@types/eslint

comments: ESTree.Comment[];

loc: SourceLocation;

range: Range;

tokens: Token[];

end: ESTree.Position;

start: ESTree.Position;

loc: SourceLocation;

range: Range;

type: TokenType;

value: string;

replacedBy: string[];

ruleId: string;

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

parserOptions?: Linter.ParserOptions | undefined;

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

errorCount: number;

fatalErrorCount: number;

filePath: string;

fixableErrorCount: number;

fixableWarningCount: number;

messages: Linter.LintMessage[];

output?: string | undefined;

source?: string | undefined;

suppressedMessages: Linter.SuppressedLintMessage[];

usedDeprecatedRules: DeprecatedRuleUse[];

warningCount: number;

cwd: string;

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

allowInlineConfig?: boolean | undefined;

baseConfig?: Linter.Config | undefined;

cache?: boolean | undefined;

cacheLocation?: string | undefined;

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

cwd?: string | undefined;

errorOnUnmatchedPattern?: boolean | undefined;

extensions?: string[] | undefined;

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

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

globInputPaths?: boolean | undefined;

ignore?: boolean | undefined;

ignorePath?: string | undefined;

overrideConfig?: Linter.Config | undefined;

overrideConfigFile?: string | undefined;

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

reportUnusedDisableDirectives?: Linter.StringSeverity | undefined;

resolvePluginsRelativeTo?: string | undefined;

rulePaths?: string[] | undefined;

useEslintrc?: boolean | undefined;

configs?: Record<string, ConfigData> | undefined;

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

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

rules?: Record<string, ((...args: any[]) => any) | Rule.RuleModule> | undefined;

$schema?: string | undefined;

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

extends?: string | string[] | undefined;

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

noInlineConfig?: boolean | undefined;

overrides?: Array<ConfigOverride<OverrideRules>> | undefined;

parser?: string | undefined;

parserOptions?: ParserOptions | undefined;

plugins?: string[] | undefined;

processor?: string | undefined;

reportUnusedDisableDirectives?: boolean | undefined;

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

ignorePatterns?: string | string[] | undefined;

root?: boolean | undefined;

excludedFiles?: string | string[] | undefined;

files: string | string[];

ast: AST.Program;

parserServices?: SourceCode.ParserServices | undefined;

scopeManager?: Scope.ScopeManager | undefined;

visitorKeys?: SourceCode.VisitorKeys | undefined;

fix?: boolean | undefined;

fixed: boolean;

messages: LintMessage[];

output: string;

files?: string | string[];

ignores?: string | string[];

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?: ParserModule;
    /**
     * 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'];
};

linterOptions?: {
    /**
     * A Boolean value indicating if inline configuration is allowed.
     */
    noInlineConfig?: boolean;
    /**
     * A Boolean value indicating if unused disable directives should be
     * tracked and reported.
     */
    reportUnusedDisableDirectives?: boolean;
};

plugins?: Record<string, ESLint.Plugin>;

processor?: string | Processor;

rules?: RulesRecord;

settings?: Record<string, unknown>;

rules?: Partial<Rules> | undefined;

column: number;

endColumn?: number | undefined;

endLine?: number | undefined;

fatal?: true | undefined;

fix?: Rule.Fix | undefined;

line: number;

message: string;

messageId?: string | undefined;

nodeType?: string | undefined;

ruleId: string | null;

severity: Severity;

source?: string | null | undefined;

suggestions?: LintSuggestion[] | undefined;

allowInlineConfig?: boolean | undefined;

disableFixes?: boolean | undefined;

filename?: string | undefined;

filterCodeBlock?: boolean | undefined;

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

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

reportUnusedDisableDirectives?: boolean | undefined;

desc: string;

fix: Rule.Fix;

messageId?: string | undefined;

justification: string;

kind: string;

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

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

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

[key: string]: any;

supportsAutofix?: boolean | undefined;

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

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

filename: string;

text: string;

[rule: string]: RuleEntry;

suppressions: LintSuppression[];

childCodePaths: CodePath[];

currentSegments: CodePathSegment[];

finalSegments: CodePathSegment[];

id: string;

initialSegment: CodePathSegment;

returnedSegments: CodePathSegment[];

thrownSegments: CodePathSegment[];

upper: CodePath | null;

id: string;

nextSegments: CodePathSegment[];

prevSegments: CodePathSegment[];

reachable: boolean;

range: AST.Range;

text: string;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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