@types/eslint

  • Version 8.4.2
  • Published
  • 163 kB
  • 2 dependencies
  • MIT license

Install

npm i @types/eslint
yarn add @types/eslint
pnpm add @types/eslint

Overview

TypeScript definitions for eslint

Index

Classes

Namespaces

Classes

class ESLint

class ESLint {}

    constructor

    constructor(options?: ESLint.Options);

      property version

      static version: string;

        method calculateConfigForFile

        calculateConfigForFile: (filePath: string) => Promise<any>;

          method getErrorResults

          static getErrorResults: (results: ESLint.LintResult[]) => ESLint.LintResult[];

            method getRulesMetaForResults

            getRulesMetaForResults: (
            results: ESLint.LintResult[]
            ) => ESLint.LintResultData['rulesMeta'];

              method isPathIgnored

              isPathIgnored: (filePath: string) => Promise<boolean>;

                method lintFiles

                lintFiles: (patterns: string | string[]) => Promise<ESLint.LintResult[]>;

                  method lintText

                  lintText: (
                  code: string,
                  options?: {
                  filePath?: string | undefined;
                  warnIgnored?: boolean | undefined;
                  }
                  ) => Promise<ESLint.LintResult[]>;

                    method loadFormatter

                    loadFormatter: (nameOrPath?: string) => Promise<ESLint.Formatter>;

                      method outputFixes

                      static outputFixes: (results: ESLint.LintResult[]) => Promise<void>;

                        class Linter

                        class Linter {}

                          constructor

                          constructor(options?: { cwd?: string | undefined });

                            property version

                            static version: string;

                              property version

                              version: string;

                                method defineParser

                                defineParser: (name: string, parser: Linter.ParserModule) => void;

                                  method defineRule

                                  defineRule: (name: string, rule: Rule.RuleModule) => void;

                                    method defineRules

                                    defineRules: (rules: { [name: string]: Rule.RuleModule }) => void;

                                      method getRules

                                      getRules: () => Map<string, Rule.RuleModule>;

                                        method getSourceCode

                                        getSourceCode: () => SourceCode;

                                          method verify

                                          verify: {
                                          (
                                          code: SourceCode | string,
                                          config: Linter.Config,
                                          filename?: string
                                          ): Linter.LintMessage[];
                                          (
                                          code: string | SourceCode,
                                          config: Linter.Config<Linter.RulesRecord>,
                                          options: Linter.LintOptions
                                          ): Linter.LintMessage[];
                                          };

                                            method verifyAndFix

                                            verifyAndFix: {
                                            (code: string, config: Linter.Config, filename?: string): Linter.FixReport;
                                            (
                                            code: string,
                                            config: Linter.Config<Linter.RulesRecord>,
                                            options: Linter.FixOptions
                                            ): Linter.FixReport;
                                            };

                                              class RuleTester

                                              class RuleTester {}

                                                constructor

                                                constructor(config?: any);

                                                  method only

                                                  static only: (
                                                  item: string | RuleTester.ValidTestCase | RuleTester.InvalidTestCase
                                                  ) => RuleTester.ValidTestCase | RuleTester.InvalidTestCase;

                                                    method run

                                                    run: (
                                                    name: string,
                                                    rule: Rule.RuleModule,
                                                    tests: {
                                                    valid?: Array<string | RuleTester.ValidTestCase> | undefined;
                                                    invalid?: RuleTester.InvalidTestCase[] | undefined;
                                                    }
                                                    ) => void;

                                                      class SourceCode

                                                      class SourceCode {}

                                                        constructor

                                                        constructor(text: string, ast: AST.Program);

                                                          constructor

                                                          constructor(config: SourceCode.Config);

                                                            property ast

                                                            ast: AST.Program;

                                                              property getFirstToken

                                                              getFirstToken: SourceCode.UnaryNodeCursorWithSkipOptions;

                                                                property getFirstTokenBetween

                                                                getFirstTokenBetween: SourceCode.BinaryCursorWithSkipOptions;

                                                                  property getFirstTokens

                                                                  getFirstTokens: SourceCode.UnaryNodeCursorWithCountOptions;

                                                                    property getFirstTokensBetween

                                                                    getFirstTokensBetween: SourceCode.BinaryCursorWithCountOptions;

                                                                      property getLastToken

                                                                      getLastToken: SourceCode.UnaryNodeCursorWithSkipOptions;

                                                                        property getLastTokenBetween

                                                                        getLastTokenBetween: SourceCode.BinaryCursorWithSkipOptions;

                                                                          property getLastTokens

                                                                          getLastTokens: SourceCode.UnaryNodeCursorWithCountOptions;

                                                                            property getLastTokensBetween

                                                                            getLastTokensBetween: SourceCode.BinaryCursorWithCountOptions;

                                                                              property getTokenAfter

                                                                              getTokenAfter: SourceCode.UnaryCursorWithSkipOptions;

                                                                                property getTokenBefore

                                                                                getTokenBefore: SourceCode.UnaryCursorWithSkipOptions;

                                                                                  property getTokens

                                                                                  getTokens: ((
                                                                                  node: ESTree.Node,
                                                                                  beforeCount?: number,
                                                                                  afterCount?: number
                                                                                  ) => AST.Token[]) &
                                                                                  SourceCode.UnaryNodeCursorWithCountOptions;

                                                                                    property getTokensAfter

                                                                                    getTokensAfter: SourceCode.UnaryCursorWithCountOptions;

                                                                                      property getTokensBefore

                                                                                      getTokensBefore: SourceCode.UnaryCursorWithCountOptions;

                                                                                        property getTokensBetween

                                                                                        getTokensBetween: SourceCode.BinaryCursorWithCountOptions;

                                                                                          property hasBOM

                                                                                          hasBOM: boolean;

                                                                                            property lines

                                                                                            lines: string[];

                                                                                              property parserServices

                                                                                              parserServices: any;

                                                                                                property scopeManager

                                                                                                scopeManager: Scope.ScopeManager;

                                                                                                  property text

                                                                                                  text: string;

                                                                                                    property visitorKeys

                                                                                                    visitorKeys: SourceCode.VisitorKeys;

                                                                                                      method commentsExistBetween

                                                                                                      commentsExistBetween: (
                                                                                                      left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                      right: ESTree.Node | AST.Token | ESTree.Comment
                                                                                                      ) => boolean;

                                                                                                        method getAllComments

                                                                                                        getAllComments: () => ESTree.Comment[];

                                                                                                          method getComments

                                                                                                          getComments: (node: ESTree.Node) => {
                                                                                                          leading: ESTree.Comment[];
                                                                                                          trailing: ESTree.Comment[];
                                                                                                          };

                                                                                                            method getCommentsAfter

                                                                                                            getCommentsAfter: (nodeOrToken: ESTree.Node | AST.Token) => ESTree.Comment[];

                                                                                                              method getCommentsBefore

                                                                                                              getCommentsBefore: (nodeOrToken: ESTree.Node | AST.Token) => ESTree.Comment[];

                                                                                                                method getCommentsInside

                                                                                                                getCommentsInside: (node: ESTree.Node) => ESTree.Comment[];

                                                                                                                  method getIndexFromLoc

                                                                                                                  getIndexFromLoc: (location: ESTree.Position) => number;

                                                                                                                    method getJSDocComment

                                                                                                                    getJSDocComment: (node: ESTree.Node) => ESTree.Comment | null;

                                                                                                                      method getLines

                                                                                                                      getLines: () => string[];

                                                                                                                        method getLocFromIndex

                                                                                                                        getLocFromIndex: (index: number) => ESTree.Position;

                                                                                                                          method getNodeByRangeIndex

                                                                                                                          getNodeByRangeIndex: (index: number) => ESTree.Node | null;

                                                                                                                            method getText

                                                                                                                            getText: (
                                                                                                                            node?: ESTree.Node,
                                                                                                                            beforeCount?: number,
                                                                                                                            afterCount?: number
                                                                                                                            ) => string;

                                                                                                                              method getTokenByRangeStart

                                                                                                                              getTokenByRangeStart: {
                                                                                                                              (offset: number, options?: { includeComments: false }): AST.Token | null;
                                                                                                                              (offset: number, options: { includeComments: boolean }): any;
                                                                                                                              };

                                                                                                                                method isSpaceBetweenTokens

                                                                                                                                isSpaceBetweenTokens: (first: AST.Token, second: AST.Token) => boolean;

                                                                                                                                  method splitLines

                                                                                                                                  static splitLines: (text: string) => string[];

                                                                                                                                    Namespaces

                                                                                                                                    namespace AST

                                                                                                                                    namespace AST {}

                                                                                                                                      interface Program

                                                                                                                                      interface Program extends ESTree.Program {}

                                                                                                                                        property comments

                                                                                                                                        comments: ESTree.Comment[];

                                                                                                                                          property loc

                                                                                                                                          loc: SourceLocation;

                                                                                                                                            property range

                                                                                                                                            range: Range;

                                                                                                                                              property tokens

                                                                                                                                              tokens: Token[];

                                                                                                                                                interface SourceLocation

                                                                                                                                                interface SourceLocation {}

                                                                                                                                                  property end

                                                                                                                                                  end: ESTree.Position;

                                                                                                                                                    property start

                                                                                                                                                    start: ESTree.Position;

                                                                                                                                                      interface Token

                                                                                                                                                      interface Token {}

                                                                                                                                                        property loc

                                                                                                                                                        loc: SourceLocation;

                                                                                                                                                          property range

                                                                                                                                                          range: Range;

                                                                                                                                                            property type

                                                                                                                                                            type: TokenType;

                                                                                                                                                              property value

                                                                                                                                                              value: string;

                                                                                                                                                                type Range

                                                                                                                                                                type Range = [number, number];

                                                                                                                                                                  type TokenType

                                                                                                                                                                  type TokenType =
                                                                                                                                                                  | 'Boolean'
                                                                                                                                                                  | 'Null'
                                                                                                                                                                  | 'Identifier'
                                                                                                                                                                  | 'Keyword'
                                                                                                                                                                  | 'Punctuator'
                                                                                                                                                                  | 'JSXIdentifier'
                                                                                                                                                                  | 'JSXText'
                                                                                                                                                                  | 'Numeric'
                                                                                                                                                                  | 'String'
                                                                                                                                                                  | 'RegularExpression';

                                                                                                                                                                    namespace ESLint

                                                                                                                                                                    namespace ESLint {}

                                                                                                                                                                      interface DeprecatedRuleUse

                                                                                                                                                                      interface DeprecatedRuleUse {}

                                                                                                                                                                        property replacedBy

                                                                                                                                                                        replacedBy: string[];

                                                                                                                                                                          property ruleId

                                                                                                                                                                          ruleId: string;

                                                                                                                                                                            interface Formatter

                                                                                                                                                                            interface Formatter {}

                                                                                                                                                                              method format

                                                                                                                                                                              format: (
                                                                                                                                                                              results: LintResult[],
                                                                                                                                                                              data?: LintResultData
                                                                                                                                                                              ) => string | Promise<string>;

                                                                                                                                                                                interface LintResult

                                                                                                                                                                                interface LintResult {}

                                                                                                                                                                                  property errorCount

                                                                                                                                                                                  errorCount: number;

                                                                                                                                                                                    property fatalErrorCount

                                                                                                                                                                                    fatalErrorCount: number;

                                                                                                                                                                                      property filePath

                                                                                                                                                                                      filePath: string;

                                                                                                                                                                                        property fixableErrorCount

                                                                                                                                                                                        fixableErrorCount: number;

                                                                                                                                                                                          property fixableWarningCount

                                                                                                                                                                                          fixableWarningCount: number;

                                                                                                                                                                                            property messages

                                                                                                                                                                                            messages: Linter.LintMessage[];

                                                                                                                                                                                              property output

                                                                                                                                                                                              output?: string | undefined;

                                                                                                                                                                                                property source

                                                                                                                                                                                                source?: string | undefined;

                                                                                                                                                                                                  property suppressedMessages

                                                                                                                                                                                                  suppressedMessages: Linter.SuppressedLintMessage[];

                                                                                                                                                                                                    property usedDeprecatedRules

                                                                                                                                                                                                    usedDeprecatedRules: DeprecatedRuleUse[];

                                                                                                                                                                                                      property warningCount

                                                                                                                                                                                                      warningCount: number;

                                                                                                                                                                                                        interface LintResultData

                                                                                                                                                                                                        interface LintResultData {}

                                                                                                                                                                                                          property cwd

                                                                                                                                                                                                          cwd: string;

                                                                                                                                                                                                            property rulesMeta

                                                                                                                                                                                                            rulesMeta: {
                                                                                                                                                                                                            [ruleId: string]: Rule.RuleMetaData;
                                                                                                                                                                                                            };

                                                                                                                                                                                                              interface Options

                                                                                                                                                                                                              interface Options {}

                                                                                                                                                                                                                property allowInlineConfig

                                                                                                                                                                                                                allowInlineConfig?: boolean | undefined;

                                                                                                                                                                                                                  property baseConfig

                                                                                                                                                                                                                  baseConfig?: Linter.Config | undefined;

                                                                                                                                                                                                                    property cache

                                                                                                                                                                                                                    cache?: boolean | undefined;

                                                                                                                                                                                                                      property cacheLocation

                                                                                                                                                                                                                      cacheLocation?: string | undefined;

                                                                                                                                                                                                                        property cacheStrategy

                                                                                                                                                                                                                        cacheStrategy?: 'content' | 'metadata' | undefined;

                                                                                                                                                                                                                          property cwd

                                                                                                                                                                                                                          cwd?: string | undefined;

                                                                                                                                                                                                                            property errorOnUnmatchedPattern

                                                                                                                                                                                                                            errorOnUnmatchedPattern?: boolean | undefined;

                                                                                                                                                                                                                              property extensions

                                                                                                                                                                                                                              extensions?: string[] | undefined;

                                                                                                                                                                                                                                property fix

                                                                                                                                                                                                                                fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined;

                                                                                                                                                                                                                                  property fixTypes

                                                                                                                                                                                                                                  fixTypes?: Array<Rule.RuleMetaData['type']> | undefined;

                                                                                                                                                                                                                                    property globInputPaths

                                                                                                                                                                                                                                    globInputPaths?: boolean | undefined;

                                                                                                                                                                                                                                      property ignore

                                                                                                                                                                                                                                      ignore?: boolean | undefined;

                                                                                                                                                                                                                                        property ignorePath

                                                                                                                                                                                                                                        ignorePath?: string | undefined;

                                                                                                                                                                                                                                          property overrideConfig

                                                                                                                                                                                                                                          overrideConfig?: Linter.Config | undefined;

                                                                                                                                                                                                                                            property overrideConfigFile

                                                                                                                                                                                                                                            overrideConfigFile?: string | undefined;

                                                                                                                                                                                                                                              property plugins

                                                                                                                                                                                                                                              plugins?: Record<string, any> | undefined;

                                                                                                                                                                                                                                                property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                reportUnusedDisableDirectives?: Linter.RuleLevel | undefined;

                                                                                                                                                                                                                                                  property resolvePluginsRelativeTo

                                                                                                                                                                                                                                                  resolvePluginsRelativeTo?: string | undefined;

                                                                                                                                                                                                                                                    property rulePaths

                                                                                                                                                                                                                                                    rulePaths?: string[] | undefined;

                                                                                                                                                                                                                                                      property useEslintrc

                                                                                                                                                                                                                                                      useEslintrc?: boolean | undefined;

                                                                                                                                                                                                                                                        type EditInfo

                                                                                                                                                                                                                                                        type EditInfo = Rule.Fix;

                                                                                                                                                                                                                                                          namespace Linter

                                                                                                                                                                                                                                                          namespace Linter {}

                                                                                                                                                                                                                                                            interface BaseConfig

                                                                                                                                                                                                                                                            interface BaseConfig<Rules extends RulesRecord = RulesRecord>
                                                                                                                                                                                                                                                            extends HasRules<Rules> {}

                                                                                                                                                                                                                                                              property $schema

                                                                                                                                                                                                                                                              $schema?: string | undefined;

                                                                                                                                                                                                                                                                property env

                                                                                                                                                                                                                                                                env?: { [name: string]: boolean } | undefined;

                                                                                                                                                                                                                                                                  property extends

                                                                                                                                                                                                                                                                  extends?: string | string[] | undefined;

                                                                                                                                                                                                                                                                    property globals

                                                                                                                                                                                                                                                                    globals?:
                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                    [name: string]:
                                                                                                                                                                                                                                                                    | boolean
                                                                                                                                                                                                                                                                    | 'readonly'
                                                                                                                                                                                                                                                                    | 'readable'
                                                                                                                                                                                                                                                                    | 'writable'
                                                                                                                                                                                                                                                                    | 'writeable';
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                      property noInlineConfig

                                                                                                                                                                                                                                                                      noInlineConfig?: boolean | undefined;

                                                                                                                                                                                                                                                                        property overrides

                                                                                                                                                                                                                                                                        overrides?: ConfigOverride[] | undefined;

                                                                                                                                                                                                                                                                          property parser

                                                                                                                                                                                                                                                                          parser?: string | undefined;

                                                                                                                                                                                                                                                                            property parserOptions

                                                                                                                                                                                                                                                                            parserOptions?: ParserOptions | undefined;

                                                                                                                                                                                                                                                                              property plugins

                                                                                                                                                                                                                                                                              plugins?: string[] | undefined;

                                                                                                                                                                                                                                                                                property processor

                                                                                                                                                                                                                                                                                processor?: string | undefined;

                                                                                                                                                                                                                                                                                  property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                                                  reportUnusedDisableDirectives?: boolean | undefined;

                                                                                                                                                                                                                                                                                    property settings

                                                                                                                                                                                                                                                                                    settings?: { [name: string]: any } | undefined;

                                                                                                                                                                                                                                                                                      interface Config

                                                                                                                                                                                                                                                                                      interface Config<Rules extends RulesRecord = RulesRecord>
                                                                                                                                                                                                                                                                                      extends BaseConfig<Rules> {}

                                                                                                                                                                                                                                                                                        property ignorePatterns

                                                                                                                                                                                                                                                                                        ignorePatterns?: string | string[] | undefined;

                                                                                                                                                                                                                                                                                          property root

                                                                                                                                                                                                                                                                                          root?: boolean | undefined;

                                                                                                                                                                                                                                                                                            interface ConfigOverride

                                                                                                                                                                                                                                                                                            interface ConfigOverride<Rules extends RulesRecord = RulesRecord>
                                                                                                                                                                                                                                                                                            extends BaseConfig<Rules> {}

                                                                                                                                                                                                                                                                                              property excludedFiles

                                                                                                                                                                                                                                                                                              excludedFiles?: string | string[] | undefined;

                                                                                                                                                                                                                                                                                                property files

                                                                                                                                                                                                                                                                                                files: string | string[];

                                                                                                                                                                                                                                                                                                  interface ESLintParseResult

                                                                                                                                                                                                                                                                                                  interface ESLintParseResult {}

                                                                                                                                                                                                                                                                                                    property ast

                                                                                                                                                                                                                                                                                                    ast: AST.Program;

                                                                                                                                                                                                                                                                                                      property parserServices

                                                                                                                                                                                                                                                                                                      parserServices?: SourceCode.ParserServices | undefined;

                                                                                                                                                                                                                                                                                                        property scopeManager

                                                                                                                                                                                                                                                                                                        scopeManager?: Scope.ScopeManager | undefined;

                                                                                                                                                                                                                                                                                                          property visitorKeys

                                                                                                                                                                                                                                                                                                          visitorKeys?: SourceCode.VisitorKeys | undefined;

                                                                                                                                                                                                                                                                                                            interface FixOptions

                                                                                                                                                                                                                                                                                                            interface FixOptions extends LintOptions {}

                                                                                                                                                                                                                                                                                                              property fix

                                                                                                                                                                                                                                                                                                              fix?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                interface FixReport

                                                                                                                                                                                                                                                                                                                interface FixReport {}

                                                                                                                                                                                                                                                                                                                  property fixed

                                                                                                                                                                                                                                                                                                                  fixed: boolean;

                                                                                                                                                                                                                                                                                                                    property messages

                                                                                                                                                                                                                                                                                                                    messages: LintMessage[];

                                                                                                                                                                                                                                                                                                                      property output

                                                                                                                                                                                                                                                                                                                      output: string;

                                                                                                                                                                                                                                                                                                                        interface HasRules

                                                                                                                                                                                                                                                                                                                        interface HasRules<Rules extends RulesRecord = RulesRecord> {}

                                                                                                                                                                                                                                                                                                                          property rules

                                                                                                                                                                                                                                                                                                                          rules?: Partial<Rules> | undefined;

                                                                                                                                                                                                                                                                                                                            interface LintMessage

                                                                                                                                                                                                                                                                                                                            interface LintMessage {}

                                                                                                                                                                                                                                                                                                                              property column

                                                                                                                                                                                                                                                                                                                              column: number;

                                                                                                                                                                                                                                                                                                                                property endColumn

                                                                                                                                                                                                                                                                                                                                endColumn?: number | undefined;

                                                                                                                                                                                                                                                                                                                                  property endLine

                                                                                                                                                                                                                                                                                                                                  endLine?: number | undefined;

                                                                                                                                                                                                                                                                                                                                    property fatal

                                                                                                                                                                                                                                                                                                                                    fatal?: true | undefined;

                                                                                                                                                                                                                                                                                                                                      property fix

                                                                                                                                                                                                                                                                                                                                      fix?: Rule.Fix | undefined;

                                                                                                                                                                                                                                                                                                                                        property line

                                                                                                                                                                                                                                                                                                                                        line: number;

                                                                                                                                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                                                                                                                                          message: string;

                                                                                                                                                                                                                                                                                                                                            property messageId

                                                                                                                                                                                                                                                                                                                                            messageId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                              property nodeType

                                                                                                                                                                                                                                                                                                                                              nodeType?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                property ruleId

                                                                                                                                                                                                                                                                                                                                                ruleId: string | null;

                                                                                                                                                                                                                                                                                                                                                  property severity

                                                                                                                                                                                                                                                                                                                                                  severity: Severity;

                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                    source?: string | null | undefined;
                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                      Use linter.getSourceCode()

                                                                                                                                                                                                                                                                                                                                                    property suggestions

                                                                                                                                                                                                                                                                                                                                                    suggestions?: LintSuggestion[] | undefined;

                                                                                                                                                                                                                                                                                                                                                      interface LintOptions

                                                                                                                                                                                                                                                                                                                                                      interface LintOptions {}

                                                                                                                                                                                                                                                                                                                                                        property allowInlineConfig

                                                                                                                                                                                                                                                                                                                                                        allowInlineConfig?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                          property disableFixes

                                                                                                                                                                                                                                                                                                                                                          disableFixes?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                            property filename

                                                                                                                                                                                                                                                                                                                                                            filename?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                              property filterCodeBlock

                                                                                                                                                                                                                                                                                                                                                              filterCodeBlock?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                property postprocess

                                                                                                                                                                                                                                                                                                                                                                postprocess?: ((problemLists: LintMessage[][]) => LintMessage[]) | undefined;

                                                                                                                                                                                                                                                                                                                                                                  property preprocess

                                                                                                                                                                                                                                                                                                                                                                  preprocess?: ((code: string) => string[]) | undefined;

                                                                                                                                                                                                                                                                                                                                                                    property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                                                                                                                                    reportUnusedDisableDirectives?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                      interface LintSuggestion

                                                                                                                                                                                                                                                                                                                                                                      interface LintSuggestion {}

                                                                                                                                                                                                                                                                                                                                                                        property desc

                                                                                                                                                                                                                                                                                                                                                                        desc: string;

                                                                                                                                                                                                                                                                                                                                                                          property fix

                                                                                                                                                                                                                                                                                                                                                                          fix: Rule.Fix;

                                                                                                                                                                                                                                                                                                                                                                            property messageId

                                                                                                                                                                                                                                                                                                                                                                            messageId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                              interface LintSuppression

                                                                                                                                                                                                                                                                                                                                                                              interface LintSuppression {}

                                                                                                                                                                                                                                                                                                                                                                                property justification

                                                                                                                                                                                                                                                                                                                                                                                justification: string;

                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                  kind: string;

                                                                                                                                                                                                                                                                                                                                                                                    interface ParserOptions

                                                                                                                                                                                                                                                                                                                                                                                    interface ParserOptions {}

                                                                                                                                                                                                                                                                                                                                                                                      property ecmaFeatures

                                                                                                                                                                                                                                                                                                                                                                                      ecmaFeatures?:
                                                                                                                                                                                                                                                                                                                                                                                      | {
                                                                                                                                                                                                                                                                                                                                                                                      globalReturn?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                      impliedStrict?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                      jsx?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                      experimentalObjectRestSpread?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                      [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                        property ecmaVersion

                                                                                                                                                                                                                                                                                                                                                                                        ecmaVersion?:
                                                                                                                                                                                                                                                                                                                                                                                        | 3
                                                                                                                                                                                                                                                                                                                                                                                        | 5
                                                                                                                                                                                                                                                                                                                                                                                        | 6
                                                                                                                                                                                                                                                                                                                                                                                        | 7
                                                                                                                                                                                                                                                                                                                                                                                        | 8
                                                                                                                                                                                                                                                                                                                                                                                        | 9
                                                                                                                                                                                                                                                                                                                                                                                        | 10
                                                                                                                                                                                                                                                                                                                                                                                        | 11
                                                                                                                                                                                                                                                                                                                                                                                        | 12
                                                                                                                                                                                                                                                                                                                                                                                        | 2015
                                                                                                                                                                                                                                                                                                                                                                                        | 2016
                                                                                                                                                                                                                                                                                                                                                                                        | 2017
                                                                                                                                                                                                                                                                                                                                                                                        | 2018
                                                                                                                                                                                                                                                                                                                                                                                        | 2019
                                                                                                                                                                                                                                                                                                                                                                                        | 2020
                                                                                                                                                                                                                                                                                                                                                                                        | 2021
                                                                                                                                                                                                                                                                                                                                                                                        | 2022
                                                                                                                                                                                                                                                                                                                                                                                        | 'latest'
                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                          property sourceType

                                                                                                                                                                                                                                                                                                                                                                                          sourceType?: 'script' | 'module' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                              interface Processor

                                                                                                                                                                                                                                                                                                                                                                                              interface Processor<T extends string | ProcessorFile = string | ProcessorFile> {}

                                                                                                                                                                                                                                                                                                                                                                                                property supportsAutofix

                                                                                                                                                                                                                                                                                                                                                                                                supportsAutofix?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                  method postprocess

                                                                                                                                                                                                                                                                                                                                                                                                  postprocess: (messages: LintMessage[][], filename: string) => LintMessage[];

                                                                                                                                                                                                                                                                                                                                                                                                    method preprocess

                                                                                                                                                                                                                                                                                                                                                                                                    preprocess: (text: string, filename: string) => T[];

                                                                                                                                                                                                                                                                                                                                                                                                      interface ProcessorFile

                                                                                                                                                                                                                                                                                                                                                                                                      interface ProcessorFile {}

                                                                                                                                                                                                                                                                                                                                                                                                        property filename

                                                                                                                                                                                                                                                                                                                                                                                                        filename: string;

                                                                                                                                                                                                                                                                                                                                                                                                          property text

                                                                                                                                                                                                                                                                                                                                                                                                          text: string;

                                                                                                                                                                                                                                                                                                                                                                                                            interface RulesRecord

                                                                                                                                                                                                                                                                                                                                                                                                            interface RulesRecord {}

                                                                                                                                                                                                                                                                                                                                                                                                              index signature

                                                                                                                                                                                                                                                                                                                                                                                                              [rule: string]: RuleEntry;

                                                                                                                                                                                                                                                                                                                                                                                                                interface SuppressedLintMessage

                                                                                                                                                                                                                                                                                                                                                                                                                interface SuppressedLintMessage extends LintMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                                  property suppressions

                                                                                                                                                                                                                                                                                                                                                                                                                  suppressions: LintSuppression[];

                                                                                                                                                                                                                                                                                                                                                                                                                    type ParserModule

                                                                                                                                                                                                                                                                                                                                                                                                                    type ParserModule =
                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                    parse(text: string, options?: any): AST.Program;
                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                    parseForESLint(text: string, options?: any): ESLintParseResult;
                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                      type RuleEntry

                                                                                                                                                                                                                                                                                                                                                                                                                      type RuleEntry<Options extends any[] = any[]> =
                                                                                                                                                                                                                                                                                                                                                                                                                      | RuleLevel
                                                                                                                                                                                                                                                                                                                                                                                                                      | RuleLevelAndOptions<Options>;

                                                                                                                                                                                                                                                                                                                                                                                                                        type RuleLevel

                                                                                                                                                                                                                                                                                                                                                                                                                        type RuleLevel = Severity | 'off' | 'warn' | 'error';

                                                                                                                                                                                                                                                                                                                                                                                                                          type RuleLevelAndOptions

                                                                                                                                                                                                                                                                                                                                                                                                                          type RuleLevelAndOptions<Options extends any[] = any[]> = Prepend<
                                                                                                                                                                                                                                                                                                                                                                                                                          Partial<Options>,
                                                                                                                                                                                                                                                                                                                                                                                                                          RuleLevel
                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                            type Severity

                                                                                                                                                                                                                                                                                                                                                                                                                            type Severity = 0 | 1 | 2;

                                                                                                                                                                                                                                                                                                                                                                                                                              namespace Rule

                                                                                                                                                                                                                                                                                                                                                                                                                              namespace Rule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                interface CodePath

                                                                                                                                                                                                                                                                                                                                                                                                                                interface CodePath {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  property childCodePaths

                                                                                                                                                                                                                                                                                                                                                                                                                                  childCodePaths: CodePath[];

                                                                                                                                                                                                                                                                                                                                                                                                                                    property currentSegments

                                                                                                                                                                                                                                                                                                                                                                                                                                    currentSegments: CodePathSegment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                      property finalSegments

                                                                                                                                                                                                                                                                                                                                                                                                                                      finalSegments: CodePathSegment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                        property id

                                                                                                                                                                                                                                                                                                                                                                                                                                        id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property initialSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                          initialSegment: CodePathSegment;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property returnedSegments

                                                                                                                                                                                                                                                                                                                                                                                                                                            returnedSegments: CodePathSegment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                              property thrownSegments

                                                                                                                                                                                                                                                                                                                                                                                                                                              thrownSegments: CodePathSegment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                property upper

                                                                                                                                                                                                                                                                                                                                                                                                                                                upper: CodePath | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CodePathSegment

                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CodePathSegment {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                    id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property nextSegments

                                                                                                                                                                                                                                                                                                                                                                                                                                                      nextSegments: CodePathSegment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property prevSegments

                                                                                                                                                                                                                                                                                                                                                                                                                                                        prevSegments: CodePathSegment[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property reachable

                                                                                                                                                                                                                                                                                                                                                                                                                                                          reachable: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Fix {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                              range: AST.Range;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NodeListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NodeListener {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ArrayExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ArrayExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.ArrayExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ArrayPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ArrayPattern?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.ArrayPattern & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ArrowFunctionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ArrowFunctionExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.ArrowFunctionExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property AssignmentExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AssignmentExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.AssignmentExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property AssignmentPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            AssignmentPattern?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((node: ESTree.AssignmentPattern & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property AwaitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AwaitExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((node: ESTree.AwaitExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property BinaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BinaryExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((node: ESTree.BinaryExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BlockStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.BlockStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property BreakStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BreakStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.BreakStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property CallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CallExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.CallExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property CatchClause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CatchClause?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.CatchClause & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ChainExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ChainExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.ChainExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ClassBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ClassBody?: ((node: ESTree.ClassBody & NodeParentExtension) => void) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ClassDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ClassDeclaration?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((node: ESTree.ClassDeclaration & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ClassExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ClassExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((node: ESTree.ClassExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ConditionalExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ConditionalExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.ConditionalExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ContinueStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ContinueStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.ContinueStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property DebuggerStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DebuggerStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.DebuggerStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property DoWhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DoWhileStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.DoWhileStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property EmptyStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          EmptyStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.EmptyStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ExportAllDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ExportAllDeclaration?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((node: ESTree.ExportAllDeclaration & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ExportDefaultDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ExportDefaultDeclaration?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((node: ESTree.ExportDefaultDeclaration & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ExportNamedDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ExportNamedDeclaration?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((node: ESTree.ExportNamedDeclaration & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ExportSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ExportSpecifier?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.ExportSpecifier & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ExpressionStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ExpressionStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.ExpressionStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ForInStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ForInStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.ForInStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ForOfStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ForOfStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.ForOfStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ForStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ForStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.ForStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property FunctionDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FunctionDeclaration?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((node: ESTree.FunctionDeclaration & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property FunctionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              FunctionExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((node: ESTree.FunctionExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Identifier?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((node: ESTree.Identifier & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property IfStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IfStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.IfStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ImportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ImportDeclaration?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.ImportDeclaration & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ImportDefaultSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ImportDefaultSpecifier?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.ImportDefaultSpecifier & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ImportExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ImportExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.ImportExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ImportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ImportNamespaceSpecifier?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.ImportNamespaceSpecifier & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ImportSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ImportSpecifier?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((node: ESTree.ImportSpecifier & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property LabeledStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LabeledStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((node: ESTree.LabeledStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Literal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Literal?: ((node: ESTree.Literal & NodeParentExtension) => void) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property LogicalExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  LogicalExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.LogicalExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property MemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MemberExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.MemberExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property MetaProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MetaProperty?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.MetaProperty & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property MethodDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MethodDefinition?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.MethodDefinition & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property NewExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.NewExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ObjectExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ObjectExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((node: ESTree.ObjectExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ObjectPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ObjectPattern?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((node: ESTree.ObjectPattern & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Program?: ((node: ESTree.Program) => void) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Property

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Property?: ((node: ESTree.Property & NodeParentExtension) => void) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property RestElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RestElement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.RestElement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ReturnStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ReturnStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.ReturnStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property SequenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SequenceExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.SequenceExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property SpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SpreadElement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.SpreadElement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Super

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Super?: ((node: ESTree.Super & NodeParentExtension) => void) | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property SwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SwitchCase?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((node: ESTree.SwitchCase & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property SwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SwitchStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((node: ESTree.SwitchStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property TaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TaggedTemplateExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.TaggedTemplateExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property TemplateElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TemplateElement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.TemplateElement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property TemplateLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TemplateLiteral?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.TemplateLiteral & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ThisExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ThisExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.ThisExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ThrowStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ThrowStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.ThrowStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property TryStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TryStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((node: ESTree.TryStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property UnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UnaryExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((node: ESTree.UnaryExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property UpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UpdateExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((node: ESTree.UpdateExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property VariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  VariableDeclaration?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.VariableDeclaration & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property VariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    VariableDeclarator?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((node: ESTree.VariableDeclarator & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property WhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WhileStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.WhileStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property WithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        WithStatement?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.WithStatement & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property YieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          YieldExpression?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((node: ESTree.YieldExpression & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeParentExtension

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeParentExtension {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parent: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReportDescriptorOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ReportDescriptorOptions extends ReportDescriptorOptionsBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property suggest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  suggest?: SuggestionReportDescriptor[] | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ReportDescriptorOptionsBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ReportDescriptorOptionsBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data?: { [key: string]: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fix?: null | ReportFixer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuleContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuleContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property parserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parserOptions: Linter.ParserOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property parserPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parserPath: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property parserServices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parserServices: SourceCode.ParserServices;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      settings: { [name: string]: any };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getAncestors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getAncestors: () => ESTree.Node[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getCwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getCwd: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDeclaredVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getDeclaredVariables: (node: ESTree.Node) => Scope.Variable[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getFilename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getFilename: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getPhysicalFilename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getPhysicalFilename: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getScope: () => Scope.Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getSourceCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getSourceCode: () => SourceCode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method markVariableAsUsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      markVariableAsUsed: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method report

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        report: (descriptor: ReportDescriptor) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuleFixer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuleFixer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method insertTextAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            insertTextAfter: (nodeOrToken: ESTree.Node | AST.Token, text: string) => Fix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method insertTextAfterRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              insertTextAfterRange: (range: AST.Range, text: string) => Fix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method insertTextBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                insertTextBefore: (nodeOrToken: ESTree.Node | AST.Token, text: string) => Fix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method insertTextBeforeRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  insertTextBeforeRange: (range: AST.Range, text: string) => Fix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    remove: (nodeOrToken: ESTree.Node | AST.Token) => Fix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method removeRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      removeRange: (range: AST.Range) => Fix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method replaceText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        replaceText: (nodeOrToken: ESTree.Node | AST.Token, text: string) => Fix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method replaceTextRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replaceTextRange: (range: AST.Range, text: string) => Fix;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RuleListener

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RuleListener extends NodeListener {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method onCodePathEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onCodePathEnd: (codePath: CodePath, node: Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method onCodePathSegmentEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onCodePathSegmentEnd: (segment: CodePathSegment, node: Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method onCodePathSegmentLoop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onCodePathSegmentLoop: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fromSegment: CodePathSegment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toSegment: CodePathSegment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method onCodePathSegmentStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onCodePathSegmentStart: (segment: CodePathSegment, node: Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method onCodePathStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onCodePathStart: (codePath: CodePath, node: Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [key: string]:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((codePath: CodePath, node: Node) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((segment: CodePathSegment, node: Node) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fromSegment: CodePathSegment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toSegment: CodePathSegment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: Node) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | NodeListener[keyof NodeListener]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuleMetaData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RuleMetaData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            deprecated?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property docs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              docs?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** provides the short description of the rule in the [rules index](https://eslint.org/docs/rules/) */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              description?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** specifies the heading under which the rule is listed in the [rules index](https://eslint.org/docs/rules/) */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              category?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** is whether the `"extends": "eslint:recommended"` property in a [configuration file](https://eslint.org/docs/user-guide/configuring#extending-configuration-files) enables the rule */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              recommended?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** specifies the URL at which the full documentation can be accessed */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              url?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /** specifies whether rules can return suggestions (defaults to false if omitted) */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              suggestion?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fixable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fixable?: 'code' | 'whitespace' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hasSuggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hasSuggestions?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • specifies whether rules can return suggestions (defaults to false if omitted)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  messages?: { [messageId: string]: string } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    schema?: JSONSchema4 | JSONSchema4[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: 'problem' | 'suggestion' | 'layout' | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RuleModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RuleModule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property meta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          meta?: RuleMetaData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            create: (context: RuleContext) => RuleListener;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SuggestionReportOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SuggestionReportOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data?: { [key: string]: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fix: ReportFixer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Node = ESTree.Node & NodeParentExtension;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NodeTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NodeTypes = ESTree.Node['type'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ReportDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ReportDescriptor = ReportDescriptorMessage &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ReportDescriptorLocation &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ReportDescriptorOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ReportDescriptorLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ReportDescriptorLocation =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | { node: ESTree.Node }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | { loc: AST.SourceLocation | { line: number; column: number } };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ReportDescriptorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ReportDescriptorMessage = { message: string } | { messageId: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ReportFixer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ReportFixer = (fixer: RuleFixer) => null | Fix | IterableIterator<Fix> | Fix[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SuggestionDescriptorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SuggestionDescriptorMessage = { desc: string } | { messageId: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SuggestionReportDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SuggestionReportDescriptor = SuggestionDescriptorMessage &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SuggestionReportOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace RuleTester

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace RuleTester {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InvalidTestCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface InvalidTestCase extends ValidTestCase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errors: number | Array<TestCaseError | string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          output?: string | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SuggestionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SuggestionOutput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data?: Record<string, unknown> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property desc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                desc?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  messageId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    output: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TestCaseError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TestCaseError {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        column?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property endColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            endColumn?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property endLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              endLine?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                line?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  message?: string | RegExp | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    messageId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property suggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      suggestions?: SuggestionOutput[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ValidTestCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ValidTestCase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            code: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property filename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filename?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property globals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                globals?: { [name: string]: boolean } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property only

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    only?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parser?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parserOptions?: Linter.ParserOptions | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            settings?: { [name: string]: any } | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Reference {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  from: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    identifier: ESTree.Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      init: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property resolved

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        resolved: Variable | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property writeExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          writeExpr: ESTree.Node | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isRead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isRead: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isReadOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isReadOnly: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isReadWrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isReadWrite: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isWrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isWrite: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isWriteOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isWriteOnly: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        block: ESTree.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property childScopes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          childScopes: Scope[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property functionExpressionScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            functionExpressionScope: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isStrict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isStrict: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property references

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                references: Reference[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  set: Map<string, Variable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property through

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    through: Reference[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'block'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'catch'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'class'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'for'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'function'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'function-expression-name'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'global'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'module'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'switch'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'with'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'TDZ';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property upper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        upper: Scope | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variables: Variable[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property variableScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variableScope: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ScopeManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ScopeManager {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property globalScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                globalScope: Scope | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property scopes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scopes: Scope[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method acquire

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    acquire: (node: ESTree.Node, inner?: boolean) => Scope | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getDeclaredVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getDeclaredVariables: (node: ESTree.Node) => Variable[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Variable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Variable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property defs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defs: Definition[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property identifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            identifiers: ESTree.Identifier[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property references

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                references: Reference[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Definition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Definition = DefinitionType & { name: ESTree.Identifier };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DefinitionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DefinitionType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | { type: 'CatchClause'; node: ESTree.CatchClause; parent: null }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'ClassName';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ESTree.ClassDeclaration | ESTree.ClassExpression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parent: null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'FunctionName';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ESTree.FunctionDeclaration | ESTree.FunctionExpression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parent: null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | { type: 'ImplicitGlobalVariable'; node: ESTree.Program; parent: null }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'ImportBinding';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ESTree.ImportSpecifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ESTree.ImportDefaultSpecifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ESTree.ImportNamespaceSpecifier;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parent: ESTree.ImportDeclaration;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Parameter';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ESTree.FunctionDeclaration
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ESTree.FunctionExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ESTree.ArrowFunctionExpression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parent: null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | { type: 'TDZ'; node: any; parent: null }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Variable';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ESTree.VariableDeclarator;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parent: ESTree.VariableDeclaration;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace SourceCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace SourceCode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface BinaryCursorWithCountOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface BinaryCursorWithCountOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends AST.Token>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          right: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((token: AST.Token) => token is T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter: (token: AST.Token) => token is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T extends AST.Token | ESTree.Comment>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            right: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            filter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tokenOrComment: AST.Token | ESTree.Comment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => tokenOrComment is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              right: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filter?: ((token: AST.Token) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((token: AST.Token) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): AST.Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): Array<AST.Token | ESTree.Comment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BinaryCursorWithSkipOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BinaryCursorWithSkipOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <T extends AST.Token>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    right: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((token: AST.Token) => token is T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter: (token: AST.Token) => token is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): T | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T extends AST.Token | ESTree.Comment>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      right: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      filter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tokenOrComment: AST.Token | ESTree.Comment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => tokenOrComment is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): T | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        right: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        filter?: ((token: AST.Token) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((token: AST.Token) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): AST.Token | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          left: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          right: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): AST.Token | ESTree.Comment | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Config

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Config {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ast: AST.Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property parserServices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parserServices?: ParserServices | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property scopeManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scopeManager?: Scope.ScopeManager | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    text: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property visitorKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      visitorKeys?: VisitorKeys | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UnaryCursorWithCountOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface UnaryCursorWithCountOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends AST.Token>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | ((token: AST.Token) => token is T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter: (token: AST.Token) => token is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <T extends AST.Token | ESTree.Comment>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            filter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tokenOrComment: AST.Token | ESTree.Comment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => tokenOrComment is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filter?: ((token: AST.Token) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((token: AST.Token) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): AST.Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): Array<AST.Token | ESTree.Comment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface UnaryCursorWithSkipOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface UnaryCursorWithSkipOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <T extends AST.Token>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | ((token: AST.Token) => token is T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter: (token: AST.Token) => token is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): T | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <T extends AST.Token | ESTree.Comment>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      filter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tokenOrComment: AST.Token | ESTree.Comment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => tokenOrComment is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): T | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        filter?: ((token: AST.Token) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((token: AST.Token) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): AST.Token | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: ESTree.Node | AST.Token | ESTree.Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): AST.Token | ESTree.Comment | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UnaryNodeCursorWithCountOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UnaryNodeCursorWithCountOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <T extends AST.Token>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: ESTree.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ((token: AST.Token) => token is T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filter: (token: AST.Token) => token is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <T extends AST.Token | ESTree.Comment>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: ESTree.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                filter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tokenOrComment: AST.Token | ESTree.Comment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => tokenOrComment is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: ESTree.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filter?: ((token: AST.Token) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((token: AST.Token) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): AST.Token[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: ESTree.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    count?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): Array<AST.Token | ESTree.Comment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UnaryNodeCursorWithSkipOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UnaryNodeCursorWithSkipOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <T extends AST.Token>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: ESTree.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        options:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((token: AST.Token) => token is T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        filter: (token: AST.Token) => token is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): T | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <T extends AST.Token | ESTree.Comment>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: ESTree.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tokenOrComment: AST.Token | ESTree.Comment
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => tokenOrComment is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): T | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: ESTree.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            filter?: ((token: AST.Token) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            includeComments?: false | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((token: AST.Token) => boolean)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): AST.Token | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: ESTree.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filter?: ((token: AST.Token | ESTree.Comment) => boolean) | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              includeComments: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              skip?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): AST.Token | ESTree.Comment | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface VisitorKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface VisitorKeys {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  [nodeType: string]: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ParserServices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ParserServices = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/eslint.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/eslint)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/@types/eslint"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>