eslint

constructor(options?: ESLint.Options);

static configType: string;

static readonly defaultConfig: ConfigObject<Rules>[];

static readonly version: string;

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

findConfigFile: (filePath?: string) => Promise<string | undefined>;

static fromOptionsModule: (optionsURL: {
    readonly href: string;
}) => Promise<ESLint>;

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

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

hasFlag: (flag: string) => boolean;

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

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

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

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

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

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

static readonly version: string;

version: string;

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

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

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

getFixPassCount: () => Linter.Stats['fixPasses'];

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

getSourceCode: () => SourceCode;

getTimes: () => Linter.Stats['times'];

verify: {
    (
        code: SourceCode | string,
        config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
        filename?: string
    ): Linter.LintMessage[];
    (
        code: string | SourceCode,
        config: any,
        options: Linter.LintOptions
    ): CoreLintMessage[];
};

verifyAndFix: {
    (
        code: string,
        config: Linter.LegacyConfig | Linter.Config | Linter.Config[],
        filename?: string
    ): Linter.FixReport;
    (code: string, config: any, options: Linter.FixOptions): Linter.FixReport;
};

constructor(config?: ConfigObject<Rules>);

static describe: (...args: any) => any;

static it: (...args: any) => any;

static itOnly: (...args: any) => any;

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

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

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

constructor(config: SourceCode.Config);

ast: AST.Program;

getFirstToken: SourceCode.UnaryNodeCursorWithSkipOptions;

getFirstTokenBetween: SourceCode.BinaryCursorWithSkipOptions;

getFirstTokens: SourceCode.UnaryNodeCursorWithCountOptions;

getFirstTokensBetween: SourceCode.BinaryCursorWithCountOptions;

getLastToken: SourceCode.UnaryNodeCursorWithSkipOptions;

getLastTokenBetween: SourceCode.BinaryCursorWithSkipOptions;

getLastTokens: SourceCode.UnaryNodeCursorWithCountOptions;

getLastTokensBetween: SourceCode.BinaryCursorWithCountOptions;

getTokenAfter: SourceCode.UnaryCursorWithSkipOptions;

getTokenBefore: SourceCode.UnaryCursorWithSkipOptions;

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

getTokensAfter: SourceCode.UnaryCursorWithCountOptions;

getTokensBefore: SourceCode.UnaryCursorWithCountOptions;

getTokensBetween: SourceCode.BinaryCursorWithCountOptions;

hasBOM: boolean;

lines: string[];

parserServices: any;

scopeManager: Scope.ScopeManager;

text: string;

visitorKeys: SourceCode.VisitorKeys;

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

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

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

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

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

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

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

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

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

getLines: () => string[];

getLoc: (syntaxElement: AST.Token | ESTree.Node) => ESTree.SourceLocation;

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

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

getRange: (syntaxElement: AST.Token | ESTree.Node) => SourceRange;

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

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

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

getTokenOrCommentAfter: (
    node: ESTree.Node | AST.Token | ESTree.Comment,
    skip?: number | undefined
) => AST.Token | ESTree.Comment | null;

getTokenOrCommentBefore: (
    node: ESTree.Node | AST.Token | ESTree.Comment,
    skip?: number | undefined
) => AST.Token | ESTree.Comment | null;

isGlobalReference: (node: ESTree.Identifier) => boolean;

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

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

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

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

traverse: () => Iterable<TraversalStep>;

type Range = [number, number];

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

type CacheStrategy = 'content' | 'metadata';

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

type EditInfo = Rule.Fix;

type Environment = EnvironmentConfig;

type FixType = 'directive' | 'problem' | 'suggestion' | 'layout';

type Formatter = LoadedFormatter;

type FormatterFunction = (
    results: LintResult[],
    context: LintResultData
) => string | Promise<string>;

type ObjectMetaProperties = CoreObjectMetaProperties;

type Plugin = CorePlugin;

type BaseConfig<
    Rules extends RulesConfig = RulesConfig,
    OverrideRules extends RulesConfig = Rules
> = CoreBaseConfig<Rules, OverrideRules>;

type Config<Rules extends RulesConfig = RulesConfig> = ConfigObject<Rules>;

type ConfigOverride<Rules extends RulesConfig = RulesConfig> =
    CoreConfigOverride<Rules>;

type EcmaVersion = CoreEcmaVersion;

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

type FlatConfig<Rules extends RulesConfig = RulesConfig> = Config<Rules>;

type GlobalConf = GlobalAccess;

type Globals = GlobalsConfig;

type HasRules<Rules extends RulesConfig = RulesConfig> = CoreHasRules<Rules>;

type LegacyConfig<
    Rules extends RulesConfig = RulesConfig,
    OverrideRules extends RulesConfig = Rules
> = LegacyConfigObject<Rules, OverrideRules>;

type LinterOptions = LinterOptionsConfig;

type LintMessage = CoreLintMessage;

type LintSuggestion = CoreLintSuggestion;

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

type Parser = NonESTreeParser | ESTreeParser;

type ParserOptions = JavaScriptParserOptionsConfig;

type Processor<T extends string | ProcessorFile = string | ProcessorFile> =
    CoreProcessor<T>;

type ProcessorFile = CoreProcessorFile;

type RuleEntry<Options extends any[] = any[]> = RuleConfig<Options>;

type RuleSeverity = CoreSeverity;

type RuleSeverityAndOptions<Options extends any[] = any[]> = [
    RuleSeverity,
    ...Partial<Options>
];