@types/eslint

  • Version 8.56.5
  • Published
  • 187 kB
  • 2 dependencies
  • MIT license

Install

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

Overview

TypeScript definitions for eslint

Index

Classes

Namespaces

Classes

class ESLint

class ESLint {}

    constructor

    constructor(options?: ESLint.Options);

      property version

      static version: string;

        method calculateConfigForFile

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

          method getErrorResults

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

            method getRulesMetaForResults

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

              method isPathIgnored

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

                method lintFiles

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

                  method lintText

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

                    method loadFormatter

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

                      method outputFixes

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

                        class Linter

                        class Linter {}

                          constructor

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

                            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 | Linter.FlatConfig[],
                                          filename?: string
                                          ): Linter.LintMessage[];
                                          (
                                          code: string | SourceCode,
                                          config:
                                          | Linter.Config<Linter.RulesRecord, Linter.RulesRecord>
                                          | Linter.FlatConfig[],
                                          options: Linter.LintOptions
                                          ): Linter.LintMessage[];
                                          };

                                            method verifyAndFix

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

                                              class RuleTester

                                              class RuleTester {}

                                                constructor

                                                constructor(config?: any);

                                                  method only

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

                                                    method run

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

                                                      class SourceCode

                                                      class SourceCode {}

                                                        constructor

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

                                                          constructor

                                                          constructor(config: SourceCode.Config);

                                                            property ast

                                                            ast: AST.Program;

                                                              property getFirstToken

                                                              getFirstToken: SourceCode.UnaryNodeCursorWithSkipOptions;

                                                                property getFirstTokenBetween

                                                                getFirstTokenBetween: SourceCode.BinaryCursorWithSkipOptions;

                                                                  property getFirstTokens

                                                                  getFirstTokens: SourceCode.UnaryNodeCursorWithCountOptions;

                                                                    property getFirstTokensBetween

                                                                    getFirstTokensBetween: SourceCode.BinaryCursorWithCountOptions;

                                                                      property getLastToken

                                                                      getLastToken: SourceCode.UnaryNodeCursorWithSkipOptions;

                                                                        property getLastTokenBetween

                                                                        getLastTokenBetween: SourceCode.BinaryCursorWithSkipOptions;

                                                                          property getLastTokens

                                                                          getLastTokens: SourceCode.UnaryNodeCursorWithCountOptions;

                                                                            property getLastTokensBetween

                                                                            getLastTokensBetween: SourceCode.BinaryCursorWithCountOptions;

                                                                              property getTokenAfter

                                                                              getTokenAfter: SourceCode.UnaryCursorWithSkipOptions;

                                                                                property getTokenBefore

                                                                                getTokenBefore: SourceCode.UnaryCursorWithSkipOptions;

                                                                                  property getTokens

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

                                                                                    property getTokensAfter

                                                                                    getTokensAfter: SourceCode.UnaryCursorWithCountOptions;

                                                                                      property getTokensBefore

                                                                                      getTokensBefore: SourceCode.UnaryCursorWithCountOptions;

                                                                                        property getTokensBetween

                                                                                        getTokensBetween: SourceCode.BinaryCursorWithCountOptions;

                                                                                          property hasBOM

                                                                                          hasBOM: boolean;

                                                                                            property lines

                                                                                            lines: string[];

                                                                                              property parserServices

                                                                                              parserServices: any;

                                                                                                property scopeManager

                                                                                                scopeManager: Scope.ScopeManager;

                                                                                                  property text

                                                                                                  text: string;

                                                                                                    property visitorKeys

                                                                                                    visitorKeys: SourceCode.VisitorKeys;

                                                                                                      method commentsExistBetween

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

                                                                                                        method getAllComments

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

                                                                                                          method getAncestors

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

                                                                                                            method getComments

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

                                                                                                              method getCommentsAfter

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

                                                                                                                method getCommentsBefore

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

                                                                                                                  method getCommentsInside

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

                                                                                                                    method getDeclaredVariables

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

                                                                                                                      method getIndexFromLoc

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

                                                                                                                        method getJSDocComment

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

                                                                                                                          method getLines

                                                                                                                          getLines: () => string[];

                                                                                                                            method getLocFromIndex

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

                                                                                                                              method getNodeByRangeIndex

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

                                                                                                                                method getScope

                                                                                                                                getScope: (node: ESTree.Node) => Scope.Scope;

                                                                                                                                  method getText

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

                                                                                                                                    method getTokenByRangeStart

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

                                                                                                                                      method isSpaceBetween

                                                                                                                                      isSpaceBetween: (
                                                                                                                                      first: ESTree.Node | AST.Token,
                                                                                                                                      second: ESTree.Node | AST.Token
                                                                                                                                      ) => boolean;

                                                                                                                                        method isSpaceBetweenTokens

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

                                                                                                                                          method markVariableAsUsed

                                                                                                                                          markVariableAsUsed: (name: string, refNode?: ESTree.Node) => boolean;

                                                                                                                                            method splitLines

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

                                                                                                                                              Namespaces

                                                                                                                                              namespace AST

                                                                                                                                              namespace AST {}

                                                                                                                                                interface Program

                                                                                                                                                interface Program extends ESTree.Program {}

                                                                                                                                                  property comments

                                                                                                                                                  comments: ESTree.Comment[];

                                                                                                                                                    property loc

                                                                                                                                                    loc: SourceLocation;

                                                                                                                                                      property range

                                                                                                                                                      range: Range;

                                                                                                                                                        property tokens

                                                                                                                                                        tokens: Token[];

                                                                                                                                                          interface SourceLocation

                                                                                                                                                          interface SourceLocation {}

                                                                                                                                                            property end

                                                                                                                                                            end: ESTree.Position;

                                                                                                                                                              property start

                                                                                                                                                              start: ESTree.Position;

                                                                                                                                                                interface Token

                                                                                                                                                                interface Token {}

                                                                                                                                                                  property loc

                                                                                                                                                                  loc: SourceLocation;

                                                                                                                                                                    property range

                                                                                                                                                                    range: Range;

                                                                                                                                                                      property type

                                                                                                                                                                      type: TokenType;

                                                                                                                                                                        property value

                                                                                                                                                                        value: string;

                                                                                                                                                                          type Range

                                                                                                                                                                          type Range = [number, number];

                                                                                                                                                                            type TokenType

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

                                                                                                                                                                              namespace ESLint

                                                                                                                                                                              namespace ESLint {}

                                                                                                                                                                                interface DeprecatedRuleUse

                                                                                                                                                                                interface DeprecatedRuleUse {}

                                                                                                                                                                                  property replacedBy

                                                                                                                                                                                  replacedBy: string[];

                                                                                                                                                                                    property ruleId

                                                                                                                                                                                    ruleId: string;

                                                                                                                                                                                      interface Environment

                                                                                                                                                                                      interface Environment {}

                                                                                                                                                                                        property globals

                                                                                                                                                                                        globals?: Globals | undefined;

                                                                                                                                                                                          property parserOptions

                                                                                                                                                                                          parserOptions?: Linter.ParserOptions | undefined;

                                                                                                                                                                                            interface Formatter

                                                                                                                                                                                            interface Formatter {}

                                                                                                                                                                                              method format

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

                                                                                                                                                                                                interface Globals

                                                                                                                                                                                                interface Globals {}

                                                                                                                                                                                                  index signature

                                                                                                                                                                                                  [name: string]: boolean | 'writable' | 'readonly' | 'off';

                                                                                                                                                                                                    interface LintResult

                                                                                                                                                                                                    interface LintResult {}

                                                                                                                                                                                                      property errorCount

                                                                                                                                                                                                      errorCount: number;

                                                                                                                                                                                                        property fatalErrorCount

                                                                                                                                                                                                        fatalErrorCount: number;

                                                                                                                                                                                                          property filePath

                                                                                                                                                                                                          filePath: string;

                                                                                                                                                                                                            property fixableErrorCount

                                                                                                                                                                                                            fixableErrorCount: number;

                                                                                                                                                                                                              property fixableWarningCount

                                                                                                                                                                                                              fixableWarningCount: number;

                                                                                                                                                                                                                property messages

                                                                                                                                                                                                                messages: Linter.LintMessage[];

                                                                                                                                                                                                                  property output

                                                                                                                                                                                                                  output?: string | undefined;

                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                    source?: string | undefined;

                                                                                                                                                                                                                      property suppressedMessages

                                                                                                                                                                                                                      suppressedMessages: Linter.SuppressedLintMessage[];

                                                                                                                                                                                                                        property usedDeprecatedRules

                                                                                                                                                                                                                        usedDeprecatedRules: DeprecatedRuleUse[];

                                                                                                                                                                                                                          property warningCount

                                                                                                                                                                                                                          warningCount: number;

                                                                                                                                                                                                                            interface LintResultData

                                                                                                                                                                                                                            interface LintResultData {}

                                                                                                                                                                                                                              property cwd

                                                                                                                                                                                                                              cwd: string;

                                                                                                                                                                                                                                property rulesMeta

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

                                                                                                                                                                                                                                  interface ObjectMetaProperties

                                                                                                                                                                                                                                  interface ObjectMetaProperties {}

                                                                                                                                                                                                                                    property meta

                                                                                                                                                                                                                                    meta?: {
                                                                                                                                                                                                                                    name?: string | undefined;
                                                                                                                                                                                                                                    version?: string | undefined;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                      name?: string | undefined;
                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                        Use meta.name instead.

                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                      version?: string | undefined;
                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                        Use meta.version instead.

                                                                                                                                                                                                                                      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, Plugin> | undefined;

                                                                                                                                                                                                                                                                        property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                                        reportUnusedDisableDirectives?: Linter.StringSeverity | undefined;

                                                                                                                                                                                                                                                                          property resolvePluginsRelativeTo

                                                                                                                                                                                                                                                                          resolvePluginsRelativeTo?: string | undefined;

                                                                                                                                                                                                                                                                            property rulePaths

                                                                                                                                                                                                                                                                            rulePaths?: string[] | undefined;

                                                                                                                                                                                                                                                                              property useEslintrc

                                                                                                                                                                                                                                                                              useEslintrc?: boolean | undefined;

                                                                                                                                                                                                                                                                                interface Plugin

                                                                                                                                                                                                                                                                                interface Plugin extends ObjectMetaProperties {}

                                                                                                                                                                                                                                                                                  property configs

                                                                                                                                                                                                                                                                                  configs?:
                                                                                                                                                                                                                                                                                  | Record<string, ConfigData | Linter.FlatConfig | Linter.FlatConfig[]>
                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                    property environments

                                                                                                                                                                                                                                                                                    environments?: Record<string, Environment> | undefined;

                                                                                                                                                                                                                                                                                      property processors

                                                                                                                                                                                                                                                                                      processors?: Record<string, Linter.Processor> | undefined;

                                                                                                                                                                                                                                                                                        property rules

                                                                                                                                                                                                                                                                                        rules?: Record<string, Rule.OldStyleRule | Rule.RuleModule> | undefined;

                                                                                                                                                                                                                                                                                          type ConfigData

                                                                                                                                                                                                                                                                                          type ConfigData<Rules extends Linter.RulesRecord = Linter.RulesRecord> = Omit<
                                                                                                                                                                                                                                                                                          Linter.Config<Rules>,
                                                                                                                                                                                                                                                                                          '$schema'
                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                            type EditInfo

                                                                                                                                                                                                                                                                                            type EditInfo = Rule.Fix;

                                                                                                                                                                                                                                                                                              namespace Linter

                                                                                                                                                                                                                                                                                              namespace Linter {}

                                                                                                                                                                                                                                                                                                interface BaseConfig

                                                                                                                                                                                                                                                                                                interface BaseConfig<
                                                                                                                                                                                                                                                                                                Rules extends RulesRecord = RulesRecord,
                                                                                                                                                                                                                                                                                                OverrideRules extends RulesRecord = Rules
                                                                                                                                                                                                                                                                                                > extends HasRules<Rules> {}
                                                                                                                                                                                                                                                                                                • ESLint configuration.

                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                  • [ESLint Configuration](https://eslint.org/docs/latest/user-guide/configuring/)

                                                                                                                                                                                                                                                                                                property $schema

                                                                                                                                                                                                                                                                                                $schema?: string | undefined;

                                                                                                                                                                                                                                                                                                  property env

                                                                                                                                                                                                                                                                                                  env?: { [name: string]: boolean } | undefined;
                                                                                                                                                                                                                                                                                                  • An environment provides predefined global variables.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Environments](https://eslint.org/docs/latest/user-guide/configuring/language-options#specifying-environments)

                                                                                                                                                                                                                                                                                                  property extends

                                                                                                                                                                                                                                                                                                  extends?: string | string[] | undefined;
                                                                                                                                                                                                                                                                                                  • Extending configuration files.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Extends](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#extending-configuration-files)

                                                                                                                                                                                                                                                                                                  property globals

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

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Globals](https://eslint.org/docs/latest/user-guide/configuring/language-options#specifying-globals)

                                                                                                                                                                                                                                                                                                  property noInlineConfig

                                                                                                                                                                                                                                                                                                  noInlineConfig?: boolean | undefined;
                                                                                                                                                                                                                                                                                                  • Disable processing of inline comments.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Disabling Inline Comments](https://eslint.org/docs/latest/user-guide/configuring/rules#disabling-inline-comments)

                                                                                                                                                                                                                                                                                                  property overrides

                                                                                                                                                                                                                                                                                                  overrides?: Array<ConfigOverride<OverrideRules>> | undefined;
                                                                                                                                                                                                                                                                                                  • Overrides can be used to use a differing configuration for matching sub-directories and files.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [How do overrides work](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#how-do-overrides-work)

                                                                                                                                                                                                                                                                                                  property parser

                                                                                                                                                                                                                                                                                                  parser?: string | undefined;
                                                                                                                                                                                                                                                                                                  • Parser.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Working with Custom Parsers](https://eslint.org/docs/latest/developer-guide/working-with-custom-parsers)

                                                                                                                                                                                                                                                                                                    • [Specifying Parser](https://eslint.org/docs/latest/user-guide/configuring/plugins#configure-a-parser)

                                                                                                                                                                                                                                                                                                  property parserOptions

                                                                                                                                                                                                                                                                                                  parserOptions?: ParserOptions | undefined;
                                                                                                                                                                                                                                                                                                  • Parser options.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Working with Custom Parsers](https://eslint.org/docs/latest/developer-guide/working-with-custom-parsers)

                                                                                                                                                                                                                                                                                                    • [Specifying Parser Options](https://eslint.org/docs/latest/user-guide/configuring/language-options#specifying-parser-options)

                                                                                                                                                                                                                                                                                                  property plugins

                                                                                                                                                                                                                                                                                                  plugins?: string[] | undefined;
                                                                                                                                                                                                                                                                                                  • Which third-party plugins define additional rules, environments, configs, etc. for ESLint to use.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Configuring Plugins](https://eslint.org/docs/latest/user-guide/configuring/plugins#configure-plugins)

                                                                                                                                                                                                                                                                                                  property processor

                                                                                                                                                                                                                                                                                                  processor?: string | undefined;
                                                                                                                                                                                                                                                                                                  • Specifying processor.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [processor](https://eslint.org/docs/latest/user-guide/configuring/plugins#specify-a-processor)

                                                                                                                                                                                                                                                                                                  property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                                                                  reportUnusedDisableDirectives?: boolean | undefined;
                                                                                                                                                                                                                                                                                                  • Report unused ESLint-disable comments as warning.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Report unused ESLint-disable comments](https://eslint.org/docs/latest/user-guide/configuring/rules#report-unused-eslint-disable-comments)

                                                                                                                                                                                                                                                                                                  property settings

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

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Settings](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#adding-shared-settings)

                                                                                                                                                                                                                                                                                                  interface Config

                                                                                                                                                                                                                                                                                                  interface Config<
                                                                                                                                                                                                                                                                                                  Rules extends RulesRecord = RulesRecord,
                                                                                                                                                                                                                                                                                                  OverrideRules extends RulesRecord = Rules
                                                                                                                                                                                                                                                                                                  > extends BaseConfig<Rules, OverrideRules> {}
                                                                                                                                                                                                                                                                                                  • ESLint configuration.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [ESLint Configuration](https://eslint.org/docs/latest/user-guide/configuring/)

                                                                                                                                                                                                                                                                                                  property ignorePatterns

                                                                                                                                                                                                                                                                                                  ignorePatterns?: string | string[] | undefined;
                                                                                                                                                                                                                                                                                                  • Tell ESLint to ignore specific files and directories.

                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                    • [Ignore Patterns](https://eslint.org/docs/latest/user-guide/configuring/ignoring-code)

                                                                                                                                                                                                                                                                                                  property root

                                                                                                                                                                                                                                                                                                  root?: boolean | undefined;
                                                                                                                                                                                                                                                                                                  • See Also

                                                                                                                                                                                                                                                                                                    • [Using Configuration Files](https://eslint.org/docs/latest/user-guide/configuring/configuration-files#using-configuration-files)

                                                                                                                                                                                                                                                                                                  interface ConfigOverride

                                                                                                                                                                                                                                                                                                  interface ConfigOverride<Rules extends RulesRecord = RulesRecord>
                                                                                                                                                                                                                                                                                                  extends BaseConfig<Rules> {}
                                                                                                                                                                                                                                                                                                  • The overwrites that apply more differing configuration to specific files or directories.

                                                                                                                                                                                                                                                                                                  property excludedFiles

                                                                                                                                                                                                                                                                                                  excludedFiles?: string | string[] | undefined;
                                                                                                                                                                                                                                                                                                  • The glob patterns for excluded files.

                                                                                                                                                                                                                                                                                                  property files

                                                                                                                                                                                                                                                                                                  files: string | string[];
                                                                                                                                                                                                                                                                                                  • The glob patterns for target files.

                                                                                                                                                                                                                                                                                                  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 FlatConfig

                                                                                                                                                                                                                                                                                                                        interface FlatConfig {}

                                                                                                                                                                                                                                                                                                                          property files

                                                                                                                                                                                                                                                                                                                          files?: Array<FlatConfigFileSpec | FlatConfigFileSpec[]>;
                                                                                                                                                                                                                                                                                                                          • An array of glob patterns indicating the files that the configuration object should apply to. If not specified, the configuration object applies to all files

                                                                                                                                                                                                                                                                                                                          property ignores

                                                                                                                                                                                                                                                                                                                          ignores?: FlatConfigFileSpec[];
                                                                                                                                                                                                                                                                                                                          • An array of glob patterns indicating the files that the configuration object should not apply to. If not specified, the configuration object applies to all files matched by files

                                                                                                                                                                                                                                                                                                                          property languageOptions

                                                                                                                                                                                                                                                                                                                          languageOptions?: {
                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                          * The version of ECMAScript to support. May be any year (i.e., 2022) or
                                                                                                                                                                                                                                                                                                                          * version (i.e., 5). Set to "latest" for the most recent supported version.
                                                                                                                                                                                                                                                                                                                          * @default "latest"
                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                          ecmaVersion?: ParserOptions['ecmaVersion'];
                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                          * The type of JavaScript source code. Possible values are "script" for
                                                                                                                                                                                                                                                                                                                          * traditional script files, "module" for ECMAScript modules (ESM), and
                                                                                                                                                                                                                                                                                                                          * "commonjs" for CommonJS files. (default: "module" for .js and .mjs
                                                                                                                                                                                                                                                                                                                          * files; "commonjs" for .cjs files)
                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                          sourceType?: 'script' | 'module' | 'commonjs';
                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                          * An object specifying additional objects that should be added to the
                                                                                                                                                                                                                                                                                                                          * global scope during linting.
                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                          globals?: ESLint.Environment['globals'];
                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                          * An object containing a parse() or parseForESLint() method.
                                                                                                                                                                                                                                                                                                                          * If not configured, the default ESLint parser (Espree) will be used.
                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                          parser?: FlatConfigParserModule;
                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                          * An object specifying additional options that are passed directly to the
                                                                                                                                                                                                                                                                                                                          * parser() method on the parser. The available options are parser-dependent
                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                          parserOptions?: ESLint.Environment['parserOptions'];
                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                          • An object containing settings related to how JavaScript is configured for linting.

                                                                                                                                                                                                                                                                                                                          property linterOptions

                                                                                                                                                                                                                                                                                                                          linterOptions?: {
                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                          * A boolean value indicating if inline configuration is allowed.
                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                          noInlineConfig?: boolean;
                                                                                                                                                                                                                                                                                                                          /**
                                                                                                                                                                                                                                                                                                                          * A severity value indicating if and how unused disable directives should be
                                                                                                                                                                                                                                                                                                                          * tracked and reported.
                                                                                                                                                                                                                                                                                                                          */
                                                                                                                                                                                                                                                                                                                          reportUnusedDisableDirectives?: Severity | StringSeverity | boolean;
                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                          • An object containing settings related to the linting process

                                                                                                                                                                                                                                                                                                                          property plugins

                                                                                                                                                                                                                                                                                                                          plugins?: Record<string, ESLint.Plugin>;
                                                                                                                                                                                                                                                                                                                          • An object containing a name-value mapping of plugin names to plugin objects. When files is specified, these plugins are only available to the matching files.

                                                                                                                                                                                                                                                                                                                          property processor

                                                                                                                                                                                                                                                                                                                          processor?: string | Processor;
                                                                                                                                                                                                                                                                                                                          • Either an object containing preprocess() and postprocess() methods or a string indicating the name of a processor inside of a plugin (i.e., "pluginName/processorName").

                                                                                                                                                                                                                                                                                                                          property rules

                                                                                                                                                                                                                                                                                                                          rules?: RulesRecord;
                                                                                                                                                                                                                                                                                                                          • An object containing the configured rules. When files or ignores are specified, these rule configurations are only available to the matching files.

                                                                                                                                                                                                                                                                                                                          property settings

                                                                                                                                                                                                                                                                                                                          settings?: Record<string, unknown>;
                                                                                                                                                                                                                                                                                                                          • An object containing name-value pairs of information that should be available to all rules.

                                                                                                                                                                                                                                                                                                                          interface HasRules

                                                                                                                                                                                                                                                                                                                          interface HasRules<Rules extends RulesRecord = RulesRecord> {}
                                                                                                                                                                                                                                                                                                                          • A configuration object that may have a rules block.

                                                                                                                                                                                                                                                                                                                          property rules

                                                                                                                                                                                                                                                                                                                          rules?: Partial<Rules> | undefined;

                                                                                                                                                                                                                                                                                                                            interface LintMessage

                                                                                                                                                                                                                                                                                                                            interface LintMessage {}

                                                                                                                                                                                                                                                                                                                              property column

                                                                                                                                                                                                                                                                                                                              column: number;

                                                                                                                                                                                                                                                                                                                                property endColumn

                                                                                                                                                                                                                                                                                                                                endColumn?: number | undefined;

                                                                                                                                                                                                                                                                                                                                  property endLine

                                                                                                                                                                                                                                                                                                                                  endLine?: number | undefined;

                                                                                                                                                                                                                                                                                                                                    property fatal

                                                                                                                                                                                                                                                                                                                                    fatal?: true | undefined;

                                                                                                                                                                                                                                                                                                                                      property fix

                                                                                                                                                                                                                                                                                                                                      fix?: Rule.Fix | undefined;

                                                                                                                                                                                                                                                                                                                                        property line

                                                                                                                                                                                                                                                                                                                                        line: number;

                                                                                                                                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                                                                                                                                          message: string;

                                                                                                                                                                                                                                                                                                                                            property messageId

                                                                                                                                                                                                                                                                                                                                            messageId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                              property nodeType

                                                                                                                                                                                                                                                                                                                                              nodeType?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                property ruleId

                                                                                                                                                                                                                                                                                                                                                ruleId: string | null;

                                                                                                                                                                                                                                                                                                                                                  property severity

                                                                                                                                                                                                                                                                                                                                                  severity: Severity;

                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                    source?: string | null | undefined;
                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                      Use linter.getSourceCode()

                                                                                                                                                                                                                                                                                                                                                    property suggestions

                                                                                                                                                                                                                                                                                                                                                    suggestions?: LintSuggestion[] | undefined;

                                                                                                                                                                                                                                                                                                                                                      interface LintOptions

                                                                                                                                                                                                                                                                                                                                                      interface LintOptions {}

                                                                                                                                                                                                                                                                                                                                                        property allowInlineConfig

                                                                                                                                                                                                                                                                                                                                                        allowInlineConfig?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                          property disableFixes

                                                                                                                                                                                                                                                                                                                                                          disableFixes?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                            property filename

                                                                                                                                                                                                                                                                                                                                                            filename?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                              property filterCodeBlock

                                                                                                                                                                                                                                                                                                                                                              filterCodeBlock?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                property postprocess

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

                                                                                                                                                                                                                                                                                                                                                                  property preprocess

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

                                                                                                                                                                                                                                                                                                                                                                    property reportUnusedDisableDirectives

                                                                                                                                                                                                                                                                                                                                                                    reportUnusedDisableDirectives?: boolean | undefined;

                                                                                                                                                                                                                                                                                                                                                                      interface LintSuggestion

                                                                                                                                                                                                                                                                                                                                                                      interface LintSuggestion {}

                                                                                                                                                                                                                                                                                                                                                                        property desc

                                                                                                                                                                                                                                                                                                                                                                        desc: string;

                                                                                                                                                                                                                                                                                                                                                                          property fix

                                                                                                                                                                                                                                                                                                                                                                          fix: Rule.Fix;

                                                                                                                                                                                                                                                                                                                                                                            property messageId

                                                                                                                                                                                                                                                                                                                                                                            messageId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                              interface LintSuppression

                                                                                                                                                                                                                                                                                                                                                                              interface LintSuppression {}

                                                                                                                                                                                                                                                                                                                                                                                property justification

                                                                                                                                                                                                                                                                                                                                                                                justification: string;

                                                                                                                                                                                                                                                                                                                                                                                  property kind

                                                                                                                                                                                                                                                                                                                                                                                  kind: string;

                                                                                                                                                                                                                                                                                                                                                                                    interface ParserOptions

                                                                                                                                                                                                                                                                                                                                                                                    interface ParserOptions {}
                                                                                                                                                                                                                                                                                                                                                                                    • Parser options.

                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                      • [Specifying Parser Options](https://eslint.org/docs/user-guide/configuring/language-options#specifying-parser-options)

                                                                                                                                                                                                                                                                                                                                                                                    property ecmaFeatures

                                                                                                                                                                                                                                                                                                                                                                                    ecmaFeatures?:
                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                    globalReturn?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    impliedStrict?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    jsx?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    experimentalObjectRestSpread?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;
                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                    | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    • An object indicating which additional language features you'd like to use.

                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                      • https://eslint.org/docs/latest/user-guide/configuring/language-options#specifying-parser-options

                                                                                                                                                                                                                                                                                                                                                                                      • https://typescript-eslint.io/architecture/parser#ecmafeatures

                                                                                                                                                                                                                                                                                                                                                                                    property ecmaVersion

                                                                                                                                                                                                                                                                                                                                                                                    ecmaVersion?:
                                                                                                                                                                                                                                                                                                                                                                                    | 3
                                                                                                                                                                                                                                                                                                                                                                                    | 5
                                                                                                                                                                                                                                                                                                                                                                                    | 6
                                                                                                                                                                                                                                                                                                                                                                                    | 7
                                                                                                                                                                                                                                                                                                                                                                                    | 8
                                                                                                                                                                                                                                                                                                                                                                                    | 9
                                                                                                                                                                                                                                                                                                                                                                                    | 10
                                                                                                                                                                                                                                                                                                                                                                                    | 11
                                                                                                                                                                                                                                                                                                                                                                                    | 12
                                                                                                                                                                                                                                                                                                                                                                                    | 13
                                                                                                                                                                                                                                                                                                                                                                                    | 14
                                                                                                                                                                                                                                                                                                                                                                                    | 15
                                                                                                                                                                                                                                                                                                                                                                                    | 2015
                                                                                                                                                                                                                                                                                                                                                                                    | 2016
                                                                                                                                                                                                                                                                                                                                                                                    | 2017
                                                                                                                                                                                                                                                                                                                                                                                    | 2018
                                                                                                                                                                                                                                                                                                                                                                                    | 2019
                                                                                                                                                                                                                                                                                                                                                                                    | 2020
                                                                                                                                                                                                                                                                                                                                                                                    | 2021
                                                                                                                                                                                                                                                                                                                                                                                    | 2022
                                                                                                                                                                                                                                                                                                                                                                                    | 2023
                                                                                                                                                                                                                                                                                                                                                                                    | 2024
                                                                                                                                                                                                                                                                                                                                                                                    | 'latest'
                                                                                                                                                                                                                                                                                                                                                                                    | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    • Accepts any valid ECMAScript version number or 'latest':

                                                                                                                                                                                                                                                                                                                                                                                      - A version: es3, es5, es6, es7, es8, es9, es10, es11, es12, es13, es14, ..., or - A year: es2015, es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, ..., or - 'latest'

                                                                                                                                                                                                                                                                                                                                                                                      When it's a version or a year, the value must be a number - so do not include the es prefix.

                                                                                                                                                                                                                                                                                                                                                                                      Specifies the version of ECMAScript syntax you want to use. This is used by the parser to determine how to perform scope analysis, and it affects the default

                                                                                                                                                                                                                                                                                                                                                                                      2018

                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                      • https://typescript-eslint.io/architecture/parser/#ecmaversion

                                                                                                                                                                                                                                                                                                                                                                                    property sourceType

                                                                                                                                                                                                                                                                                                                                                                                    sourceType?: 'script' | 'module' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                    • Set to "script" (default) or "module" if your code is in ECMAScript modules.

                                                                                                                                                                                                                                                                                                                                                                                      'script'

                                                                                                                                                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                                                                                                                                                      • https://eslint.org/docs/latest/user-guide/configuring/language-options#specifying-parser-options

                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                      interface Processor

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

                                                                                                                                                                                                                                                                                                                                                                                        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 {}
                                                                                                                                                                                                                                                                                                                                                                                                    • The rules config object is a key/value map of rule names and their severity and options.

                                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                                    [rule: string]: RuleEntry;

                                                                                                                                                                                                                                                                                                                                                                                                      interface SuppressedLintMessage

                                                                                                                                                                                                                                                                                                                                                                                                      interface SuppressedLintMessage extends LintMessage {}

                                                                                                                                                                                                                                                                                                                                                                                                        property suppressions

                                                                                                                                                                                                                                                                                                                                                                                                        suppressions: LintSuppression[];

                                                                                                                                                                                                                                                                                                                                                                                                          type FlatConfigFileSpec

                                                                                                                                                                                                                                                                                                                                                                                                          type FlatConfigFileSpec = string | ((filePath: string) => boolean);

                                                                                                                                                                                                                                                                                                                                                                                                            type FlatConfigParserModule

                                                                                                                                                                                                                                                                                                                                                                                                            type FlatConfigParserModule = Omit<ParserModule, 'parseForESLint'> &
                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                            parse(text: string, options?: any): unknown;
                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                            parseForESLint(
                                                                                                                                                                                                                                                                                                                                                                                                            text: string,
                                                                                                                                                                                                                                                                                                                                                                                                            options?: any
                                                                                                                                                                                                                                                                                                                                                                                                            ): Omit<ESLintParseResult, 'ast' | 'scopeManager'> & {
                                                                                                                                                                                                                                                                                                                                                                                                            ast: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                            scopeManager?: unknown;
                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                              type ParserModule

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

                                                                                                                                                                                                                                                                                                                                                                                                                type RuleEntry

                                                                                                                                                                                                                                                                                                                                                                                                                type RuleEntry<Options extends any[] = any[]> =
                                                                                                                                                                                                                                                                                                                                                                                                                | RuleLevel
                                                                                                                                                                                                                                                                                                                                                                                                                | RuleLevelAndOptions<Options>;
                                                                                                                                                                                                                                                                                                                                                                                                                • The severity level for the rule or an array containing the rule severity level, followed by the rule options.

                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                  • [Rules](https://eslint.org/docs/user-guide/configuring/rules)

                                                                                                                                                                                                                                                                                                                                                                                                                type RuleLevel

                                                                                                                                                                                                                                                                                                                                                                                                                type RuleLevel = Severity | StringSeverity;
                                                                                                                                                                                                                                                                                                                                                                                                                • The numeric or human readable severity level for a rule.

                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                  • [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)

                                                                                                                                                                                                                                                                                                                                                                                                                type RuleLevelAndOptions

                                                                                                                                                                                                                                                                                                                                                                                                                type RuleLevelAndOptions<Options extends any[] = any[]> = Prepend<
                                                                                                                                                                                                                                                                                                                                                                                                                Partial<Options>,
                                                                                                                                                                                                                                                                                                                                                                                                                RuleLevel
                                                                                                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                                                                                                • An array containing the rule severity level, followed by the rule options.

                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                  • [Rules](https://eslint.org/docs/user-guide/configuring/rules)

                                                                                                                                                                                                                                                                                                                                                                                                                type Severity

                                                                                                                                                                                                                                                                                                                                                                                                                type Severity = 0 | 1 | 2;
                                                                                                                                                                                                                                                                                                                                                                                                                • The numeric severity level for a rule.

                                                                                                                                                                                                                                                                                                                                                                                                                  - 0 means off. - 1 means warn. - 2 means error.

                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                  • [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)

                                                                                                                                                                                                                                                                                                                                                                                                                type StringSeverity

                                                                                                                                                                                                                                                                                                                                                                                                                type StringSeverity = 'off' | 'warn' | 'error';
                                                                                                                                                                                                                                                                                                                                                                                                                • The human readable severity level for a rule.

                                                                                                                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                                                                                                                  • [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)

                                                                                                                                                                                                                                                                                                                                                                                                                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:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "ArrayPattern:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "ArrowFunctionExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "AssignmentExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "AssignmentPattern:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "AwaitExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "BinaryExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "BlockStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "BreakStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "CallExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "CatchClause:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "ChainExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "ClassBody:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "ClassDeclaration:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "ClassExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "ConditionalExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "ContinueStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "DebuggerStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "DoWhileStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "EmptyStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "ExportAllDeclaration:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "ExportDefaultDeclaration:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "ExportNamedDeclaration:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "ExportSpecifier:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "ExpressionStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "ForInStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "ForOfStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "ForStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "FunctionDeclaration:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "FunctionExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "Identifier:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "IfStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "ImportDeclaration:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "ImportDefaultSpecifier:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "ImportExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "ImportNamespaceSpecifier:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "ImportSpecifier:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "LabeledStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "Literal:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "LogicalExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "MemberExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "MetaProperty:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "MethodDefinition:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "NewExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "ObjectExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "ObjectPattern:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "PrivateIdentifier:exit"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'PrivateIdentifier:exit'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.PrivateIdentifier & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "Program:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "Property:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "PropertyDefinition:exit"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'PropertyDefinition:exit'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: ESTree.PropertyDefinition & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "RestElement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "ReturnStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "SequenceExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "SpreadElement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "StaticBlock:exit"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  'StaticBlock:exit'?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | ((node: ESTree.StaticBlock & NodeParentExtension) => void)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "Super:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "SwitchCase:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "SwitchStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "TaggedTemplateExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "TemplateElement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "TemplateLiteral:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "ThisExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "ThrowStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property "TryStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property "UnaryExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property "UpdateExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property "VariableDeclaration:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property "VariableDeclarator:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property "WhileStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property "WithStatement:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property "YieldExpression:exit"

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 PrivateIdentifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Program

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Property

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property PropertyDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PropertyDefinition?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ((node: ESTree.PropertyDefinition & 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 StaticBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                StaticBlock?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((node: ESTree.StaticBlock & 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 cwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cwd: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property filename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filename: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property languageOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        languageOptions: Linter.FlatConfig['languageOptions'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          options: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parserOptions: Linter.ParserOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parserPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parserPath: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property parserServices

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parserServices: SourceCode.ParserServices;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property physicalFilename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  physicalFilename: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property settings

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sourceCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceCode: SourceCode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getAncestors

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getCwd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getCwd: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Use property cwd directly instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getDeclaredVariables

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getFilename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getFilename: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use property filename directly instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getPhysicalFilename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getPhysicalFilename: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use property physicalFilename directly instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getScope: () => Scope.Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getSourceCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getSourceCode: () => SourceCode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Use property sourceCode directly instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Indicates whether the rule has been deprecated. Omit if not deprecated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property docs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    docs?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /** Provides a short description of the rule. Commonly used when generating lists of rules. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    description?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /** Historically used by some plugins that divide rules into categories in their documentation. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    category?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /** Historically used by some plugins to indicate a rule belongs in their `recommended` configuration. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    recommended?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /** Specifies the URL at which the full documentation can be accessed. Code editors often use this to provide a helpful link on highlighted rule violations. */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    url?: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * TODO: remove this field in next major release of @types/eslint.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    * @deprecated use `meta.hasSuggestions` instead
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    suggestion?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Properties often used for documentation generation and tooling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fixable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fixable?: 'code' | 'whitespace' | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Specifies if the --fix option on the command line automatically fixes problems reported by the rule. Mandatory for fixable rules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hasSuggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hasSuggestions?: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Specifies whether the rule can return suggestions (defaults to false if omitted). Mandatory for rules that provide suggestions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property messages

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    messages?: { [messageId: string]: string } | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Violation and suggestion messages.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property replacedBy

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    schema?: JSONSchema4 | JSONSchema4[] | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Specifies the [options](https://eslint.org/docs/latest/developer-guide/working-with-rules#options-schemas) so ESLint can prevent invalid [rule configurations](https://eslint.org/docs/latest/user-guide/configuring/rules#configuring-rules). Mandatory for rules with options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RuleModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RuleModule {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property meta

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      meta?: RuleMetaData | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        schema?: RuleMetaData['schema'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 OldStyleRule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type OldStyleRule = RuleModule['create'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • TODO: Old style rules are planned to be removed in v9, remove this type then (https://github.com/eslint/rfcs/blob/main/designs/2021-schema-object-rules/README.md)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Use RuleModule instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ReportDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ReportDescriptor = ReportDescriptorMessage &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ReportDescriptorLocation &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ReportDescriptorOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ReportDescriptorLocation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ReportDescriptorMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ReportFixer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SuggestionDescriptorMessage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SuggestionReportDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SuggestionReportDescriptor = SuggestionDescriptorMessage &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SuggestionReportOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace RuleTester

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace RuleTester {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InvalidTestCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InvalidTestCase extends ValidTestCase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      errors: number | Array<TestCaseError | string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        output?: string | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SuggestionOutput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SuggestionOutput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property desc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              desc?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                messageId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property output

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  output: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TestCaseError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TestCaseError {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      column?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property endColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          endColumn?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property endLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            endLine?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              line?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                message?: string | RegExp | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property messageId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  messageId?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property suggestions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    suggestions?: SuggestionOutput[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ValidTestCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ValidTestCase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          code: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property filename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            filename?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property globals

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property only

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  only?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parser?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property parserOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parserOptions?: Linter.ParserOptions | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property settings

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Reference {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                from: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  identifier: ESTree.Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property init

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    init: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property resolved

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolved: Variable | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property writeExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        writeExpr: ESTree.Node | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isRead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isRead: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isReadOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isReadOnly: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isReadWrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isReadWrite: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isWrite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isWrite: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isWriteOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isWriteOnly: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      block: ESTree.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property childScopes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        childScopes: Scope[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property functionExpressionScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          functionExpressionScope: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isStrict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isStrict: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property references

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              references: Reference[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                set: Map<string, Variable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property through

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  through: Reference[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property upper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      upper: Scope | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property variables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variables: Variable[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property variableScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variableScope: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ScopeManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ScopeManager {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property globalScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              globalScope: Scope | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scopes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scopes: Scope[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method acquire

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getDeclaredVariables

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Variable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Variable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defs: Definition[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property identifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          identifiers: ESTree.Identifier[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property references

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              references: Reference[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scope: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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