@typescript-eslint/experimental-utils

  • Version 4.30.0
  • Published
  • 418 kB
  • 6 dependencies
  • MIT license

Install

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

Overview

(Experimental) Utilities for working with TypeScript + ESLint together

Index

Namespaces

Namespaces

namespace ASTUtils

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

    variable isArrowToken

    const isArrowToken: IsPunctuatorTokenWithValueFunction<'=>'>;

      variable isClosingBraceToken

      const isClosingBraceToken: IsPunctuatorTokenWithValueFunction<'}'>;

        variable isClosingBracketToken

        const isClosingBracketToken: IsPunctuatorTokenWithValueFunction<']'>;

          variable isClosingParenToken

          const isClosingParenToken: IsPunctuatorTokenWithValueFunction<')'>;

            variable isColonToken

            const isColonToken: IsPunctuatorTokenWithValueFunction<':'>;

              variable isCommaToken

              const isCommaToken: IsPunctuatorTokenWithValueFunction<','>;

                variable isCommentToken

                const isCommentToken: IsSpecificTokenFunction<any>;

                  variable isNotArrowToken

                  const isNotArrowToken: IsNotPunctuatorTokenWithValueFunction<'=>'>;

                    variable isNotClosingBraceToken

                    const isNotClosingBraceToken: IsNotPunctuatorTokenWithValueFunction<'}'>;

                      variable isNotClosingBracketToken

                      const isNotClosingBracketToken: IsNotPunctuatorTokenWithValueFunction<']'>;

                        variable isNotClosingParenToken

                        const isNotClosingParenToken: IsNotPunctuatorTokenWithValueFunction<')'>;

                          variable isNotColonToken

                          const isNotColonToken: IsNotPunctuatorTokenWithValueFunction<':'>;

                            variable isNotCommaToken

                            const isNotCommaToken: IsNotPunctuatorTokenWithValueFunction<','>;

                              variable isNotCommentToken

                              const isNotCommentToken: IsNotSpecificTokenFunction<any>;

                                variable isNotOpeningBraceToken

                                const isNotOpeningBraceToken: IsNotPunctuatorTokenWithValueFunction<'{'>;

                                  variable isNotOpeningBracketToken

                                  const isNotOpeningBracketToken: IsNotPunctuatorTokenWithValueFunction<'['>;

                                    variable isNotOpeningParenToken

                                    const isNotOpeningParenToken: IsNotPunctuatorTokenWithValueFunction<'('>;

                                      variable isNotSemicolonToken

                                      const isNotSemicolonToken: IsNotPunctuatorTokenWithValueFunction<';'>;

                                        variable isOpeningBraceToken

                                        const isOpeningBraceToken: IsPunctuatorTokenWithValueFunction<'{'>;

                                          variable isOpeningBracketToken

                                          const isOpeningBracketToken: IsPunctuatorTokenWithValueFunction<'['>;

                                            variable isOpeningParenToken

                                            const isOpeningParenToken: IsPunctuatorTokenWithValueFunction<'('>;

                                              variable isSemicolonToken

                                              const isSemicolonToken: IsPunctuatorTokenWithValueFunction<';'>;

                                                variable LINEBREAK_MATCHER

                                                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,
                                                  nameOrNode: string | TSESTree.Identifier
                                                  ) => TSESLint.Scope.Variable | null;

                                                  function getFunctionHeadLocation

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

                                                  function getFunctionNameWithKind

                                                  getFunctionNameWithKind: (
                                                  node:
                                                  | 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,
                                                  initialScope?:
                                                  | import('@typescript-eslint/scope-manager/dist/scope/Scope').Scope
                                                  | undefined
                                                  ) => string | null;

                                                  function getStaticValue

                                                  getStaticValue: (
                                                  node: any,
                                                  initialScope?:
                                                  | 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.

                                                    Returns

                                                    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,
                                                  initialScope?:
                                                  | import('@typescript-eslint/scope-manager/dist/scope/Scope').Scope
                                                  | undefined
                                                  ) => string | null;

                                                  function hasSideEffect

                                                  hasSideEffect: (
                                                  node: any,
                                                  sourceCode: TSESLint.SourceCode,
                                                  options?:
                                                  | {
                                                  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 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 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 isNotNonNullAssertionPunctuator

                                                                isNotNonNullAssertionPunctuator: (token: any) => token is never;

                                                                  function isNotOptionalChainPunctuator

                                                                  isNotOptionalChainPunctuator: (token: any) => token is never;

                                                                    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.

                                                                        Returns

                                                                        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 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
                                                                            <foo>x

                                                                          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 [ReferenceTrackerESM]

                                                                                                  [ReferenceTrackerESM]?: true;

                                                                                                    property [ReferenceTrackerREAD]

                                                                                                    [ReferenceTrackerREAD]?: T;

                                                                                                      index signature

                                                                                                      [key: string]: TraceMapElement<T>;

                                                                                                        type CALL

                                                                                                        type CALL = ReferenceTrackerStatic['CALL'];

                                                                                                          type CONSTRUCT

                                                                                                          type CONSTRUCT = ReferenceTrackerStatic['CONSTRUCT'];

                                                                                                            type ESM

                                                                                                            type ESM = ReferenceTrackerStatic['ESM'];

                                                                                                              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

                                                                                                                        Returns

                                                                                                                        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

                                                                                                                        Returns

                                                                                                                        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

                                                                                                                        Returns

                                                                                                                        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
                                                                                                                      >({
                                                                                                                      name,
                                                                                                                      meta,
                                                                                                                      defaultOptions,
                                                                                                                      create,
                                                                                                                      }: 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

                                                                                                                          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.

                                                                                                                                    Deprecated

                                                                                                                                    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.

                                                                                                                                    7.0.0

                                                                                                                                  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: SharedConfigurationSettings;
                                                                                                                                          • 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 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 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 extends Linter.Config {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 SharedConfigurationSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SharedConfigurationSettings {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Plugins can add their settings using declaration merging against this interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [name: string]: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 only

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly only?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Run this case exclusively for debugging in supported test frameworks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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<SharedConfigurationSettings>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 GlobalVariableOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GlobalVariableOption = 'readonly' | 'writable' | 'off' | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ScopeChildConstructorWithUpperScope<FunctionExpressionNameScope>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ScopeChildConstructorWithUpperScope<ModuleScope>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )