• Version 4.26.1
  • Published
  • 411 kB
  • 6 dependencies
  • MIT license


npm i @typescript-eslint/experimental-utils
yarn add @typescript-eslint/experimental-utils
pnpm add @typescript-eslint/experimental-utils


(Experimental) Utilities for working with TypeScript + ESLint together




namespace ASTUtils

module 'dist/ast-utils/index.d.ts' {}


    const LINEBREAK_MATCHER: RegExp;

      variable PatternMatcher

      const PatternMatcher: new (
      pattern: RegExp,
      options?: { escaped?: boolean | undefined } | undefined
      ) => PatternMatcher;

      variable ReferenceTracker

      const ReferenceTracker: ReferenceTrackerStatic;

      function findVariable

      findVariable: (
      initialScope: any,
      name: string
      ) => TSESLint.Scope.Variable | null;

      function getFunctionHeadLocation

      getFunctionHeadLocation: (
      | TSESTree.FunctionDeclaration
      | TSESTree.FunctionExpression
      | TSESTree.ArrowFunctionExpression,
      sourceCode: TSESLint.SourceCode
      ) => any;

      function getFunctionNameWithKind

      getFunctionNameWithKind: (
      | TSESTree.FunctionDeclaration
      | TSESTree.FunctionExpression
      | TSESTree.ArrowFunctionExpression
      ) => string;

      function getInnermostScope

      getInnermostScope: (initialScope: any, node: any) => any;

      function getPropertyName

      getPropertyName: (
      node: TSESTree.MemberExpression | TSESTree.Property | TSESTree.MethodDefinition,
      | import('@typescript-eslint/scope-manager/dist/scope/Scope').Scope
      | undefined
      ) => string | null;

      function getStaticValue

      getStaticValue: (
      node: any,
      | import('@typescript-eslint/scope-manager/dist/scope/Scope').Scope
      | undefined
      ) => { value: unknown } | null;
      • Get the value of a given node if it can decide the value statically. If the 2nd parameter initialScope was given, this function tries to resolve identifier references which are in the given node as much as possible. In the resolving way, it does on the assumption that built-in global objects have not been modified. For example, it considers Symbol.iterator, String.rawhello , and Object.freeze({a: 1}).a as static.


        The { value: any } shaped object. The value property is the static value. If it couldn't compute the static value of the node, it returns null.

        See Also

      function getStringIfConstant

      getStringIfConstant: (
      node: any,
      | import('@typescript-eslint/scope-manager/dist/scope/Scope').Scope
      | undefined
      ) => string | null;

      function hasSideEffect

      hasSideEffect: (
      node: any,
      sourceCode: TSESLint.SourceCode,
      | {
      considerGetters?: boolean | undefined;
      considerImplicitTypeConversion?: boolean | undefined;
      | undefined
      ) => boolean;
      • Check whether a given node has any side effect or not. The side effect means that it may modify a certain variable or object member. This function considers the node which contains the following types as the node which has side effects: - AssignmentExpression - AwaitExpression - CallExpression - ImportExpression - NewExpression - UnaryExpression([operator = "delete"]) - UpdateExpression - YieldExpression - When options.considerGetters is true: - MemberExpression - When options.considerImplicitTypeConversion is true: - BinaryExpression([operator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in"]) - MemberExpression([computed = true]) - MethodDefinition([computed = true]) - Property([computed = true]) - UnaryExpression([operator = "-" | "+" | "!" | "~"])

        See Also

      function isArrowToken

      isArrowToken: (token: any) => token is any;

        function isAwaitExpression

        isAwaitExpression: (node: TSESTree.Node | undefined | null) => node is any;
        • Checks if a node represents an await … expression.

        function isAwaitKeyword

        isAwaitKeyword: (node: TSESTree.Token | undefined | null) => node is any;
        • Checks if a possible token is the await keyword.

        function isClassOrTypeElement

        isClassOrTypeElement: (node: TSESTree.Node | undefined) => node is any;

          function isClosingBraceToken

          isClosingBraceToken: (token: any) => token is any;

            function isClosingBracketToken

            isClosingBracketToken: (token: any) => token is any;

              function isClosingParenToken

              isClosingParenToken: (token: any) => token is any;

                function isColonToken

                isColonToken: (token: any) => token is any;

                  function isCommaToken

                  isCommaToken: (token: any) => token is any;

                    function isCommentToken

                    isCommentToken: (token: any) => token is any;

                      function isConstructor

                      isConstructor: (node: TSESTree.Node | undefined) => node is any;
                      • Checks if a node is a constructor method.

                      function isFunction

                      isFunction: (node: TSESTree.Node | undefined) => node is any;

                        function isFunctionOrFunctionType

                        isFunctionOrFunctionType: (node: TSESTree.Node | undefined) => node is any;

                          function isFunctionType

                          isFunctionType: (node: TSESTree.Node | undefined) => node is any;

                            function isIdentifier

                            isIdentifier: (node: TSESTree.Node | undefined) => node is any;

                              function isLogicalOrOperator

                              isLogicalOrOperator: (node: any) => node is any;
                              • Returns true if and only if the node represents logical OR

                              function isLoop

                              isLoop: (node: TSESTree.Node | undefined | null) => node is any;

                                function isNonNullAssertionPunctuator

                                isNonNullAssertionPunctuator: (token: any) => token is any;

                                  function isNotArrowToken

                                  isNotArrowToken: (token: any) => boolean;

                                    function isNotClosingBraceToken

                                    isNotClosingBraceToken: (token: any) => boolean;

                                      function isNotClosingBracketToken

                                      isNotClosingBracketToken: (token: any) => boolean;

                                        function isNotClosingParenToken

                                        isNotClosingParenToken: (token: any) => boolean;

                                          function isNotColonToken

                                          isNotColonToken: (token: any) => boolean;

                                            function isNotCommaToken

                                            isNotCommaToken: (token: any) => boolean;

                                              function isNotCommentToken

                                              isNotCommentToken: (token: any) => token is any;

                                                function isNotNonNullAssertionPunctuator

                                                isNotNonNullAssertionPunctuator: (token: any) => boolean;

                                                  function isNotOpeningBraceToken

                                                  isNotOpeningBraceToken: (token: any) => boolean;

                                                    function isNotOpeningBracketToken

                                                    isNotOpeningBracketToken: (token: any) => boolean;

                                                      function isNotOpeningParenToken

                                                      isNotOpeningParenToken: (token: any) => boolean;

                                                        function isNotOptionalChainPunctuator

                                                        isNotOptionalChainPunctuator: (token: any) => boolean;

                                                          function isNotSemicolonToken

                                                          isNotSemicolonToken: (token: any) => boolean;

                                                            function isOpeningBraceToken

                                                            isOpeningBraceToken: (token: any) => token is any;

                                                              function isOpeningBracketToken

                                                              isOpeningBracketToken: (token: any) => token is any;

                                                                function isOpeningParenToken

                                                                isOpeningParenToken: (token: any) => token is any;

                                                                  function isOptionalCallExpression

                                                                  isOptionalCallExpression: (node: any) => node is any;
                                                                  • Returns true if and only if the node represents: foo?.() or foo.bar?.()

                                                                  function isOptionalChainPunctuator

                                                                  isOptionalChainPunctuator: (token: any) => token is any;

                                                                    function isParenthesized

                                                                    isParenthesized: (node: any, sourceCode: TSESLint.SourceCode) => boolean;
                                                                    • Check whether a given node is parenthesized or not. This function detects it correctly even if it's parenthesized by specific syntax.


                                                                      true if the node is parenthesized. If times was given, it returns true only if the node is parenthesized the times times. For example, isParenthesized(2, node, sourceCode) returns true for ((foo)), but not for (foo).

                                                                      See Also

                                                                    function isSemicolonToken

                                                                    isSemicolonToken: (token: any) => token is any;

                                                                      function isSetter

                                                                      isSetter: (node: TSESTree.Node | undefined) => node is any;
                                                                      • Checks if a node is a setter method.

                                                                      function isTokenOnSameLine

                                                                      isTokenOnSameLine: (left: any, right: any) => boolean;
                                                                      • Determines whether two adjacent tokens are on the same line

                                                                      function isTSConstructorType

                                                                      isTSConstructorType: (node: TSESTree.Node | undefined) => node is any;

                                                                        function isTSFunctionType

                                                                        isTSFunctionType: (node: TSESTree.Node | undefined) => node is any;

                                                                          function isTypeAssertion

                                                                          isTypeAssertion: (node: TSESTree.Node | undefined | null) => node is any;
                                                                          • Checks if a node is a type assertion:

                                                                            x as foo

                                                                          function isVariableDeclarator

                                                                          isVariableDeclarator: (node: TSESTree.Node | undefined) => node is any;

                                                                            interface PatternMatcher

                                                                            interface PatternMatcher {}

                                                                              method [Symbol.replace]

                                                                              [Symbol.replace]: (
                                                                              str: string,
                                                                              replacer: string | ((...strs: string[]) => string)
                                                                              ) => string;
                                                                              • Replace all matched parts by a given replacer.

                                                                                Example 1

                                                                                const { PatternMatcher } = require("eslint-utils") const matcher = new PatternMatcher(/\p{Script=Greek}/g)

                                                                                module.exports = { meta: {}, create(context) { return { "Literal[regex]"(node) { const replacedPattern = node.regex.pattern.replace( matcher, "[\u0370-\u0373\u0375-\u0377\u037A-\u037D\u037F\u0384\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03E1\u03F0-\u03FF\u1D26-\u1D2A\u1D5D-\u1D61\u1D66-\u1D6A\u1DBF\u1F00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FC4\u1FC6-\u1FD3\u1FD6-\u1FDB\u1FDD-\u1FEF\u1FF2-\u1FF4\u1FF6-\u1FFE\u2126\uAB65]|\uD800[\uDD40-\uDD8E\uDDA0]|\uD834[\uDE00-\uDE45]" ) }, } }, }

                                                                                See Also

                                                                              method execAll

                                                                              execAll: (str: string) => IterableIterator<RegExpExecArray>;

                                                                              method test

                                                                              test: (str: string) => boolean;

                                                                              interface ReferenceTracker

                                                                              interface ReferenceTracker {}

                                                                                method iterateCjsReferences

                                                                                iterateCjsReferences: <T>(
                                                                                traceMap: ReferenceTracker.TraceMap<T>
                                                                                ) => IterableIterator<ReferenceTracker.FoundReference<T>>;

                                                                                method iterateEsmReferences

                                                                                iterateEsmReferences: <T>(
                                                                                traceMap: ReferenceTracker.TraceMap<T>
                                                                                ) => IterableIterator<ReferenceTracker.FoundReference<T>>;

                                                                                method iterateGlobalReferences

                                                                                iterateGlobalReferences: <T>(
                                                                                traceMap: ReferenceTracker.TraceMap<T>
                                                                                ) => IterableIterator<ReferenceTracker.FoundReference<T>>;

                                                                                namespace ASTUtils.ReferenceTracker

                                                                                namespace ASTUtils.ReferenceTracker {}

                                                                                  interface FoundReference

                                                                                  interface FoundReference<T = any> {}

                                                                                    property entry

                                                                                    entry: T;

                                                                                      property node

                                                                                      node: TSESTree.Node;

                                                                                        property path

                                                                                        path: readonly string[];

                                                                                          property type

                                                                                          type: ReferenceType;

                                                                                            interface TraceMapElement

                                                                                            interface TraceMapElement<T> {}

                                                                                              property [ReferenceTrackerCALL]

                                                                                              [ReferenceTrackerCALL]?: T;

                                                                                                property [ReferenceTrackerCONSTRUCT]

                                                                                                [ReferenceTrackerCONSTRUCT]?: T;

                                                                                                  property [ReferenceTrackerREAD]

                                                                                                  [ReferenceTrackerREAD]?: T;

                                                                                                    index signature

                                                                                                    [key: string]: TraceMapElement<T>;

                                                                                                      type CALL

                                                                                                      type CALL = ReferenceTrackerStatic['CALL'];

                                                                                                        type CONSTRUCT

                                                                                                        type CONSTRUCT = ReferenceTrackerStatic['CONSTRUCT'];

                                                                                                          type READ

                                                                                                          type READ = ReferenceTrackerStatic['READ'];

                                                                                                            type ReferenceType

                                                                                                            type ReferenceType = READ | CALL | CONSTRUCT;

                                                                                                              type TraceMap

                                                                                                              type TraceMap<T = any> = Record<string, TraceMapElement<T>>;

                                                                                                                namespace ESLintUtils

                                                                                                                module 'dist/eslint-utils/index.d.ts' {}

                                                                                                                  function applyDefault

                                                                                                                  applyDefault: <TUser extends readonly unknown[], TDefault extends TUser>(
                                                                                                                  defaultOptions: Readonly<TDefault>,
                                                                                                                  userOptions: Readonly<TUser> | null
                                                                                                                  ) => TDefault;
                                                                                                                  • Pure function - doesn't mutate either parameter! Uses the default options and overrides with the options provided by the user

                                                                                                                    Parameter defaultOptions

                                                                                                                    the defaults

                                                                                                                    Parameter userOptions

                                                                                                                    the user opts


                                                                                                                    the options with defaults

                                                                                                                  function batchedSingleLineTests

                                                                                                                  batchedSingleLineTests: {
                                                                                                                  <TOptions extends readonly unknown[]>(
                                                                                                                  test: ValidTestCase<TOptions>
                                                                                                                  ): ValidTestCase<TOptions>[];
                                                                                                                  <TMessageIds extends string, TOptions extends readonly unknown[]>(
                                                                                                                  test: InvalidTestCase<TMessageIds, TOptions>
                                                                                                                  ): InvalidTestCase<TMessageIds, TOptions>[];
                                                                                                                  • Converts a batch of single line tests into a number of separate test cases. This makes it easier to write tests which use the same options.

                                                                                                                    Why wouldn't you just leave them as one test? Because it makes the test error messages harder to decipher. This way each line will fail separately, instead of them all failing together.

                                                                                                                  • Converts a batch of single line tests into a number of separate test cases. This makes it easier to write tests which use the same options.

                                                                                                                    Why wouldn't you just leave them as one test? Because it makes the test error messages harder to decipher. This way each line will fail separately, instead of them all failing together.

                                                                                                                    Make sure you have your line numbers correct for error reporting, as it will match the line numbers up with the split tests!

                                                                                                                  function deepMerge

                                                                                                                  deepMerge: (first?: ObjectLike, second?: ObjectLike) => Record<string, unknown>;
                                                                                                                  • Pure function - doesn't mutate either parameter! Merges two objects together deeply, overwriting the properties in first with the properties in second

                                                                                                                    Parameter first

                                                                                                                    The first object

                                                                                                                    Parameter second

                                                                                                                    The second object


                                                                                                                    a new object

                                                                                                                  function getParserServices

                                                                                                                  getParserServices: <
                                                                                                                  TMessageIds extends string,
                                                                                                                  TOptions extends readonly unknown[]
                                                                                                                  context: Readonly<TSESLint.RuleContext<TMessageIds, TOptions>>,
                                                                                                                  allowWithoutFullTypeInformation?: boolean
                                                                                                                  ) => any;
                                                                                                                  • Try to retrieve typescript parser service from context

                                                                                                                  function isObjectNotArray

                                                                                                                  isObjectNotArray: <T extends ObjectLike<unknown>>(
                                                                                                                  obj: unknown | unknown[]
                                                                                                                  ) => obj is T;
                                                                                                                  • Check if the variable contains an object strictly rejecting arrays

                                                                                                                    Parameter obj

                                                                                                                    an object


                                                                                                                    true if obj is an object

                                                                                                                  function noFormat

                                                                                                                  noFormat: (strings: TemplateStringsArray, ...keys: string[]) => string;
                                                                                                                  • Simple no-op tag to mark code samples as "should not format with prettier" for the internal/plugin-test-formatting lint rule

                                                                                                                  function RuleCreator

                                                                                                                  RuleCreator: (
                                                                                                                  urlCreator: (ruleName: string) => string
                                                                                                                  ) => <
                                                                                                                  TOptions extends readonly unknown[],
                                                                                                                  TMessageIds extends string,
                                                                                                                  TRuleListener extends RuleListener = RuleListener
                                                                                                                  }: Readonly<{
                                                                                                                  name: string;
                                                                                                                  meta: CreateRuleMeta<TMessageIds>;
                                                                                                                  defaultOptions: Readonly<TOptions>;
                                                                                                                  create: (
                                                                                                                  context: Readonly<RuleContext<TMessageIds, TOptions>>,
                                                                                                                  optionsWithDefault: Readonly<TOptions>
                                                                                                                  ) => TRuleListener;
                                                                                                                  }>) => RuleModule<TMessageIds, TOptions, TRuleListener>;

                                                                                                                    class RuleTester

                                                                                                                    class RuleTester extends TSESLint.RuleTester {}


                                                                                                                      constructor(options: RuleTesterConfig);

                                                                                                                        method run

                                                                                                                        run: <TMessageIds extends string, TOptions extends readonly unknown[]>(
                                                                                                                        name: string,
                                                                                                                        rule: TSESLint.RuleModule<TMessageIds, TOptions>,
                                                                                                                        testsReadonly: TSESLint.RunTests<TMessageIds, TOptions>
                                                                                                                        ) => void;

                                                                                                                          type InferMessageIdsTypeFromRule

                                                                                                                          type InferMessageIdsTypeFromRule<T> = T extends RuleModule<
                                                                                                                          infer TMessageIds,
                                                                                                                          infer _TOptions
                                                                                                                          ? TMessageIds
                                                                                                                          : T extends RuleCreateFunction<infer TMessageIds, infer _TOptions>
                                                                                                                          ? TMessageIds
                                                                                                                          : unknown;
                                                                                                                          • Uses type inference to fetch the TMessageIds type from the given RuleModule

                                                                                                                          type InferOptionsTypeFromRule

                                                                                                                          type InferOptionsTypeFromRule<T> = T extends RuleModule<
                                                                                                                          infer _TMessageIds,
                                                                                                                          infer TOptions
                                                                                                                          ? TOptions
                                                                                                                          : T extends RuleCreateFunction<infer _TMessageIds, infer TOptions>
                                                                                                                          ? TOptions
                                                                                                                          : unknown;
                                                                                                                          • Uses type inference to fetch the TOptions type from the given RuleModule

                                                                                                                          namespace JSONSchema

                                                                                                                          module 'dist/json-schema.d.ts' {}

                                                                                                                            namespace TSESLint

                                                                                                                            module 'dist/ts-eslint/index.d.ts' {}

                                                                                                                              class CLIEngine

                                                                                                                              class CLIEngine extends CLIEngine_base {}
                                                                                                                              • The underlying utility that runs the ESLint command line interface. This object will read the filesystem for configuration and file information but will not output any results. Instead, it allows you direct access to the important information so you can deal with the output yourself.


                                                                                                                                use the ESLint class instead

                                                                                                                              class ESLint

                                                                                                                              class ESLint extends _ESLint {}
                                                                                                                              • The ESLint class is the primary class to use in Node.js applications. This class depends on the Node.js fs module and the file system, so you cannot use it in browsers.

                                                                                                                                If you want to lint code on browsers, use the Linter class instead.


                                                                                                                              class Linter

                                                                                                                              class Linter extends Linter_base {}
                                                                                                                              • The Linter object does the actual evaluation of the JavaScript code. It doesn't do any filesystem operations, it simply parses and reports on the code. In particular, the Linter object does not process configuration objects or files.

                                                                                                                              class RuleTester

                                                                                                                              class RuleTester extends RuleTester_base {}

                                                                                                                                class SourceCode

                                                                                                                                class SourceCode extends SourceCode_base {}

                                                                                                                                  interface InvalidTestCase

                                                                                                                                  interface InvalidTestCase<
                                                                                                                                  TMessageIds extends string,
                                                                                                                                  TOptions extends Readonly<unknown[]>
                                                                                                                                  > extends ValidTestCase<TOptions> {}

                                                                                                                                    property errors

                                                                                                                                    readonly errors: readonly TestCaseError<TMessageIds>[];
                                                                                                                                    • Expected errors.

                                                                                                                                    property output

                                                                                                                                    readonly output?: string | null;
                                                                                                                                    • The expected code after autofixes are applied. If set to null, the test runner will assert that no autofix is suggested.

                                                                                                                                    interface RuleContext

                                                                                                                                    interface RuleContext<
                                                                                                                                    TMessageIds extends string,
                                                                                                                                    TOptions extends readonly unknown[]
                                                                                                                                    > {}

                                                                                                                                      property id

                                                                                                                                      id: string;
                                                                                                                                      • The rule ID.

                                                                                                                                      property options

                                                                                                                                      options: TOptions;
                                                                                                                                      • An array of the configured options for this rule. This array does not include the rule severity.

                                                                                                                                      property parserOptions

                                                                                                                                      parserOptions: Linter.ParserOptions;
                                                                                                                                      • The parser options configured for this run

                                                                                                                                      property parserPath

                                                                                                                                      parserPath: string;
                                                                                                                                      • The name of the parser from configuration.

                                                                                                                                      property parserServices

                                                                                                                                      parserServices?: ParserServices;
                                                                                                                                      • An object containing parser-provided services for rules

                                                                                                                                      property settings

                                                                                                                                      settings: Record<string, unknown>;
                                                                                                                                      • The shared settings from configuration. We do not have any shared settings in this plugin.

                                                                                                                                      method getAncestors

                                                                                                                                      getAncestors: () => TSESTree.Node[];
                                                                                                                                      • Returns an array of the ancestors of the currently-traversed node, starting at the root of the AST and continuing through the direct parent of the current node. This array does not include the currently-traversed node itself.

                                                                                                                                      method getCwd

                                                                                                                                      getCwd: () => string;
                                                                                                                                      • Returns the current working directory passed to Linter. It is a path to a directory that should be considered as the current working directory. This was added in v6.6.0 6.6.0

                                                                                                                                      method getDeclaredVariables

                                                                                                                                      getDeclaredVariables: (node: any) => Scope.Variable[];
                                                                                                                                      • Returns a list of variables declared by the given node. This information can be used to track references to variables.

                                                                                                                                      method getFilename

                                                                                                                                      getFilename: () => string;
                                                                                                                                      • Returns the filename associated with the source.

                                                                                                                                      method getScope

                                                                                                                                      getScope: () => any;
                                                                                                                                      • Returns the scope of the currently-traversed node. This information can be used track references to variables.

                                                                                                                                      method getSourceCode

                                                                                                                                      getSourceCode: () => Readonly<SourceCode>;
                                                                                                                                      • Returns a SourceCode object that you can use to work with the source that was passed to ESLint.

                                                                                                                                      method markVariableAsUsed

                                                                                                                                      markVariableAsUsed: (name: string) => boolean;
                                                                                                                                      • Marks a variable with the given name in the current scope as used. This affects the no-unused-vars rule.

                                                                                                                                      method report

                                                                                                                                      report: (descriptor: ReportDescriptor<TMessageIds>) => void;
                                                                                                                                      • Reports a problem in the code.

                                                                                                                                      interface RuleFix

                                                                                                                                      interface RuleFix {}

                                                                                                                                        property range

                                                                                                                                        range: AST.Range;

                                                                                                                                          property text

                                                                                                                                          text: string;

                                                                                                                                            interface RuleFixer

                                                                                                                                            interface RuleFixer {}

                                                                                                                                              method insertTextAfter

                                                                                                                                              insertTextAfter: (
                                                                                                                                              nodeOrToken: TSESTree.Node | TSESTree.Token,
                                                                                                                                              text: string
                                                                                                                                              ) => RuleFix;

                                                                                                                                                method insertTextAfterRange

                                                                                                                                                insertTextAfterRange: (range: any, text: string) => RuleFix;

                                                                                                                                                  method insertTextBefore

                                                                                                                                                  insertTextBefore: (
                                                                                                                                                  nodeOrToken: TSESTree.Node | TSESTree.Token,
                                                                                                                                                  text: string
                                                                                                                                                  ) => RuleFix;

                                                                                                                                                    method insertTextBeforeRange

                                                                                                                                                    insertTextBeforeRange: (range: any, text: string) => RuleFix;

                                                                                                                                                      method remove

                                                                                                                                                      remove: (nodeOrToken: TSESTree.Node | TSESTree.Token) => RuleFix;

                                                                                                                                                        method removeRange

                                                                                                                                                        removeRange: (range: any) => RuleFix;

                                                                                                                                                          method replaceText

                                                                                                                                                          replaceText: (
                                                                                                                                                          nodeOrToken: TSESTree.Node | TSESTree.Token,
                                                                                                                                                          text: string
                                                                                                                                                          ) => RuleFix;

                                                                                                                                                            method replaceTextRange

                                                                                                                                                            replaceTextRange: (range: any, text: string) => RuleFix;

                                                                                                                                                              interface RuleListener

                                                                                                                                                              interface RuleListener {}

                                                                                                                                                                property ArrayExpression

                                                                                                                                                                ArrayExpression?: RuleFunction<TSESTree.ArrayExpression>;

                                                                                                                                                                  property ArrayPattern

                                                                                                                                                                  ArrayPattern?: RuleFunction<TSESTree.ArrayPattern>;

                                                                                                                                                                    property ArrowFunctionExpression

                                                                                                                                                                    ArrowFunctionExpression?: RuleFunction<TSESTree.ArrowFunctionExpression>;

                                                                                                                                                                      property AssignmentExpression

                                                                                                                                                                      AssignmentExpression?: RuleFunction<TSESTree.AssignmentExpression>;

                                                                                                                                                                        property AssignmentPattern

                                                                                                                                                                        AssignmentPattern?: RuleFunction<TSESTree.AssignmentPattern>;

                                                                                                                                                                          property AwaitExpression

                                                                                                                                                                          AwaitExpression?: RuleFunction<TSESTree.AwaitExpression>;

                                                                                                                                                                            property BigIntLiteral

                                                                                                                                                                            BigIntLiteral?: RuleFunction<TSESTree.BigIntLiteral>;

                                                                                                                                                                              property BinaryExpression

                                                                                                                                                                              BinaryExpression?: RuleFunction<TSESTree.BinaryExpression>;

                                                                                                                                                                                property BlockStatement

                                                                                                                                                                                BlockStatement?: RuleFunction<TSESTree.BlockStatement>;

                                                                                                                                                                                  property BreakStatement

                                                                                                                                                                                  BreakStatement?: RuleFunction<TSESTree.BreakStatement>;

                                                                                                                                                                                    property CallExpression

                                                                                                                                                                                    CallExpression?: RuleFunction<TSESTree.CallExpression>;

                                                                                                                                                                                      property CatchClause

                                                                                                                                                                                      CatchClause?: RuleFunction<TSESTree.CatchClause>;

                                                                                                                                                                                        property ChainExpression

                                                                                                                                                                                        ChainExpression?: RuleFunction<TSESTree.ChainExpression>;

                                                                                                                                                                                          property ClassBody

                                                                                                                                                                                          ClassBody?: RuleFunction<TSESTree.ClassBody>;

                                                                                                                                                                                            property ClassDeclaration

                                                                                                                                                                                            ClassDeclaration?: RuleFunction<TSESTree.ClassDeclaration>;

                                                                                                                                                                                              property ClassExpression

                                                                                                                                                                                              ClassExpression?: RuleFunction<TSESTree.ClassExpression>;

                                                                                                                                                                                                property ClassProperty

                                                                                                                                                                                                ClassProperty?: RuleFunction<TSESTree.ClassProperty>;

                                                                                                                                                                                                  property Comment

                                                                                                                                                                                                  Comment?: RuleFunction<TSESTree.Comment>;

                                                                                                                                                                                                    property ConditionalExpression

                                                                                                                                                                                                    ConditionalExpression?: RuleFunction<TSESTree.ConditionalExpression>;

                                                                                                                                                                                                      property ContinueStatement

                                                                                                                                                                                                      ContinueStatement?: RuleFunction<TSESTree.ContinueStatement>;

                                                                                                                                                                                                        property DebuggerStatement

                                                                                                                                                                                                        DebuggerStatement?: RuleFunction<TSESTree.DebuggerStatement>;

                                                                                                                                                                                                          property Decorator

                                                                                                                                                                                                          Decorator?: RuleFunction<TSESTree.Decorator>;

                                                                                                                                                                                                            property DoWhileStatement

                                                                                                                                                                                                            DoWhileStatement?: RuleFunction<TSESTree.DoWhileStatement>;

                                                                                                                                                                                                              property EmptyStatement

                                                                                                                                                                                                              EmptyStatement?: RuleFunction<TSESTree.EmptyStatement>;

                                                                                                                                                                                                                property ExportAllDeclaration

                                                                                                                                                                                                                ExportAllDeclaration?: RuleFunction<TSESTree.ExportAllDeclaration>;

                                                                                                                                                                                                                  property ExportDefaultDeclaration

                                                                                                                                                                                                                  ExportDefaultDeclaration?: RuleFunction<TSESTree.ExportDefaultDeclaration>;

                                                                                                                                                                                                                    property ExportNamedDeclaration

                                                                                                                                                                                                                    ExportNamedDeclaration?: RuleFunction<TSESTree.ExportNamedDeclaration>;

                                                                                                                                                                                                                      property ExportSpecifier

                                                                                                                                                                                                                      ExportSpecifier?: RuleFunction<TSESTree.ExportSpecifier>;

                                                                                                                                                                                                                        property ExpressionStatement

                                                                                                                                                                                                                        ExpressionStatement?: RuleFunction<TSESTree.ExpressionStatement>;

                                                                                                                                                                                                                          property ForInStatement

                                                                                                                                                                                                                          ForInStatement?: RuleFunction<TSESTree.ForInStatement>;

                                                                                                                                                                                                                            property ForOfStatement

                                                                                                                                                                                                                            ForOfStatement?: RuleFunction<TSESTree.ForOfStatement>;

                                                                                                                                                                                                                              property ForStatement

                                                                                                                                                                                                                              ForStatement?: RuleFunction<TSESTree.ForStatement>;

                                                                                                                                                                                                                                property FunctionDeclaration

                                                                                                                                                                                                                                FunctionDeclaration?: RuleFunction<TSESTree.FunctionDeclaration>;

                                                                                                                                                                                                                                  property FunctionExpression

                                                                                                                                                                                                                                  FunctionExpression?: RuleFunction<TSESTree.FunctionExpression>;

                                                                                                                                                                                                                                    property Identifier

                                                                                                                                                                                                                                    Identifier?: RuleFunction<TSESTree.Identifier>;

                                                                                                                                                                                                                                      property IfStatement

                                                                                                                                                                                                                                      IfStatement?: RuleFunction<TSESTree.IfStatement>;

                                                                                                                                                                                                                                        property ImportDeclaration

                                                                                                                                                                                                                                        ImportDeclaration?: RuleFunction<TSESTree.ImportDeclaration>;

                                                                                                                                                                                                                                          property ImportDefaultSpecifier

                                                                                                                                                                                                                                          ImportDefaultSpecifier?: RuleFunction<TSESTree.ImportDefaultSpecifier>;

                                                                                                                                                                                                                                            property ImportExpression

                                                                                                                                                                                                                                            ImportExpression?: RuleFunction<TSESTree.ImportExpression>;

                                                                                                                                                                                                                                              property ImportNamespaceSpecifier

                                                                                                                                                                                                                                              ImportNamespaceSpecifier?: RuleFunction<TSESTree.ImportNamespaceSpecifier>;

                                                                                                                                                                                                                                                property ImportSpecifier

                                                                                                                                                                                                                                                ImportSpecifier?: RuleFunction<TSESTree.ImportSpecifier>;

                                                                                                                                                                                                                                                  property JSXAttribute

                                                                                                                                                                                                                                                  JSXAttribute?: RuleFunction<TSESTree.JSXAttribute>;

                                                                                                                                                                                                                                                    property JSXClosingElement

                                                                                                                                                                                                                                                    JSXClosingElement?: RuleFunction<TSESTree.JSXClosingElement>;

                                                                                                                                                                                                                                                      property JSXClosingFragment

                                                                                                                                                                                                                                                      JSXClosingFragment?: RuleFunction<TSESTree.JSXClosingFragment>;

                                                                                                                                                                                                                                                        property JSXElement

                                                                                                                                                                                                                                                        JSXElement?: RuleFunction<TSESTree.JSXElement>;

                                                                                                                                                                                                                                                          property JSXEmptyExpression

                                                                                                                                                                                                                                                          JSXEmptyExpression?: RuleFunction<TSESTree.JSXEmptyExpression>;

                                                                                                                                                                                                                                                            property JSXExpressionContainer

                                                                                                                                                                                                                                                            JSXExpressionContainer?: RuleFunction<TSESTree.JSXExpressionContainer>;

                                                                                                                                                                                                                                                              property JSXFragment

                                                                                                                                                                                                                                                              JSXFragment?: RuleFunction<TSESTree.JSXFragment>;

                                                                                                                                                                                                                                                                property JSXIdentifier

                                                                                                                                                                                                                                                                JSXIdentifier?: RuleFunction<TSESTree.JSXIdentifier>;

                                                                                                                                                                                                                                                                  property JSXMemberExpression

                                                                                                                                                                                                                                                                  JSXMemberExpression?: RuleFunction<TSESTree.JSXMemberExpression>;

                                                                                                                                                                                                                                                                    property JSXOpeningElement

                                                                                                                                                                                                                                                                    JSXOpeningElement?: RuleFunction<TSESTree.JSXOpeningElement>;

                                                                                                                                                                                                                                                                      property JSXOpeningFragment

                                                                                                                                                                                                                                                                      JSXOpeningFragment?: RuleFunction<TSESTree.JSXOpeningFragment>;

                                                                                                                                                                                                                                                                        property JSXSpreadAttribute

                                                                                                                                                                                                                                                                        JSXSpreadAttribute?: RuleFunction<TSESTree.JSXSpreadAttribute>;

                                                                                                                                                                                                                                                                          property JSXSpreadChild

                                                                                                                                                                                                                                                                          JSXSpreadChild?: RuleFunction<TSESTree.JSXSpreadChild>;

                                                                                                                                                                                                                                                                            property JSXText

                                                                                                                                                                                                                                                                            JSXText?: RuleFunction<TSESTree.JSXText>;

                                                                                                                                                                                                                                                                              property LabeledStatement

                                                                                                                                                                                                                                                                              LabeledStatement?: RuleFunction<TSESTree.LabeledStatement>;

                                                                                                                                                                                                                                                                                property Literal

                                                                                                                                                                                                                                                                                Literal?: RuleFunction<TSESTree.Literal>;

                                                                                                                                                                                                                                                                                  property LogicalExpression

                                                                                                                                                                                                                                                                                  LogicalExpression?: RuleFunction<TSESTree.LogicalExpression>;

                                                                                                                                                                                                                                                                                    property MemberExpression

                                                                                                                                                                                                                                                                                    MemberExpression?: RuleFunction<TSESTree.MemberExpression>;

                                                                                                                                                                                                                                                                                      property MetaProperty

                                                                                                                                                                                                                                                                                      MetaProperty?: RuleFunction<TSESTree.MetaProperty>;

                                                                                                                                                                                                                                                                                        property MethodDefinition

                                                                                                                                                                                                                                                                                        MethodDefinition?: RuleFunction<TSESTree.MethodDefinition>;

                                                                                                                                                                                                                                                                                          property NewExpression

                                                                                                                                                                                                                                                                                          NewExpression?: RuleFunction<TSESTree.NewExpression>;

                                                                                                                                                                                                                                                                                            property ObjectExpression

                                                                                                                                                                                                                                                                                            ObjectExpression?: RuleFunction<TSESTree.ObjectExpression>;

                                                                                                                                                                                                                                                                                              property ObjectPattern

                                                                                                                                                                                                                                                                                              ObjectPattern?: RuleFunction<TSESTree.ObjectPattern>;

                                                                                                                                                                                                                                                                                                property Program

                                                                                                                                                                                                                                                                                                Program?: RuleFunction<TSESTree.Program>;

                                                                                                                                                                                                                                                                                                  property Property

                                                                                                                                                                                                                                                                                                  Property?: RuleFunction<TSESTree.Property>;

                                                                                                                                                                                                                                                                                                    property RestElement

                                                                                                                                                                                                                                                                                                    RestElement?: RuleFunction<TSESTree.RestElement>;

                                                                                                                                                                                                                                                                                                      property ReturnStatement

                                                                                                                                                                                                                                                                                                      ReturnStatement?: RuleFunction<TSESTree.ReturnStatement>;

                                                                                                                                                                                                                                                                                                        property SequenceExpression

                                                                                                                                                                                                                                                                                                        SequenceExpression?: RuleFunction<TSESTree.SequenceExpression>;

                                                                                                                                                                                                                                                                                                          property SpreadElement

                                                                                                                                                                                                                                                                                                          SpreadElement?: RuleFunction<TSESTree.SpreadElement>;

                                                                                                                                                                                                                                                                                                            property Super

                                                                                                                                                                                                                                                                                                            Super?: RuleFunction<TSESTree.Super>;

                                                                                                                                                                                                                                                                                                              property SwitchCase

                                                                                                                                                                                                                                                                                                              SwitchCase?: RuleFunction<TSESTree.SwitchCase>;

                                                                                                                                                                                                                                                                                                                property SwitchStatement

                                                                                                                                                                                                                                                                                                                SwitchStatement?: RuleFunction<TSESTree.SwitchStatement>;

                                                                                                                                                                                                                                                                                                                  property TaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                  TaggedTemplateExpression?: RuleFunction<TSESTree.TaggedTemplateExpression>;

                                                                                                                                                                                                                                                                                                                    property TemplateElement

                                                                                                                                                                                                                                                                                                                    TemplateElement?: RuleFunction<TSESTree.TemplateElement>;

                                                                                                                                                                                                                                                                                                                      property TemplateLiteral

                                                                                                                                                                                                                                                                                                                      TemplateLiteral?: RuleFunction<TSESTree.TemplateLiteral>;

                                                                                                                                                                                                                                                                                                                        property ThisExpression

                                                                                                                                                                                                                                                                                                                        ThisExpression?: RuleFunction<TSESTree.ThisExpression>;

                                                                                                                                                                                                                                                                                                                          property ThrowStatement

                                                                                                                                                                                                                                                                                                                          ThrowStatement?: RuleFunction<TSESTree.ThrowStatement>;

                                                                                                                                                                                                                                                                                                                            property Token

                                                                                                                                                                                                                                                                                                                            Token?: RuleFunction<TSESTree.Token>;

                                                                                                                                                                                                                                                                                                                              property TryStatement

                                                                                                                                                                                                                                                                                                                              TryStatement?: RuleFunction<TSESTree.TryStatement>;

                                                                                                                                                                                                                                                                                                                                property TSAbstractClassProperty

                                                                                                                                                                                                                                                                                                                                TSAbstractClassProperty?: RuleFunction<TSESTree.TSAbstractClassProperty>;

                                                                                                                                                                                                                                                                                                                                  property TSAbstractKeyword

                                                                                                                                                                                                                                                                                                                                  TSAbstractKeyword?: RuleFunction<TSESTree.TSAbstractKeyword>;

                                                                                                                                                                                                                                                                                                                                    property TSAbstractMethodDefinition

                                                                                                                                                                                                                                                                                                                                    TSAbstractMethodDefinition?: RuleFunction<TSESTree.TSAbstractMethodDefinition>;

                                                                                                                                                                                                                                                                                                                                      property TSAnyKeyword

                                                                                                                                                                                                                                                                                                                                      TSAnyKeyword?: RuleFunction<TSESTree.TSAnyKeyword>;

                                                                                                                                                                                                                                                                                                                                        property TSArrayType

                                                                                                                                                                                                                                                                                                                                        TSArrayType?: RuleFunction<TSESTree.TSArrayType>;

                                                                                                                                                                                                                                                                                                                                          property TSAsExpression

                                                                                                                                                                                                                                                                                                                                          TSAsExpression?: RuleFunction<TSESTree.TSAsExpression>;

                                                                                                                                                                                                                                                                                                                                            property TSAsyncKeyword

                                                                                                                                                                                                                                                                                                                                            TSAsyncKeyword?: RuleFunction<TSESTree.TSAsyncKeyword>;

                                                                                                                                                                                                                                                                                                                                              property TSBigIntKeyword

                                                                                                                                                                                                                                                                                                                                              TSBigIntKeyword?: RuleFunction<TSESTree.TSBigIntKeyword>;

                                                                                                                                                                                                                                                                                                                                                property TSBooleanKeyword

                                                                                                                                                                                                                                                                                                                                                TSBooleanKeyword?: RuleFunction<TSESTree.TSBooleanKeyword>;

                                                                                                                                                                                                                                                                                                                                                  property TSCallSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                  TSCallSignatureDeclaration?: RuleFunction<TSESTree.TSCallSignatureDeclaration>;

                                                                                                                                                                                                                                                                                                                                                    property TSClassImplements

                                                                                                                                                                                                                                                                                                                                                    TSClassImplements?: RuleFunction<TSESTree.TSClassImplements>;

                                                                                                                                                                                                                                                                                                                                                      property TSConditionalType

                                                                                                                                                                                                                                                                                                                                                      TSConditionalType?: RuleFunction<TSESTree.TSConditionalType>;

                                                                                                                                                                                                                                                                                                                                                        property TSConstructorType

                                                                                                                                                                                                                                                                                                                                                        TSConstructorType?: RuleFunction<TSESTree.TSConstructorType>;

                                                                                                                                                                                                                                                                                                                                                          property TSConstructSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                          TSConstructSignatureDeclaration?: RuleFunction<TSESTree.TSConstructSignatureDeclaration>;

                                                                                                                                                                                                                                                                                                                                                            property TSDeclareFunction

                                                                                                                                                                                                                                                                                                                                                            TSDeclareFunction?: RuleFunction<TSESTree.TSDeclareFunction>;

                                                                                                                                                                                                                                                                                                                                                              property TSDeclareKeyword

                                                                                                                                                                                                                                                                                                                                                              TSDeclareKeyword?: RuleFunction<TSESTree.TSDeclareKeyword>;

                                                                                                                                                                                                                                                                                                                                                                property TSEmptyBodyFunctionExpression

                                                                                                                                                                                                                                                                                                                                                                TSEmptyBodyFunctionExpression?: RuleFunction<TSESTree.TSEmptyBodyFunctionExpression>;

                                                                                                                                                                                                                                                                                                                                                                  property TSEnumDeclaration

                                                                                                                                                                                                                                                                                                                                                                  TSEnumDeclaration?: RuleFunction<TSESTree.TSEnumDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                    property TSEnumMember

                                                                                                                                                                                                                                                                                                                                                                    TSEnumMember?: RuleFunction<TSESTree.TSEnumMember>;

                                                                                                                                                                                                                                                                                                                                                                      property TSExportAssignment

                                                                                                                                                                                                                                                                                                                                                                      TSExportAssignment?: RuleFunction<TSESTree.TSExportAssignment>;

                                                                                                                                                                                                                                                                                                                                                                        property TSExportKeyword

                                                                                                                                                                                                                                                                                                                                                                        TSExportKeyword?: RuleFunction<TSESTree.TSExportKeyword>;

                                                                                                                                                                                                                                                                                                                                                                          property TSExternalModuleReference

                                                                                                                                                                                                                                                                                                                                                                          TSExternalModuleReference?: RuleFunction<TSESTree.TSExternalModuleReference>;

                                                                                                                                                                                                                                                                                                                                                                            property TSFunctionType

                                                                                                                                                                                                                                                                                                                                                                            TSFunctionType?: RuleFunction<TSESTree.TSFunctionType>;

                                                                                                                                                                                                                                                                                                                                                                              property TSImportEqualsDeclaration

                                                                                                                                                                                                                                                                                                                                                                              TSImportEqualsDeclaration?: RuleFunction<TSESTree.TSImportEqualsDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                property TSImportType

                                                                                                                                                                                                                                                                                                                                                                                TSImportType?: RuleFunction<TSESTree.TSImportType>;

                                                                                                                                                                                                                                                                                                                                                                                  property TSIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                  TSIndexedAccessType?: RuleFunction<TSESTree.TSIndexedAccessType>;

                                                                                                                                                                                                                                                                                                                                                                                    property TSIndexSignature

                                                                                                                                                                                                                                                                                                                                                                                    TSIndexSignature?: RuleFunction<TSESTree.TSIndexSignature>;

                                                                                                                                                                                                                                                                                                                                                                                      property TSInferType

                                                                                                                                                                                                                                                                                                                                                                                      TSInferType?: RuleFunction<TSESTree.TSInferType>;

                                                                                                                                                                                                                                                                                                                                                                                        property TSInterfaceBody

                                                                                                                                                                                                                                                                                                                                                                                        TSInterfaceBody?: RuleFunction<TSESTree.TSInterfaceBody>;

                                                                                                                                                                                                                                                                                                                                                                                          property TSInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                          TSInterfaceDeclaration?: RuleFunction<TSESTree.TSInterfaceDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                            property TSInterfaceHeritage

                                                                                                                                                                                                                                                                                                                                                                                            TSInterfaceHeritage?: RuleFunction<TSESTree.TSInterfaceHeritage>;

                                                                                                                                                                                                                                                                                                                                                                                              property TSIntersectionType

                                                                                                                                                                                                                                                                                                                                                                                              TSIntersectionType?: RuleFunction<TSESTree.TSIntersectionType>;

                                                                                                                                                                                                                                                                                                                                                                                                property TSLiteralType

                                                                                                                                                                                                                                                                                                                                                                                                TSLiteralType?: RuleFunction<TSESTree.TSLiteralType>;

                                                                                                                                                                                                                                                                                                                                                                                                  property TSMappedType

                                                                                                                                                                                                                                                                                                                                                                                                  TSMappedType?: RuleFunction<TSESTree.TSMappedType>;

                                                                                                                                                                                                                                                                                                                                                                                                    property TSMethodSignature

                                                                                                                                                                                                                                                                                                                                                                                                    TSMethodSignature?: RuleFunction<TSESTree.TSMethodSignature>;

                                                                                                                                                                                                                                                                                                                                                                                                      property TSModuleBlock

                                                                                                                                                                                                                                                                                                                                                                                                      TSModuleBlock?: RuleFunction<TSESTree.TSModuleBlock>;

                                                                                                                                                                                                                                                                                                                                                                                                        property TSModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                        TSModuleDeclaration?: RuleFunction<TSESTree.TSModuleDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                          property TSNamespaceExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                          TSNamespaceExportDeclaration?: RuleFunction<TSESTree.TSNamespaceExportDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                            property TSNeverKeyword

                                                                                                                                                                                                                                                                                                                                                                                                            TSNeverKeyword?: RuleFunction<TSESTree.TSNeverKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                              property TSNonNullExpression

                                                                                                                                                                                                                                                                                                                                                                                                              TSNonNullExpression?: RuleFunction<TSESTree.TSNonNullExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                property TSNullKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                TSNullKeyword?: RuleFunction<TSESTree.TSNullKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                  property TSNumberKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                  TSNumberKeyword?: RuleFunction<TSESTree.TSNumberKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                    property TSObjectKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                    TSObjectKeyword?: RuleFunction<TSESTree.TSObjectKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                      property TSOptionalType

                                                                                                                                                                                                                                                                                                                                                                                                                      TSOptionalType?: RuleFunction<TSESTree.TSOptionalType>;

                                                                                                                                                                                                                                                                                                                                                                                                                        property TSParameterProperty

                                                                                                                                                                                                                                                                                                                                                                                                                        TSParameterProperty?: RuleFunction<TSESTree.TSParameterProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                          property TSParenthesizedType

                                                                                                                                                                                                                                                                                                                                                                                                                          TSParenthesizedType?: RuleFunction<TSESTree.TSParenthesizedType>;

                                                                                                                                                                                                                                                                                                                                                                                                                            property TSPrivateKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                            TSPrivateKeyword?: RuleFunction<TSESTree.TSPrivateKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                              property TSPropertySignature

                                                                                                                                                                                                                                                                                                                                                                                                                              TSPropertySignature?: RuleFunction<TSESTree.TSPropertySignature>;

                                                                                                                                                                                                                                                                                                                                                                                                                                property TSProtectedKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                TSProtectedKeyword?: RuleFunction<TSESTree.TSProtectedKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property TSPublicKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                  TSPublicKeyword?: RuleFunction<TSESTree.TSPublicKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property TSQualifiedName

                                                                                                                                                                                                                                                                                                                                                                                                                                    TSQualifiedName?: RuleFunction<TSESTree.TSQualifiedName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property TSReadonlyKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                      TSReadonlyKeyword?: RuleFunction<TSESTree.TSReadonlyKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property TSRestType

                                                                                                                                                                                                                                                                                                                                                                                                                                        TSRestType?: RuleFunction<TSESTree.TSRestType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property TSStaticKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                          TSStaticKeyword?: RuleFunction<TSESTree.TSStaticKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property TSStringKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                            TSStringKeyword?: RuleFunction<TSESTree.TSStringKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property TSSymbolKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                              TSSymbolKeyword?: RuleFunction<TSESTree.TSSymbolKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property TSThisType

                                                                                                                                                                                                                                                                                                                                                                                                                                                TSThisType?: RuleFunction<TSESTree.TSThisType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property TSTupleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                  TSTupleType?: RuleFunction<TSESTree.TSTupleType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property TSTypeAliasDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                    TSTypeAliasDeclaration?: RuleFunction<TSESTree.TSTypeAliasDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property TSTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSTypeAnnotation?: RuleFunction<TSESTree.TSTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property TSTypeAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSTypeAssertion?: RuleFunction<TSESTree.TSTypeAssertion>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property TSTypeLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSTypeLiteral?: RuleFunction<TSESTree.TSTypeLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property TSTypeOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                            TSTypeOperator?: RuleFunction<TSESTree.TSTypeOperator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property TSTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                              TSTypeParameter?: RuleFunction<TSESTree.TSTypeParameter>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property TSTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                TSTypeParameterDeclaration?: RuleFunction<TSESTree.TSTypeParameterDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property TSTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TSTypeParameterInstantiation?: RuleFunction<TSESTree.TSTypeParameterInstantiation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property TSTypePredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TSTypePredicate?: RuleFunction<TSESTree.TSTypePredicate>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property TSTypeQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TSTypeQuery?: RuleFunction<TSESTree.TSTypeQuery>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property TSTypeReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TSTypeReference?: RuleFunction<TSESTree.TSTypeReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property TSUndefinedKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TSUndefinedKeyword?: RuleFunction<TSESTree.TSUndefinedKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property TSUnionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TSUnionType?: RuleFunction<TSESTree.TSUnionType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property TSUnknownKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TSUnknownKeyword?: RuleFunction<TSESTree.TSUnknownKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property TSVoidKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TSVoidKeyword?: RuleFunction<TSESTree.TSVoidKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property UnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UnaryExpression?: RuleFunction<TSESTree.UnaryExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property UpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UpdateExpression?: RuleFunction<TSESTree.UpdateExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property VariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      VariableDeclaration?: RuleFunction<TSESTree.VariableDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property VariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        VariableDeclarator?: RuleFunction<TSESTree.VariableDeclarator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property WhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WhileStatement?: RuleFunction<TSESTree.WhileStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property WithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            WithStatement?: RuleFunction<TSESTree.WithStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property YieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              YieldExpression?: RuleFunction<TSESTree.YieldExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [nodeSelector: string]: RuleFunction | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RuleMetaData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RuleMetaData<TMessageIds extends string> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    deprecated?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • True if the rule is deprecated, false otherwise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property docs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    docs?: RuleMetaDataDocs;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Documentation for the rule, unnecessary for custom rules/plugins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fixable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fixable?: 'code' | 'whitespace';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The fixer category. Omit if there is no fixer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    messages: Record<TMessageIds, string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A map of messages which the rule can report. The key is the messageId, and the string is the parameterised error string. See: https://eslint.org/docs/developer-guide/working-with-rules#messageids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property replacedBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    replacedBy?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The name of the rule this rule was replaced by, if it was deprecated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    schema: JSONSchema4 | JSONSchema4[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The options schema. Supply an empty array if there are no options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'suggestion' | 'problem' | 'layout';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The type of rule. - "problem" means the rule is identifying code that either will cause an error or may cause a confusing behavior. Developers should consider this a high priority to resolve. - "suggestion" means the rule is identifying something that could be done in a better way but no errors will occur if the code isn’t changed. - "layout" means the rule cares primarily about whitespace, semicolons, commas, and parentheses, all the parts of the program that determine how the code looks rather than how it executes. These rules work on parts of the code that aren’t specified in the AST.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RuleMetaDataDocs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RuleMetaDataDocs {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property category

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Best Practices'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Stylistic Issues'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Variables'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Possible Errors';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The general category the rule falls within

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Concise description of the rule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property extendsBaseRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extendsBaseRule?: boolean | string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Does the rule extend (or is it based off of) an ESLint code rule? Alternately accepts the name of the base rule, in case the rule has been renamed. This is only used for documentation purposes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property recommended

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      recommended: 'error' | 'warn' | false;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The recommendation level for the rule. Used by the build tools to generate the recommended config. Set to false to not include it as a recommendation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property requiresTypeChecking

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      requiresTypeChecking?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Does the rule require us to create a full TypeScript Program in order for it to type-check code. This is only used for documentation purposes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property suggestion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      suggestion?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Specifies whether the rule can return suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      url: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The URL of the rule's docs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RuleModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface RuleModule<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TMessageIds extends string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TOptions extends readonly unknown[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TRuleListener extends RuleListener = RuleListener
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property meta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        meta: RuleMetaData<TMessageIds>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Metadata about the rule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        create: (context: Readonly<RuleContext<TMessageIds, TOptions>>) => TRuleListener;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Function which returns an object with methods that ESLint calls to “visit” nodes while traversing the abstract syntax tree.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RuleTesterConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RuleTesterConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly parser: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly parserOptions?: Readonly<ParserOptions>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RunTests

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RunTests<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TMessageIds extends string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TOptions extends Readonly<unknown[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property invalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly invalid: readonly InvalidTestCase<TMessageIds, TOptions>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property valid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly valid: readonly (ValidTestCase<TOptions> | string)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SuggestionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SuggestionOutput<TMessageIds extends string> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly data?: Readonly<Record<string, unknown>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The data used to fill the message template.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly messageId: TMessageIds;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Reported message ID.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly output: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • NOTE: Suggestions will be applied as a stand-alone change, without triggering multi-pass fixes. Each individual error has its own suggestion, so you have to show the correct, _isolated_ output for each suggestion.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TestCaseError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TestCaseError<TMessageIds extends string> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly column?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The 1-based column number of the reported start location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly data?: Readonly<Record<string, unknown>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The data used to fill the message template.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property endColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly endColumn?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The 1-based column number of the reported end location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property endLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly endLine?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The 1-based line number of the reported end location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly line?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The 1-based line number of the reported start location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly messageId: TMessageIds;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Reported message ID.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property suggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly suggestions?: SuggestionOutput<TMessageIds>[] | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Reported suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly type?: AST_NODE_TYPES | AST_TOKEN_TYPES;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The type of the reported AST node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ValidTestCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ValidTestCase<TOptions extends Readonly<unknown[]>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly code: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Code for the test case.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property env

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly env?: Readonly<Record<string, boolean>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Environments for the test case.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property filename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly filename?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The fake filename for the test case. Useful for rules that make assertion about filenames.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property globals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly globals?: Record<string, 'readonly' | 'writable' | 'off' | true>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The additional global variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly options?: Readonly<TOptions>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Options for the test case.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly parser?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • The absolute path for the parser.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly parserOptions?: Readonly<ParserOptions>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Options for the parser.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly settings?: Readonly<Record<string, unknown>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Settings for the test case.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ReportDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ReportDescriptor<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TMessageIds extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > = ReportDescriptorWithSuggestion<TMessageIds> &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (ReportDescriptorNodeOptionalLoc | ReportDescriptorLocOnly);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ReportFixFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ReportFixFunction = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fixer: RuleFixer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => null | RuleFix | RuleFix[] | IterableIterator<RuleFix>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ReportSuggestionArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ReportSuggestionArray<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TMessageIds extends string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > = ReportDescriptorBase<TMessageIds>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RuleCreateFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RuleCreateFunction<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TMessageIds extends string = never,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TOptions extends readonly unknown[] = unknown[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TRuleListener extends RuleListener = RuleListener
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > = (context: Readonly<RuleContext<TMessageIds, TOptions>>) => TRuleListener;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RuleFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RuleFunction<T extends TSESTree.BaseNode = never> = (node: T) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace TSESLint.AST

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace TSESLint.AST {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Range = TSESTree.Range;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SourceLocation = TSESTree.SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Token

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Token = TSESTree.Token;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TokenType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TokenType = AST_TOKEN_TYPES;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace TSESLint.CLIEngine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace TSESLint.CLIEngine {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DeprecatedRuleUse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface DeprecatedRuleUse {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property replacedBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  replacedBy: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ruleId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ruleId: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LintReport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LintReport {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property errorCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errorCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fixableErrorCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fixableErrorCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fixableWarningCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fixableWarningCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property results

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              results: LintResult[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property usedDeprecatedRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                usedDeprecatedRules: DeprecatedRuleUse[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property warningCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  warningCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LintResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface LintResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property errorCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      errorCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property filePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        filePath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property fixableErrorCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fixableErrorCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fixableWarningCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fixableWarningCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              messages: Linter.LintMessage[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                output?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property warningCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    warningCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LintResultData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LintResultData<TMessageIds extends string> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property rulesMeta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rulesMeta: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [ruleId: string]: RuleMetaData<TMessageIds>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Options {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property allowInlineConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            allowInlineConfig?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property baseConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | false
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [name: string]: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cache?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cacheFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cacheFile?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cacheLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cacheLocation?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property configFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      configFile?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cwd?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property envs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          envs?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property errorOnUnmatchedPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            errorOnUnmatchedPattern?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extensions?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fix?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property globals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  globals?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ignore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ignore?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ignorePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignorePath?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ignorePattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ignorePattern?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parser?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parserOptions?: Linter.ParserOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property plugins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              plugins?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reportUnusedDisableDirectives?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property resolvePluginsRelativeTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resolvePluginsRelativeTo?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rulePaths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rulePaths?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property rules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rules?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [name: string]: Linter.RuleLevel | Linter.RuleLevelAndOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property useEslintrc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        useEslintrc?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Formatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Formatter = <TMessageIds extends string>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          results: LintResult[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data?: LintResultData<TMessageIds>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace TSESLint.ESLint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace TSESLint.ESLint {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DeprecatedRuleInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DeprecatedRuleInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property replacedBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                replacedBy: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The rule IDs that replace this deprecated rule.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ruleId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ruleId: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The rule ID.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditInfo {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The EditInfo value is information to edit text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This edit information means replacing the range of the range property by the text property value. It's like sourceCodeText.slice(0, edit.range[0]) + edit.text + sourceCodeText.slice(edit.range[1]). Therefore, it's an add if the range[0] and range[1] property values are the same value, and it's removal if the text property value is empty string.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                range: [number, number];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The pair of 0-based indices in source code text to remove.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                text: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The text to add.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ESLintOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ESLintOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property allowInlineConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  allowInlineConfig?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If false is present, ESLint suppresses directive comments in source code. If this option is false, it overrides the noInlineConfig setting in your configurations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property baseConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  baseConfig?: Linter.Config | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Configuration object, extended by all configurations used with this instance. You can use this option to define the default settings that will be used if your configuration files don't configure it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cache?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If true is present, the eslint.lintFiles() method caches lint results and uses it if each target file is not changed. Please mind that ESLint doesn't clear the cache when you upgrade ESLint plugins. In that case, you have to remove the cache file manually. The eslint.lintText() method doesn't use caches even if you pass the options.filePath to the method.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cacheLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cacheLocation?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The eslint.lintFiles() method writes caches into this file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cwd?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The working directory. This must be an absolute path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property errorOnUnmatchedPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  errorOnUnmatchedPattern?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Unless set to false, the eslint.lintFiles() method will throw an error when no target files are found.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property extensions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  extensions?: string[] | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If you pass directory paths to the eslint.lintFiles() method, ESLint checks the files in those directories that have the given extensions. For example, when passing the src/ directory and extensions is [".js", ".ts"], ESLint will lint *.js and *.ts files in src/. If extensions is null, ESLint checks *.js files and files that match overrides[].files patterns in your configuration. Note: This option only applies when you pass directory paths to the eslint.lintFiles() method. If you pass glob patterns, ESLint will lint all files matching the glob pattern regardless of extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fix?: boolean | ((message: LintMessage) => boolean);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If true is present, the eslint.lintFiles() and eslint.lintText() methods work in autofix mode. If a predicate function is present, the methods pass each lint message to the function, then use only the lint messages for which the function returned true.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fixTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fixTypes?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The types of the rules that the eslint.lintFiles() and eslint.lintText() methods use for autofix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property globInputPaths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  globInputPaths?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If false is present, the eslint.lintFiles() method doesn't interpret glob patterns.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ignore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ignore?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If false is present, the eslint.lintFiles() method doesn't respect .eslintignore files or ignorePatterns in your configuration.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ignorePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ignorePath?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The path to a file ESLint uses instead of $CWD/.eslintignore. If a path is present and the file doesn't exist, this constructor will throw an error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property overrideConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  overrideConfig?: Linter.ConfigOverride | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Configuration object, overrides all configurations used with this instance. You can use this option to define the settings that will be used even if your configuration files configure it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property overrideConfigFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  overrideConfigFile?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The path to a configuration file, overrides all configurations used with this instance. The options.overrideConfig option is applied after this option is applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property plugins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  plugins?: Record<string, Linter.Plugin> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The plugin implementations that ESLint uses for the plugins setting of your configuration. This is a map-like object. Those keys are plugin IDs and each value is implementation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reportUnusedDisableDirectives?: Linter.SeverityString | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The severity to report unused eslint-disable directives. If this option is a severity, it overrides the reportUnusedDisableDirectives setting in your configurations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property resolvePluginsRelativeTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resolvePluginsRelativeTo?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The path to a directory where plugins should be resolved from. If null is present, ESLint loads plugins from the location of the configuration file that contains the plugin setting. If a path is present, ESLint loads all plugins from there.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property rulePaths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rulePaths?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • An array of paths to directories to load custom rules from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property useEslintrc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  useEslintrc?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If false is present, ESLint doesn't load configuration files (.eslintrc.* files). Only the configuration of the constructor options is valid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Formatter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Formatter {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The Formatter value is the object to convert the LintResult objects to text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method format

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  format: (results: LintResult[]) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The method to convert the LintResult objects to text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LintMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LintMessage {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The LintMessage value is the information of each linting error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  column: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The 1-based column number of the begin point of this message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property endColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  endColumn: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The 1-based column number of the end point of this message. This property is undefined if this message is not a range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property endLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  endLine: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The 1-based line number of the end point of this message. This property is undefined if this message is not a range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fix: EditInfo | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The EditInfo object of autofix. This property is undefined if this message is not fixable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  line: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The 1-based line number of the begin point of this message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  message: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The error message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ruleId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ruleId: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The rule name that generates this lint message. If this message is generated by the ESLint core rather than rules, this is null.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property severity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  severity: 1 | 2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The severity of this message. 1 means warning and 2 means error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property suggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  desc: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fix: EditInfo;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The list of suggestions. Each suggestion is the pair of a description and an EditInfo object to fix code. API users such as editor integrations can choose one of them to fix the problem of this message. This property is undefined if this message doesn't have any suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LintResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LintResult {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The LintResult value is the information of the linting result of each file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property errorCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  errorCount: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The number of errors. This includes fixable errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property filePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filePath: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The absolute path to the file of this result. This is the string "" if the file path is unknown (when you didn't pass the options.filePath option to the eslint.lintText() method).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fixableErrorCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fixableErrorCount: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The number of errors that can be fixed automatically by the fix constructor option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fixableWarningCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fixableWarningCount: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The number of warnings that can be fixed automatically by the fix constructor option.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  messages: Linter.LintMessage[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The array of LintMessage objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  output?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The source code of the file that was linted, with as many fixes applied as possible.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The original source code text. This property is undefined if any messages didn't exist or the output property exists.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property usedDeprecatedRules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  usedDeprecatedRules: DeprecatedRuleInfo[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The information about the deprecated rules that were used to check this file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property warningCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  warningCount: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The number of warnings. This includes fixable warnings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LintTextOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface LintTextOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property filePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filePath?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The path to the file of the source code text. If omitted, the result.filePath becomes the string "".

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property warnIgnored

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    warnIgnored?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If true is present and the options.filePath is a file ESLint should ignore, this method returns a lint result contains a warning message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace TSESLint.Linter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace TSESLint.Linter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Config extends BaseConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ignorePatterns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ignorePatterns?: string | string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The glob patterns that ignore to lint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property root

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        root?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The root flag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ConfigOverride

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ConfigOverride extends BaseConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property excludedFiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          excludedFiles?: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property files

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            files: string | string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Environment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Environment {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property globals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                globals?: Record<string, Linter.Config>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The definition of global variables.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property parserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parserOptions?: ParserOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • The parser options that will be enabled under this environment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ESLintParseResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ESLintParseResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ast: TSESTree.Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property parserServices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parserServices?: ParserServices;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scopeManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scopeManager?: Scope.ScopeManager;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property visitorKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        visitorKeys?: SourceCode.VisitorKeys;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FixOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FixOptions extends VerifyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fix?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Determines whether fixes should be applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface FixReport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface FixReport {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property fixed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fixed: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • True, if the code was fixed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              messages: LintMessage[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Collection of all messages for the given code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              output: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Fixed code text (might be the same as input if no fixes were applied).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LinterOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LinterOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cwd?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • path to a directory that should be considered as the current working directory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LintMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface LintMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  column: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The 1-based column number.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property endColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  endColumn?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The 1-based column number of the end location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property endLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  endLine?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The 1-based line number of the end location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fatal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fatal?: true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • If true then this is a fatal error.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fix?: RuleFix;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Information for autofix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  line: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The 1-based line number.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  message: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The error message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  messageId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property nodeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    nodeType: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ruleId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ruleId: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The ID of the rule which makes this message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property severity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      severity: Severity;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The severity of this message.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      source: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property suggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        suggestions?: LintSuggestion[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Information for suggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface LintSuggestion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface LintSuggestion {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property desc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          desc: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fix: RuleFix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              messageId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Plugin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Plugin {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property configs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  configs?: Record<string, Linter.Config>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The definition of plugin configs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property environments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  environments?: Record<string, Environment>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The definition of plugin environments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property processors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  processors?: Record<string, Processor>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The definition of plugin processors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property rules

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rules?: Record<string, RuleCreateFunction | RuleModule<string, unknown[]>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • The definition of plugin rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Processor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Processor {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property postprocess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    postprocess?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    messagesList: Linter.LintMessage[][],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filename: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Linter.LintMessage[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The function to merge messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property preprocess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    preprocess?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filename: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Array<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filename: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The function to extract code blocks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property supportsAutofix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    supportsAutofix?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • If true then it means the processor supports autofix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface VerifyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface VerifyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allowInlineConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allowInlineConfig?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied. Useful if you want to validate JS without comments overriding rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property disableFixes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disableFixes?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • if true then the linter doesn't make fix properties into the lint result.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property filename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      filename?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • the filename of the source code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property filterCodeBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      filterCodeBlock?: (filename: string, text: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • the predicate function that selects adopt code blocks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property postprocess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      postprocess?: Processor['postprocess'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • postprocessor for report messages. If provided, this should accept an array of the message lists for each code block returned from the preprocessor, apply a mapping to the messages as appropriate, and return a one-dimensional array of messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property preprocess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preprocess?: Processor['preprocess'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • preprocessor for source text. If provided, this should accept a string of source text, and return an array of code blocks to lint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reportUnusedDisableDirectives?: boolean | SeverityString;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Adds reported errors for unused eslint-disable directives.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ParserModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ParserModule =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parse(text: string, options?: ParserOptions): TSESTree.Program;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parseForESLint(text: string, options?: ParserOptions): ESLintParseResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ParserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ParserOptions = TSParserOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RuleEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RuleEntry = RuleLevel | RuleLevelAndOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RuleLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RuleLevel = Severity | SeverityString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RuleLevelAndOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RuleLevelAndOptions = [RuleLevel, ...unknown[]];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RulesRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RulesRecord = Partial<Record<string, RuleEntry>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Severity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Severity = 0 | 1 | 2;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SeverityString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SeverityString = 'off' | 'warn' | 'error';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace TSESLint.Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace TSESLint.Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable DefinitionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const DefinitionType: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable ScopeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const ScopeType: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Definition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Definition = scopeManager.Definition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DefinitionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DefinitionType = scopeManager.Definition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Reference = scopeManager.Reference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Scope = scopeManager.Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ScopeManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ScopeManager = scopeManager.ScopeManager;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Variable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Variable = scopeManager.Variable | scopeManager.ESLintScopeVariable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace TSESLint.Scope.Definitions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace TSESLint.Scope.Definitions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CatchClauseDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CatchClauseDefinition = scopeManager.CatchClauseDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ClassNameDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ClassNameDefinition = scopeManager.ClassNameDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FunctionNameDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FunctionNameDefinition = scopeManager.FunctionNameDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ImplicitGlobalVariableDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ImplicitGlobalVariableDefinition = scopeManager.ImplicitGlobalVariableDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ImportBindingDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ImportBindingDefinition = scopeManager.ImportBindingDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ParameterDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ParameterDefinition = scopeManager.ParameterDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSEnumMemberDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSEnumMemberDefinition = scopeManager.TSEnumMemberDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSEnumNameDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSEnumNameDefinition = scopeManager.TSEnumNameDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSModuleNameDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSModuleNameDefinition = scopeManager.TSModuleNameDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TypeDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TypeDefinition = scopeManager.TypeDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VariableDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VariableDefinition = scopeManager.VariableDefinition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace TSESLint.Scope.Scopes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace TSESLint.Scope.Scopes {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type BlockScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type BlockScope = scopeManager.BlockScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CatchScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type CatchScope = scopeManager.CatchScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ClassScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ClassScope = scopeManager.ClassScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ConditionalTypeScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ConditionalTypeScope = scopeManager.ConditionalTypeScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ForScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ForScope = scopeManager.ForScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FunctionExpressionNameScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type FunctionExpressionNameScope = scopeManager.FunctionExpressionNameScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FunctionScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type FunctionScope = scopeManager.FunctionScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FunctionTypeScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type FunctionTypeScope = scopeManager.FunctionTypeScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GlobalScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type GlobalScope = scopeManager.GlobalScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MappedTypeScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MappedTypeScope = scopeManager.MappedTypeScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ModuleScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ModuleScope = scopeManager.ModuleScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SwitchScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SwitchScope = scopeManager.SwitchScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSEnumScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSEnumScope = scopeManager.TSEnumScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSModuleScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSModuleScope = scopeManager.TSModuleScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TypeScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TypeScope = scopeManager.TypeScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type WithScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type WithScope = scopeManager.WithScope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace TSESLint.SourceCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace TSESLint.SourceCode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Program extends TSESTree.Program {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property comments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      comments: TSESTree.Comment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tokens

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tokens: TSESTree.Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SourceCodeConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SourceCodeConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ast: Program;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The Program node of the AST representing the code. This AST should be created from the text that BOM was stripped.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parserServices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parserServices: ParserServices | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The parser services.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scopeManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scopeManager: Scope.ScopeManager | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The scope of this source code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            text: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The source code text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property visitorKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            visitorKeys: VisitorKeys | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The visitor keys to traverse AST.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface VisitorKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface VisitorKeys {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [nodeType: string]: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CursorWithCountOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CursorWithCountOptions =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | FilterPredicate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * The predicate function to choose tokens.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                filter?: FilterPredicate;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * The flag to iterate comments as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                includeComments?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * The maximum count of tokens the cursor iterates.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                count?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CursorWithSkipOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CursorWithSkipOptions =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | FilterPredicate
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The predicate function to choose tokens.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filter?: FilterPredicate;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The flag to iterate comments as well.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  includeComments?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * The count of tokens the cursor skips.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  skip?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FilterPredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FilterPredicate = (token: TSESTree.Token) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ReturnTypeFromOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ReturnTypeFromOptions<T> = T extends {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      includeComments: true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? TSESTree.Token
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : Exclude<TSESTree.Token, TSESTree.Comment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace TSESLintScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        module 'dist/ts-eslint-scope/index.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable BlockScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const BlockScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<BlockScope>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable CatchScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const CatchScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<CatchScope>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable ClassScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const ClassScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<ClassScope>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable Definition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const Definition: DefinitionConstructor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable ForScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const ForScope: ScopeConstructor & ScopeChildConstructorWithUpperScope<ForScope>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable FunctionExpressionNameScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const FunctionExpressionNameScope: ScopeConstructor &

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable FunctionScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const FunctionScope: ScopeConstructor &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (new (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scopeManager: ScopeManager,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      upperScope: Scope,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      block: TSESTree.Node | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isMethodDefinition: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => FunctionScope);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable GlobalScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const GlobalScope: ScopeConstructor &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (new (scopeManager: ScopeManager, block: TSESTree.Node | null) => GlobalScope);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable ModuleScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const ModuleScope: ScopeConstructor &

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable ParameterDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const ParameterDefinition: DefinitionConstructor &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (new (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index?: number | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rest?: boolean | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => ParameterDefinition);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable PatternVisitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const PatternVisitor: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              new (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: PatternVisitorOptions,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rootPattern: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: PatternVisitorCallback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): PatternVisitor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPattern(node: any): boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const Reference: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                new (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                identifier: any,