@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?: Globals | undefined;

parserOptions?: Linter.ParserOptions | undefined;

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

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

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

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

name?: string | undefined;

version?: string | undefined;

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 | Linter.FlatConfig | Linter.FlatConfig[]>
    | undefined;

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

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

rules?: Record<string, Rule.OldStyleRule | 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?: Array<string | string[]>;

ignores?: 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?: 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'];
};

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

name?: string;

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

processor?: string | Processor;

rules?: Partial<Rules>;

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
    | 13
    | 14
    | 15
    | 2015
    | 2016
    | 2017
    | 2018
    | 2019
    | 2020
    | 2021
    | 2022
    | 2023
    | 2024
    | '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;