@types/eslint

  • Version 7.28.1
  • Published
  • 164 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 CLIEngine

class CLIEngine {}
  • Deprecated

    Deprecated in favor of ESLint

constructor

constructor(options: CLIEngine.Options);

    property version

    static version: string;

      method addPlugin

      addPlugin: (name: string, pluginObject: any) => void;

        method executeOnFiles

        executeOnFiles: (patterns: string[]) => CLIEngine.LintReport;

          method executeOnText

          executeOnText: (text: string, filename?: string) => CLIEngine.LintReport;

            method getConfigForFile

            getConfigForFile: (filePath: string) => Linter.Config;

              method getErrorResults

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

                method getFormatter

                static getFormatter: (format?: string) => CLIEngine.Formatter;

                  method getRules

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

                    method isPathIgnored

                    isPathIgnored: (filePath: string) => boolean;

                      method outputFixes

                      static outputFixes: (report: CLIEngine.LintReport) => void;

                        method resolveFileGlobPatterns

                        resolveFileGlobPatterns: (patterns: string[]) => string[];

                          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 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 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: any,
                                                                                                      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: any
                                                                                                                              ) => { 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: any) => ESTree.Comment[];

                                                                                                                                      method getIndexFromLoc

                                                                                                                                      getIndexFromLoc: (location: any) => number;

                                                                                                                                        method getJSDocComment

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

                                                                                                                                          method getLines

                                                                                                                                          getLines: () => string[];

                                                                                                                                            method getLocFromIndex

                                                                                                                                            getLocFromIndex: (index: number) => any;

                                                                                                                                              method getNodeByRangeIndex

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

                                                                                                                                                method getText

                                                                                                                                                getText: (node?: any, 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 CLIEngine

                                                                                                                                                                                        namespace CLIEngine {}
                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                          Deprecated in favor of ESLint

                                                                                                                                                                                        class Options

                                                                                                                                                                                        class Options {}

                                                                                                                                                                                          property allowInlineConfig

                                                                                                                                                                                          allowInlineConfig?: boolean;

                                                                                                                                                                                            property baseConfig

                                                                                                                                                                                            baseConfig?: false | { [name: string]: any };

                                                                                                                                                                                              property cache

                                                                                                                                                                                              cache?: boolean;

                                                                                                                                                                                                property cacheFile

                                                                                                                                                                                                cacheFile?: string;

                                                                                                                                                                                                  property cacheLocation

                                                                                                                                                                                                  cacheLocation?: string;

                                                                                                                                                                                                    property cacheStrategy

                                                                                                                                                                                                    cacheStrategy?: 'content' | 'metadata';

                                                                                                                                                                                                      property configFile

                                                                                                                                                                                                      configFile?: string;

                                                                                                                                                                                                        property cwd

                                                                                                                                                                                                        cwd?: string;

                                                                                                                                                                                                          property envs

                                                                                                                                                                                                          envs?: string[];

                                                                                                                                                                                                            property errorOnUnmatchedPattern

                                                                                                                                                                                                            errorOnUnmatchedPattern?: boolean;

                                                                                                                                                                                                              property extensions

                                                                                                                                                                                                              extensions?: string[];

                                                                                                                                                                                                                property fix

                                                                                                                                                                                                                fix?: boolean;

                                                                                                                                                                                                                  property globals

                                                                                                                                                                                                                  globals?: string[];

                                                                                                                                                                                                                    property ignore

                                                                                                                                                                                                                    ignore?: boolean;

                                                                                                                                                                                                                      property ignorePath

                                                                                                                                                                                                                      ignorePath?: string;

                                                                                                                                                                                                                        property ignorePattern

                                                                                                                                                                                                                        ignorePattern?: string | string[];

                                                                                                                                                                                                                          property parser

                                                                                                                                                                                                                          parser?: string;

                                                                                                                                                                                                                            property parserOptions

                                                                                                                                                                                                                            parserOptions?: Linter.ParserOptions;

                                                                                                                                                                                                                              property plugins

                                                                                                                                                                                                                              plugins?: string[];

                                                                                                                                                                                                                                property reportUnusedDisableDirectives

                                                                                                                                                                                                                                reportUnusedDisableDirectives?: boolean;

                                                                                                                                                                                                                                  property resolvePluginsRelativeTo

                                                                                                                                                                                                                                  resolvePluginsRelativeTo?: string;

                                                                                                                                                                                                                                    property rulePaths

                                                                                                                                                                                                                                    rulePaths?: string[];

                                                                                                                                                                                                                                      property rules

                                                                                                                                                                                                                                      rules?: {
                                                                                                                                                                                                                                      [name: string]: Linter.RuleLevel | [_: Linter.RuleLevel, ..._1: any[]];
                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                        property useEslintrc

                                                                                                                                                                                                                                        useEslintrc?: boolean;

                                                                                                                                                                                                                                          interface LintReport

                                                                                                                                                                                                                                          interface LintReport {}

                                                                                                                                                                                                                                            property errorCount

                                                                                                                                                                                                                                            errorCount: number;

                                                                                                                                                                                                                                              property fixableErrorCount

                                                                                                                                                                                                                                              fixableErrorCount: number;

                                                                                                                                                                                                                                                property fixableWarningCount

                                                                                                                                                                                                                                                fixableWarningCount: number;

                                                                                                                                                                                                                                                  property results

                                                                                                                                                                                                                                                  results: LintResult[];

                                                                                                                                                                                                                                                    property usedDeprecatedRules

                                                                                                                                                                                                                                                    usedDeprecatedRules: DeprecatedRuleUse[];

                                                                                                                                                                                                                                                      property warningCount

                                                                                                                                                                                                                                                      warningCount: number;

                                                                                                                                                                                                                                                        type DeprecatedRuleUse

                                                                                                                                                                                                                                                        type DeprecatedRuleUse = ESLint.DeprecatedRuleUse;

                                                                                                                                                                                                                                                          type Formatter

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

                                                                                                                                                                                                                                                            type LintResult

                                                                                                                                                                                                                                                            type LintResult = ESLint.LintResult;

                                                                                                                                                                                                                                                              type LintResultData

                                                                                                                                                                                                                                                              type LintResultData = ESLint.LintResultData;

                                                                                                                                                                                                                                                                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;

                                                                                                                                                                                                                                                                            interface LintResult

                                                                                                                                                                                                                                                                            interface LintResult {}

                                                                                                                                                                                                                                                                              property errorCount

                                                                                                                                                                                                                                                                              errorCount: number;

                                                                                                                                                                                                                                                                                property filePath

                                                                                                                                                                                                                                                                                filePath: string;

                                                                                                                                                                                                                                                                                  property fixableErrorCount

                                                                                                                                                                                                                                                                                  fixableErrorCount: number;

                                                                                                                                                                                                                                                                                    property fixableWarningCount

                                                                                                                                                                                                                                                                                    fixableWarningCount: number;

                                                                                                                                                                                                                                                                                      property messages

                                                                                                                                                                                                                                                                                      messages: Linter.LintMessage[];

                                                                                                                                                                                                                                                                                        property output

                                                                                                                                                                                                                                                                                        output?: string | undefined;

                                                                                                                                                                                                                                                                                          property source

                                                                                                                                                                                                                                                                                          source?: string | undefined;

                                                                                                                                                                                                                                                                                            property usedDeprecatedRules

                                                                                                                                                                                                                                                                                            usedDeprecatedRules: DeprecatedRuleUse[];

                                                                                                                                                                                                                                                                                              property warningCount

                                                                                                                                                                                                                                                                                              warningCount: number;

                                                                                                                                                                                                                                                                                                interface LintResultData

                                                                                                                                                                                                                                                                                                interface LintResultData {}

                                                                                                                                                                                                                                                                                                  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 eslint/lib/rules/*

                                                                                                                                                                                                                                                                                                                                                module 'eslint/lib/rules/*' {}
                                                                                                                                                                                                                                                                                                                                                • support to use import * as rule form 'eslint/lib/rules/no-unused-expressions' it would be very verbose and redundant to declare all rules files

                                                                                                                                                                                                                                                                                                                                                variable Rule

                                                                                                                                                                                                                                                                                                                                                const Rule: any;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: any) => 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 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 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: any, inner?: boolean) => Scope | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getDeclaredVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getDeclaredVariables: (node: any) => 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 (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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>