@jinmi/ui 0.0.0-stage → 6.0.1

package/es/node_modules/.pnpm/eslint@9.39.5_jiti@2.6.1_supports-color@10.2.2/node_modules/eslint/lib/types/index.d.mts

@@ -0,0 +1,962 @@
+import { ArrayExpression, ArrayPattern, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BinaryExpression, BlockStatement, BreakStatement, CatchClause, ChainExpression, ClassBody, ClassDeclaration, ClassExpression, Comment, ConditionalExpression, ContinueStatement, DebuggerStatement, DoWhileStatement, EmptyStatement, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, Identifier, IfStatement, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, LabeledStatement, Literal, LogicalExpression, MemberExpression, MetaProperty, MethodDefinition, NewExpression, Node as Node$1, ObjectExpression, ObjectPattern, Position, PrivateIdentifier, Program, Property, PropertyDefinition, RestElement, ReturnStatement, SequenceExpression, SimpleCallExpression, SourceLocation as SourceLocation$1, SpreadElement, StaticBlock, Super, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, UnaryExpression, UpdateExpression, VariableDeclaration, VariableDeclarator, WhileStatement, WithStatement, YieldExpression } from "../../../../../@types_estree@1.0.9/node_modules/@types/estree/index.mjs";
+import { BaseConfig, ConfigObject, ConfigOverride, DeprecatedInfo, EcmaVersion as EcmaVersion$1, EnvironmentConfig, GlobalAccess, GlobalsConfig, HasRules, JavaScriptParserOptionsConfig, JavaScriptSourceType, LanguageOptions, LegacyConfigObject, LintMessage as LintMessage$1, LintSuggestion, LinterOptionsConfig, ObjectMetaProperties, Plugin as Plugin$1, Processor, ProcessorFile as ProcessorFile$1, RuleConfig, RuleContext as RuleContext$1, RuleDefinition, RuleFixer, RuleTextEdit, RuleTextEditor, RuleVisitor, RulesConfig, RulesMeta, Severity, SeverityLevel, SeverityName, SourceRange, SuggestedEdit, SuggestedEditBase, SuggestionMessage, TextSourceCode, TraversalStep, ViolationLocation, ViolationMessage, ViolationReport, ViolationReportBase } from "../../../../../@eslint_core@0.17.0/node_modules/@eslint/core/dist/esm/types.mjs";
+//#region node_modules/.pnpm/eslint@9.39.5_jiti@2.6.1_supports-color@10.2.2/node_modules/eslint/lib/types/index.d.ts
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+declare namespace AST {
+  type TokenType = "Boolean" | "Null" | "Identifier" | "PrivateIdentifier" | "Keyword" | "Punctuator" | "JSXIdentifier" | "JSXText" | "Numeric" | "String" | "Template" | "RegularExpression";
+  interface Token {
+    type: TokenType;
+    value: string;
+    range: Range;
+    loc: SourceLocation;
+  }
+  interface SourceLocation {
+    start: Position;
+    end: Position;
+  }
+  type Range = [number, number];
+  interface Program extends Program {
+    comments: Comment[];
+    tokens: Token[];
+    loc: SourceLocation;
+    range: Range;
+  }
+}
+declare namespace Scope {
+  interface ScopeManager {
+    scopes: Scope[];
+    globalScope: Scope | null;
+    acquire(node: Node$1, inner?: boolean): Scope | null;
+    getDeclaredVariables(node: Node$1): Variable[];
+  }
+  interface Scope {
+    type: "block" | "catch" | "class" | "class-field-initializer" | "class-static-block" | "for" | "function" | "function-expression-name" | "global" | "module" | "switch" | "with" | "TDZ";
+    isStrict: boolean;
+    upper: Scope | null;
+    childScopes: Scope[];
+    variableScope: Scope;
+    block: Node$1;
+    variables: Variable[];
+    set: Map<string, Variable>;
+    references: Reference[];
+    through: Reference[];
+    functionExpressionScope: boolean;
+    implicit?: {
+      variables: Variable[];
+      set: Map<string, Variable>;
+    };
+  }
+  interface Variable {
+    name: string;
+    scope: Scope;
+    identifiers: Identifier[];
+    references: Reference[];
+    defs: Definition[];
+  }
+  interface Reference {
+    identifier: Identifier;
+    from: Scope;
+    resolved: Variable | null;
+    writeExpr: Node$1 | null;
+    init: boolean;
+    isWrite(): boolean;
+    isRead(): boolean;
+    isWriteOnly(): boolean;
+    isReadOnly(): boolean;
+    isReadWrite(): boolean;
+  }
+  type DefinitionType = {
+    type: "CatchClause";
+    node: CatchClause;
+    parent: null;
+  } | {
+    type: "ClassName";
+    node: ClassDeclaration | ClassExpression;
+    parent: null;
+  } | {
+    type: "FunctionName";
+    node: FunctionDeclaration | FunctionExpression;
+    parent: null;
+  } | {
+    type: "ImplicitGlobalVariable";
+    node: AssignmentExpression | ForInStatement | ForOfStatement;
+    parent: null;
+  } | {
+    type: "ImportBinding";
+    node: ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier;
+    parent: ImportDeclaration;
+  } | {
+    type: "Parameter";
+    node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+    parent: null;
+  } | {
+    type: "TDZ";
+    node: any;
+    parent: null;
+  } | {
+    type: "Variable";
+    node: VariableDeclarator;
+    parent: VariableDeclaration;
+  };
+  type Definition = DefinitionType & {
+    name: Identifier;
+  };
+}
+// #region SourceCode
+declare class SourceCode implements TextSourceCode<{
+  LangOptions: Linter.LanguageOptions;
+  RootNode: AST.Program;
+  SyntaxElementWithLoc: AST.Token | Node$1;
+  ConfigNode: Comment;
+}> {
+  text: string;
+  ast: AST.Program;
+  lines: string[];
+  hasBOM: boolean;
+  parserServices: SourceCode.ParserServices;
+  scopeManager: Scope.ScopeManager;
+  visitorKeys: SourceCode.VisitorKeys;
+  constructor(text: string, ast: AST.Program);
+  constructor(config: SourceCode.Config);
+  static splitLines(text: string): string[];
+  getLoc(syntaxElement: AST.Token | Node$1): SourceLocation$1;
+  getRange(syntaxElement: AST.Token | Node$1): SourceRange;
+  getText(node?: Node$1, beforeCount?: number, afterCount?: number): string;
+  getLines(): string[];
+  getAllComments(): Comment[];
+  getAncestors(node: Node$1): Node$1[];
+  getDeclaredVariables(node: Node$1): Scope.Variable[];
+  /** @deprecated */
+  getJSDocComment(node: Node$1): Comment | null;
+  getNodeByRangeIndex(index: number): Node$1 | null;
+  /** @deprecated Use `isSpaceBetween()` instead. */
+  isSpaceBetweenTokens(first: Node$1 | AST.Token, second: Node$1 | AST.Token): boolean;
+  getLocFromIndex(index: number): Position;
+  getIndexFromLoc(location: Position): number;
+  // Inherited methods from TokenStore
+  // ---------------------------------
+  getTokenByRangeStart(offset: number, options?: {
+    includeComments: false;
+  }): AST.Token | null;
+  getTokenByRangeStart(offset: number, options: {
+    includeComments: boolean;
+  }): AST.Token | Comment | null;
+  getFirstToken: SourceCode.UnaryNodeCursorWithSkipOptions;
+  getFirstTokens: SourceCode.UnaryNodeCursorWithCountOptions;
+  getLastToken: SourceCode.UnaryNodeCursorWithSkipOptions;
+  getLastTokens: SourceCode.UnaryNodeCursorWithCountOptions;
+  getTokenBefore: SourceCode.UnaryCursorWithSkipOptions;
+  getTokensBefore: SourceCode.UnaryCursorWithCountOptions;
+  getTokenAfter: SourceCode.UnaryCursorWithSkipOptions;
+  getTokensAfter: SourceCode.UnaryCursorWithCountOptions;
+  /** @deprecated Use `getTokenBefore()` instead. */
+  getTokenOrCommentBefore(node: Node$1 | AST.Token | Comment, skip?: number | undefined): AST.Token | Comment | null;
+  /** @deprecated Use `getTokenAfter()` instead. */
+  getTokenOrCommentAfter(node: Node$1 | AST.Token | Comment, skip?: number | undefined): AST.Token | Comment | null;
+  getFirstTokenBetween: SourceCode.BinaryCursorWithSkipOptions;
+  getFirstTokensBetween: SourceCode.BinaryCursorWithCountOptions;
+  getLastTokenBetween: SourceCode.BinaryCursorWithSkipOptions;
+  getLastTokensBetween: SourceCode.BinaryCursorWithCountOptions;
+  getTokensBetween: SourceCode.BinaryCursorWithCountOptions;
+  getTokens: ((node: Node$1, beforeCount?: number, afterCount?: number) => AST.Token[]) & SourceCode.UnaryNodeCursorWithCountOptions;
+  commentsExistBetween(left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment): boolean;
+  getCommentsBefore(nodeOrToken: Node$1 | AST.Token): Comment[];
+  getCommentsAfter(nodeOrToken: Node$1 | AST.Token): Comment[];
+  getCommentsInside(node: Node$1): Comment[];
+  getScope(node: Node$1): Scope.Scope;
+  isSpaceBetween(first: Node$1 | AST.Token, second: Node$1 | AST.Token): boolean;
+  isGlobalReference(node: Identifier): boolean;
+  markVariableAsUsed(name: string, refNode?: Node$1): boolean;
+  traverse(): Iterable<TraversalStep>;
+}
+declare namespace SourceCode {
+  interface Config {
+    text: string;
+    ast: AST.Program;
+    hasBOM?: boolean | undefined;
+    parserServices?: ParserServices | null | undefined;
+    scopeManager?: Scope.ScopeManager | null | undefined;
+    visitorKeys?: VisitorKeys | null | undefined;
+  }
+  type ParserServices = any;
+  interface VisitorKeys {
+    [nodeType: string]: string[];
+  }
+  interface UnaryNodeCursorWithSkipOptions {
+    <T extends AST.Token>(node: Node$1, options: ((token: AST.Token) => token is T) | {
+      filter: (token: AST.Token) => token is T;
+      includeComments?: false | undefined;
+      skip?: number | undefined;
+    }): T | null;
+    <T extends AST.Token | Comment>(node: Node$1, options: {
+      filter: (tokenOrComment: AST.Token | Comment) => tokenOrComment is T;
+      includeComments: boolean;
+      skip?: number | undefined;
+    }): T | null;
+    (node: Node$1, options?: {
+      filter?: ((token: AST.Token) => boolean) | undefined;
+      includeComments?: false | undefined;
+      skip?: number | undefined;
+    } | ((token: AST.Token) => boolean) | number): AST.Token | null;
+    (node: Node$1, options: {
+      filter?: ((token: AST.Token | Comment) => boolean) | undefined;
+      includeComments: boolean;
+      skip?: number | undefined;
+    }): AST.Token | Comment | null;
+  }
+  interface UnaryNodeCursorWithCountOptions {
+    <T extends AST.Token>(node: Node$1, options: ((token: AST.Token) => token is T) | {
+      filter: (token: AST.Token) => token is T;
+      includeComments?: false | undefined;
+      count?: number | undefined;
+    }): T[];
+    <T extends AST.Token | Comment>(node: Node$1, options: {
+      filter: (tokenOrComment: AST.Token | Comment) => tokenOrComment is T;
+      includeComments: boolean;
+      count?: number | undefined;
+    }): T[];
+    (node: Node$1, options?: {
+      filter?: ((token: AST.Token) => boolean) | undefined;
+      includeComments?: false | undefined;
+      count?: number | undefined;
+    } | ((token: AST.Token) => boolean) | number): AST.Token[];
+    (node: Node$1, options: {
+      filter?: ((token: AST.Token | Comment) => boolean) | undefined;
+      includeComments: boolean;
+      count?: number | undefined;
+    }): Array<AST.Token | Comment>;
+  }
+  interface UnaryCursorWithSkipOptions {
+    <T extends AST.Token>(node: Node$1 | AST.Token | Comment, options: ((token: AST.Token) => token is T) | {
+      filter: (token: AST.Token) => token is T;
+      includeComments?: false | undefined;
+      skip?: number | undefined;
+    }): T | null;
+    <T extends AST.Token | Comment>(node: Node$1 | AST.Token | Comment, options: {
+      filter: (tokenOrComment: AST.Token | Comment) => tokenOrComment is T;
+      includeComments: boolean;
+      skip?: number | undefined;
+    }): T | null;
+    (node: Node$1 | AST.Token | Comment, options?: {
+      filter?: ((token: AST.Token) => boolean) | undefined;
+      includeComments?: false | undefined;
+      skip?: number | undefined;
+    } | ((token: AST.Token) => boolean) | number): AST.Token | null;
+    (node: Node$1 | AST.Token | Comment, options: {
+      filter?: ((token: AST.Token | Comment) => boolean) | undefined;
+      includeComments: boolean;
+      skip?: number | undefined;
+    }): AST.Token | Comment | null;
+  }
+  interface UnaryCursorWithCountOptions {
+    <T extends AST.Token>(node: Node$1 | AST.Token | Comment, options: ((token: AST.Token) => token is T) | {
+      filter: (token: AST.Token) => token is T;
+      includeComments?: false | undefined;
+      count?: number | undefined;
+    }): T[];
+    <T extends AST.Token | Comment>(node: Node$1 | AST.Token | Comment, options: {
+      filter: (tokenOrComment: AST.Token | Comment) => tokenOrComment is T;
+      includeComments: boolean;
+      count?: number | undefined;
+    }): T[];
+    (node: Node$1 | AST.Token | Comment, options?: {
+      filter?: ((token: AST.Token) => boolean) | undefined;
+      includeComments?: false | undefined;
+      count?: number | undefined;
+    } | ((token: AST.Token) => boolean) | number): AST.Token[];
+    (node: Node$1 | AST.Token | Comment, options: {
+      filter?: ((token: AST.Token | Comment) => boolean) | undefined;
+      includeComments: boolean;
+      count?: number | undefined;
+    }): Array<AST.Token | Comment>;
+  }
+  interface BinaryCursorWithSkipOptions {
+    <T extends AST.Token>(left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment, options: ((token: AST.Token) => token is T) | {
+      filter: (token: AST.Token) => token is T;
+      includeComments?: false | undefined;
+      skip?: number | undefined;
+    }): T | null;
+    <T extends AST.Token | Comment>(left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment, options: {
+      filter: (tokenOrComment: AST.Token | Comment) => tokenOrComment is T;
+      includeComments: boolean;
+      skip?: number | undefined;
+    }): T | null;
+    (left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment, options?: {
+      filter?: ((token: AST.Token) => boolean) | undefined;
+      includeComments?: false | undefined;
+      skip?: number | undefined;
+    } | ((token: AST.Token) => boolean) | number): AST.Token | null;
+    (left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment, options: {
+      filter?: ((token: AST.Token | Comment) => boolean) | undefined;
+      includeComments: boolean;
+      skip?: number | undefined;
+    }): AST.Token | Comment | null;
+  }
+  interface BinaryCursorWithCountOptions {
+    <T extends AST.Token>(left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment, options: ((token: AST.Token) => token is T) | {
+      filter: (token: AST.Token) => token is T;
+      includeComments?: false | undefined;
+      count?: number | undefined;
+    }): T[];
+    <T extends AST.Token | Comment>(left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment, options: {
+      filter: (tokenOrComment: AST.Token | Comment) => tokenOrComment is T;
+      includeComments: boolean;
+      count?: number | undefined;
+    }): T[];
+    (left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment, options?: {
+      filter?: ((token: AST.Token) => boolean) | undefined;
+      includeComments?: false | undefined;
+      count?: number | undefined;
+    } | ((token: AST.Token) => boolean) | number): AST.Token[];
+    (left: Node$1 | AST.Token | Comment, right: Node$1 | AST.Token | Comment, options: {
+      filter?: ((token: AST.Token | Comment) => boolean) | undefined;
+      includeComments: boolean;
+      count?: number | undefined;
+    }): Array<AST.Token | Comment>;
+  }
+}
+// #endregion
+type JSSyntaxElement = {
+  type: string;
+  loc?: SourceLocation$1 | null | undefined;
+};
+declare namespace Rule {
+  interface RuleModule extends RuleDefinition<{
+    LangOptions: Linter.LanguageOptions;
+    Code: SourceCode;
+    RuleOptions: any[];
+    Visitor: RuleListener;
+    Node: JSSyntaxElement;
+    MessageIds: string;
+    ExtRuleDocs: {};
+  }> {
+    create(context: RuleContext): RuleListener;
+  }
+  type NodeTypes = Node$1["type"];
+  interface NodeListener extends RuleVisitor {
+    ArrayExpression?: ((node: ArrayExpression & NodeParentExtension) => void) | undefined;
+    "ArrayExpression:exit"?: ((node: ArrayExpression & NodeParentExtension) => void) | undefined;
+    ArrayPattern?: ((node: ArrayPattern & NodeParentExtension) => void) | undefined;
+    "ArrayPattern:exit"?: ((node: ArrayPattern & NodeParentExtension) => void) | undefined;
+    ArrowFunctionExpression?: ((node: ArrowFunctionExpression & NodeParentExtension) => void) | undefined;
+    "ArrowFunctionExpression:exit"?: ((node: ArrowFunctionExpression & NodeParentExtension) => void) | undefined;
+    AssignmentExpression?: ((node: AssignmentExpression & NodeParentExtension) => void) | undefined;
+    "AssignmentExpression:exit"?: ((node: AssignmentExpression & NodeParentExtension) => void) | undefined;
+    AssignmentPattern?: ((node: AssignmentPattern & NodeParentExtension) => void) | undefined;
+    "AssignmentPattern:exit"?: ((node: AssignmentPattern & NodeParentExtension) => void) | undefined;
+    AwaitExpression?: ((node: AwaitExpression & NodeParentExtension) => void) | undefined;
+    "AwaitExpression:exit"?: ((node: AwaitExpression & NodeParentExtension) => void) | undefined;
+    BinaryExpression?: ((node: BinaryExpression & NodeParentExtension) => void) | undefined;
+    "BinaryExpression:exit"?: ((node: BinaryExpression & NodeParentExtension) => void) | undefined;
+    BlockStatement?: ((node: BlockStatement & NodeParentExtension) => void) | undefined;
+    "BlockStatement:exit"?: ((node: BlockStatement & NodeParentExtension) => void) | undefined;
+    BreakStatement?: ((node: BreakStatement & NodeParentExtension) => void) | undefined;
+    "BreakStatement:exit"?: ((node: BreakStatement & NodeParentExtension) => void) | undefined;
+    CallExpression?: ((node: SimpleCallExpression & NodeParentExtension) => void) | undefined;
+    "CallExpression:exit"?: ((node: SimpleCallExpression & NodeParentExtension) => void) | undefined;
+    CatchClause?: ((node: CatchClause & NodeParentExtension) => void) | undefined;
+    "CatchClause:exit"?: ((node: CatchClause & NodeParentExtension) => void) | undefined;
+    ChainExpression?: ((node: ChainExpression & NodeParentExtension) => void) | undefined;
+    "ChainExpression:exit"?: ((node: ChainExpression & NodeParentExtension) => void) | undefined;
+    ClassBody?: ((node: ClassBody & NodeParentExtension) => void) | undefined;
+    "ClassBody:exit"?: ((node: ClassBody & NodeParentExtension) => void) | undefined;
+    ClassDeclaration?: ((node: ClassDeclaration & NodeParentExtension) => void) | undefined;
+    "ClassDeclaration:exit"?: ((node: ClassDeclaration & NodeParentExtension) => void) | undefined;
+    ClassExpression?: ((node: ClassExpression & NodeParentExtension) => void) | undefined;
+    "ClassExpression:exit"?: ((node: ClassExpression & NodeParentExtension) => void) | undefined;
+    ConditionalExpression?: ((node: ConditionalExpression & NodeParentExtension) => void) | undefined;
+    "ConditionalExpression:exit"?: ((node: ConditionalExpression & NodeParentExtension) => void) | undefined;
+    ContinueStatement?: ((node: ContinueStatement & NodeParentExtension) => void) | undefined;
+    "ContinueStatement:exit"?: ((node: ContinueStatement & NodeParentExtension) => void) | undefined;
+    DebuggerStatement?: ((node: DebuggerStatement & NodeParentExtension) => void) | undefined;
+    "DebuggerStatement:exit"?: ((node: DebuggerStatement & NodeParentExtension) => void) | undefined;
+    DoWhileStatement?: ((node: DoWhileStatement & NodeParentExtension) => void) | undefined;
+    "DoWhileStatement:exit"?: ((node: DoWhileStatement & NodeParentExtension) => void) | undefined;
+    EmptyStatement?: ((node: EmptyStatement & NodeParentExtension) => void) | undefined;
+    "EmptyStatement:exit"?: ((node: EmptyStatement & NodeParentExtension) => void) | undefined;
+    ExportAllDeclaration?: ((node: ExportAllDeclaration & NodeParentExtension) => void) | undefined;
+    "ExportAllDeclaration:exit"?: ((node: ExportAllDeclaration & NodeParentExtension) => void) | undefined;
+    ExportDefaultDeclaration?: ((node: ExportDefaultDeclaration & NodeParentExtension) => void) | undefined;
+    "ExportDefaultDeclaration:exit"?: ((node: ExportDefaultDeclaration & NodeParentExtension) => void) | undefined;
+    ExportNamedDeclaration?: ((node: ExportNamedDeclaration & NodeParentExtension) => void) | undefined;
+    "ExportNamedDeclaration:exit"?: ((node: ExportNamedDeclaration & NodeParentExtension) => void) | undefined;
+    ExportSpecifier?: ((node: ExportSpecifier & NodeParentExtension) => void) | undefined;
+    "ExportSpecifier:exit"?: ((node: ExportSpecifier & NodeParentExtension) => void) | undefined;
+    ExpressionStatement?: ((node: ExpressionStatement & NodeParentExtension) => void) | undefined;
+    "ExpressionStatement:exit"?: ((node: ExpressionStatement & NodeParentExtension) => void) | undefined;
+    ForInStatement?: ((node: ForInStatement & NodeParentExtension) => void) | undefined;
+    "ForInStatement:exit"?: ((node: ForInStatement & NodeParentExtension) => void) | undefined;
+    ForOfStatement?: ((node: ForOfStatement & NodeParentExtension) => void) | undefined;
+    "ForOfStatement:exit"?: ((node: ForOfStatement & NodeParentExtension) => void) | undefined;
+    ForStatement?: ((node: ForStatement & NodeParentExtension) => void) | undefined;
+    "ForStatement:exit"?: ((node: ForStatement & NodeParentExtension) => void) | undefined;
+    FunctionDeclaration?: ((node: FunctionDeclaration & NodeParentExtension) => void) | undefined;
+    "FunctionDeclaration:exit"?: ((node: FunctionDeclaration & NodeParentExtension) => void) | undefined;
+    FunctionExpression?: ((node: FunctionExpression & NodeParentExtension) => void) | undefined;
+    "FunctionExpression:exit"?: ((node: FunctionExpression & NodeParentExtension) => void) | undefined;
+    Identifier?: ((node: Identifier & NodeParentExtension) => void) | undefined;
+    "Identifier:exit"?: ((node: Identifier & NodeParentExtension) => void) | undefined;
+    IfStatement?: ((node: IfStatement & NodeParentExtension) => void) | undefined;
+    "IfStatement:exit"?: ((node: IfStatement & NodeParentExtension) => void) | undefined;
+    ImportDeclaration?: ((node: ImportDeclaration & NodeParentExtension) => void) | undefined;
+    "ImportDeclaration:exit"?: ((node: ImportDeclaration & NodeParentExtension) => void) | undefined;
+    ImportDefaultSpecifier?: ((node: ImportDefaultSpecifier & NodeParentExtension) => void) | undefined;
+    "ImportDefaultSpecifier:exit"?: ((node: ImportDefaultSpecifier & NodeParentExtension) => void) | undefined;
+    ImportExpression?: ((node: ImportExpression & NodeParentExtension) => void) | undefined;
+    "ImportExpression:exit"?: ((node: ImportExpression & NodeParentExtension) => void) | undefined;
+    ImportNamespaceSpecifier?: ((node: ImportNamespaceSpecifier & NodeParentExtension) => void) | undefined;
+    "ImportNamespaceSpecifier:exit"?: ((node: ImportNamespaceSpecifier & NodeParentExtension) => void) | undefined;
+    ImportSpecifier?: ((node: ImportSpecifier & NodeParentExtension) => void) | undefined;
+    "ImportSpecifier:exit"?: ((node: ImportSpecifier & NodeParentExtension) => void) | undefined;
+    LabeledStatement?: ((node: LabeledStatement & NodeParentExtension) => void) | undefined;
+    "LabeledStatement:exit"?: ((node: LabeledStatement & NodeParentExtension) => void) | undefined;
+    Literal?: ((node: Literal & NodeParentExtension) => void) | undefined;
+    "Literal:exit"?: ((node: Literal & NodeParentExtension) => void) | undefined;
+    LogicalExpression?: ((node: LogicalExpression & NodeParentExtension) => void) | undefined;
+    "LogicalExpression:exit"?: ((node: LogicalExpression & NodeParentExtension) => void) | undefined;
+    MemberExpression?: ((node: MemberExpression & NodeParentExtension) => void) | undefined;
+    "MemberExpression:exit"?: ((node: MemberExpression & NodeParentExtension) => void) | undefined;
+    MetaProperty?: ((node: MetaProperty & NodeParentExtension) => void) | undefined;
+    "MetaProperty:exit"?: ((node: MetaProperty & NodeParentExtension) => void) | undefined;
+    MethodDefinition?: ((node: MethodDefinition & NodeParentExtension) => void) | undefined;
+    "MethodDefinition:exit"?: ((node: MethodDefinition & NodeParentExtension) => void) | undefined;
+    NewExpression?: ((node: NewExpression & NodeParentExtension) => void) | undefined;
+    "NewExpression:exit"?: ((node: NewExpression & NodeParentExtension) => void) | undefined;
+    ObjectExpression?: ((node: ObjectExpression & NodeParentExtension) => void) | undefined;
+    "ObjectExpression:exit"?: ((node: ObjectExpression & NodeParentExtension) => void) | undefined;
+    ObjectPattern?: ((node: ObjectPattern & NodeParentExtension) => void) | undefined;
+    "ObjectPattern:exit"?: ((node: ObjectPattern & NodeParentExtension) => void) | undefined;
+    PrivateIdentifier?: ((node: PrivateIdentifier & NodeParentExtension) => void) | undefined;
+    "PrivateIdentifier:exit"?: ((node: PrivateIdentifier & NodeParentExtension) => void) | undefined;
+    Program?: ((node: AST.Program) => void) | undefined;
+    "Program:exit"?: ((node: AST.Program) => void) | undefined;
+    Property?: ((node: Property & NodeParentExtension) => void) | undefined;
+    "Property:exit"?: ((node: Property & NodeParentExtension) => void) | undefined;
+    PropertyDefinition?: ((node: PropertyDefinition & NodeParentExtension) => void) | undefined;
+    "PropertyDefinition:exit"?: ((node: PropertyDefinition & NodeParentExtension) => void) | undefined;
+    RestElement?: ((node: RestElement & NodeParentExtension) => void) | undefined;
+    "RestElement:exit"?: ((node: RestElement & NodeParentExtension) => void) | undefined;
+    ReturnStatement?: ((node: ReturnStatement & NodeParentExtension) => void) | undefined;
+    "ReturnStatement:exit"?: ((node: ReturnStatement & NodeParentExtension) => void) | undefined;
+    SequenceExpression?: ((node: SequenceExpression & NodeParentExtension) => void) | undefined;
+    "SequenceExpression:exit"?: ((node: SequenceExpression & NodeParentExtension) => void) | undefined;
+    SpreadElement?: ((node: SpreadElement & NodeParentExtension) => void) | undefined;
+    "SpreadElement:exit"?: ((node: SpreadElement & NodeParentExtension) => void) | undefined;
+    StaticBlock?: ((node: StaticBlock & NodeParentExtension) => void) | undefined;
+    "StaticBlock:exit"?: ((node: StaticBlock & NodeParentExtension) => void) | undefined;
+    Super?: ((node: Super & NodeParentExtension) => void) | undefined;
+    "Super:exit"?: ((node: Super & NodeParentExtension) => void) | undefined;
+    SwitchCase?: ((node: SwitchCase & NodeParentExtension) => void) | undefined;
+    "SwitchCase:exit"?: ((node: SwitchCase & NodeParentExtension) => void) | undefined;
+    SwitchStatement?: ((node: SwitchStatement & NodeParentExtension) => void) | undefined;
+    "SwitchStatement:exit"?: ((node: SwitchStatement & NodeParentExtension) => void) | undefined;
+    TaggedTemplateExpression?: ((node: TaggedTemplateExpression & NodeParentExtension) => void) | undefined;
+    "TaggedTemplateExpression:exit"?: ((node: TaggedTemplateExpression & NodeParentExtension) => void) | undefined;
+    TemplateElement?: ((node: TemplateElement & NodeParentExtension) => void) | undefined;
+    "TemplateElement:exit"?: ((node: TemplateElement & NodeParentExtension) => void) | undefined;
+    TemplateLiteral?: ((node: TemplateLiteral & NodeParentExtension) => void) | undefined;
+    "TemplateLiteral:exit"?: ((node: TemplateLiteral & NodeParentExtension) => void) | undefined;
+    ThisExpression?: ((node: ThisExpression & NodeParentExtension) => void) | undefined;
+    "ThisExpression:exit"?: ((node: ThisExpression & NodeParentExtension) => void) | undefined;
+    ThrowStatement?: ((node: ThrowStatement & NodeParentExtension) => void) | undefined;
+    "ThrowStatement:exit"?: ((node: ThrowStatement & NodeParentExtension) => void) | undefined;
+    TryStatement?: ((node: TryStatement & NodeParentExtension) => void) | undefined;
+    "TryStatement:exit"?: ((node: TryStatement & NodeParentExtension) => void) | undefined;
+    UnaryExpression?: ((node: UnaryExpression & NodeParentExtension) => void) | undefined;
+    "UnaryExpression:exit"?: ((node: UnaryExpression & NodeParentExtension) => void) | undefined;
+    UpdateExpression?: ((node: UpdateExpression & NodeParentExtension) => void) | undefined;
+    "UpdateExpression:exit"?: ((node: UpdateExpression & NodeParentExtension) => void) | undefined;
+    VariableDeclaration?: ((node: VariableDeclaration & NodeParentExtension) => void) | undefined;
+    "VariableDeclaration:exit"?: ((node: VariableDeclaration & NodeParentExtension) => void) | undefined;
+    VariableDeclarator?: ((node: VariableDeclarator & NodeParentExtension) => void) | undefined;
+    "VariableDeclarator:exit"?: ((node: VariableDeclarator & NodeParentExtension) => void) | undefined;
+    WhileStatement?: ((node: WhileStatement & NodeParentExtension) => void) | undefined;
+    "WhileStatement:exit"?: ((node: WhileStatement & NodeParentExtension) => void) | undefined;
+    WithStatement?: ((node: WithStatement & NodeParentExtension) => void) | undefined;
+    "WithStatement:exit"?: ((node: WithStatement & NodeParentExtension) => void) | undefined;
+    YieldExpression?: ((node: YieldExpression & NodeParentExtension) => void) | undefined;
+    "YieldExpression:exit"?: ((node: YieldExpression & NodeParentExtension) => void) | undefined;
+  }
+  interface NodeParentExtension {
+    parent: Node;
+  }
+  type Node = (AST.Program & {
+    parent: null;
+  }) | (Exclude<Node$1, Program> & NodeParentExtension);
+  interface RuleListener extends NodeListener {
+    onCodePathStart?(codePath: CodePath, node: Node): void;
+    onCodePathEnd?(codePath: CodePath, node: Node): void;
+    onCodePathSegmentStart?(segment: CodePathSegment, node: Node): void;
+    onCodePathSegmentEnd?(segment: CodePathSegment, node: Node): void;
+    onUnreachableCodePathSegmentStart?(segment: CodePathSegment, node: Node): void;
+    onUnreachableCodePathSegmentEnd?(segment: CodePathSegment, node: Node): void;
+    onCodePathSegmentLoop?(fromSegment: CodePathSegment, toSegment: CodePathSegment, node: Node): void;
+    [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;
+  }
+  type CodePathOrigin = "program" | "function" | "class-field-initializer" | "class-static-block";
+  interface CodePath {
+    id: string;
+    origin: CodePathOrigin;
+    initialSegment: CodePathSegment;
+    finalSegments: CodePathSegment[];
+    returnedSegments: CodePathSegment[];
+    thrownSegments: CodePathSegment[];
+    upper: CodePath | null;
+    childCodePaths: CodePath[];
+  }
+  interface CodePathSegment {
+    id: string;
+    nextSegments: CodePathSegment[];
+    prevSegments: CodePathSegment[];
+    reachable: boolean;
+  }
+  type RuleMetaData = RulesMeta;
+  interface RuleContext extends RuleContext$1<{
+    LangOptions: Linter.LanguageOptions;
+    Code: SourceCode;
+    RuleOptions: any[];
+    Node: JSSyntaxElement;
+    MessageIds: string;
+  }> {}
+  type ReportFixer = RuleFixer;
+  /** @deprecated Use `ReportDescriptorOptions` instead. */
+  type ReportDescriptorOptionsBase = ViolationReportBase;
+  type SuggestionReportOptions = SuggestedEditBase;
+  type SuggestionDescriptorMessage = SuggestionMessage;
+  type SuggestionReportDescriptor = SuggestedEdit;
+  // redundant with ReportDescriptorOptionsBase but kept for clarity
+  type ReportDescriptorOptions = ViolationReportBase;
+  type ReportDescriptor = ViolationReport<Node$1>;
+  type ReportDescriptorMessage = ViolationMessage;
+  type ReportDescriptorLocation = ViolationLocation<Node$1>;
+  type RuleFixer = RuleTextEditor<Node$1 | AST.Token>;
+  type Fix = RuleTextEdit;
+}
+// #region Linter
+declare class Linter {
+  static readonly version: string;
+  version: string;
+  constructor(options?: {
+    cwd?: string | undefined;
+    configType?: "flat" | "eslintrc";
+  });
+  verify(code: SourceCode | string, config: Linter.LegacyConfig | Linter.Config | Linter.Config[], filename?: string): Linter.LintMessage[];
+  verify(code: SourceCode | string, config: Linter.LegacyConfig | Linter.Config | Linter.Config[], options: Linter.LintOptions): Linter.LintMessage[];
+  verifyAndFix(code: string, config: Linter.LegacyConfig | Linter.Config | Linter.Config[], filename?: string): Linter.FixReport;
+  verifyAndFix(code: string, config: Linter.LegacyConfig | Linter.Config | Linter.Config[], options: Linter.FixOptions): Linter.FixReport;
+  getSourceCode(): SourceCode;
+  defineRule(name: string, rule: Rule.RuleModule): void;
+  defineRules(rules: {
+    [name: string]: Rule.RuleModule;
+  }): void;
+  getRules(): Map<string, Rule.RuleModule>;
+  defineParser(name: string, parser: Linter.Parser): void;
+  getTimes(): Linter.Stats["times"];
+  getFixPassCount(): Linter.Stats["fixPasses"];
+}
+declare namespace Linter {
+  /**
+   * The numeric severity level for a rule.
+   *
+   * - `0` means off.
+   * - `1` means warn.
+   * - `2` means error.
+   *
+   * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)
+   */
+  type Severity = SeverityLevel;
+  /**
+   * The human readable severity level for a rule.
+   *
+   * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)
+   */
+  type StringSeverity = SeverityName;
+  /**
+   * The numeric or human readable severity level for a rule.
+   *
+   * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)
+   */
+  type RuleSeverity = Severity;
+  /**
+   * An array containing the rule severity level, followed by the rule options.
+   *
+   * @see [Rules](https://eslint.org/docs/latest/use/configure/rules)
+   */
+  type RuleSeverityAndOptions<Options extends any[] = any[]> = [RuleSeverity, ...Partial<Options>];
+  /**
+   * The severity level for the rule or an array containing the rule severity level, followed by the rule options.
+   *
+   * @see [Rules](https://eslint.org/docs/latest/use/configure/rules)
+   */
+  type RuleEntry<Options extends any[] = any[]> = RuleConfig<Options>;
+  /**
+   * The rules config object is a key/value map of rule names and their severity and options.
+   */
+  type RulesRecord = RulesConfig;
+  /**
+   * A configuration object that may have a `rules` block.
+   */
+  type HasRules<Rules extends RulesConfig = RulesConfig> = HasRules<Rules>;
+  /**
+   * The ECMAScript version of the code being linted.
+   */
+  type EcmaVersion = EcmaVersion$1;
+  /**
+   * The type of JavaScript source code.
+   */
+  type SourceType = JavaScriptSourceType;
+  /**
+   * ESLint legacy configuration.
+   *
+   * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
+   */
+  type BaseConfig<Rules extends RulesConfig = RulesConfig, OverrideRules extends RulesConfig = Rules> = BaseConfig<Rules, OverrideRules>;
+  /**
+   * The overwrites that apply more differing configuration to specific files or directories.
+   */
+  type ConfigOverride<Rules extends RulesConfig = RulesConfig> = ConfigOverride<Rules>;
+  /**
+   * ESLint legacy configuration.
+   *
+   * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
+   */
+  // https://github.com/eslint/eslint/blob/v8.57.0/conf/config-schema.js
+  type LegacyConfig<Rules extends RulesConfig = RulesConfig, OverrideRules extends RulesConfig = Rules> = LegacyConfigObject<Rules, OverrideRules>;
+  /**
+   * Parser options.
+   *
+   * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options)
+   */
+  type ParserOptions = JavaScriptParserOptionsConfig;
+  /**
+   * Options used for linting code with `Linter#verify` and `Linter#verifyAndFix`.
+   */
+  interface LintOptions {
+    filename?: string | undefined;
+    preprocess?: ((code: string) => string[]) | undefined;
+    postprocess?: ((problemLists: LintMessage[][]) => LintMessage[]) | undefined;
+    filterCodeBlock?: ((filename: string, text: string) => boolean) | undefined;
+    disableFixes?: boolean | undefined;
+    allowInlineConfig?: boolean | undefined;
+    reportUnusedDisableDirectives?: boolean | undefined;
+  }
+  type LintSuggestion = LintSuggestion;
+  type LintMessage = LintMessage$1;
+  interface LintSuppression {
+    kind: string;
+    justification: string;
+  }
+  interface SuppressedLintMessage extends LintMessage {
+    /** The suppression info. */
+    suppressions: LintSuppression[];
+  }
+  interface FixOptions extends LintOptions {
+    fix?: boolean | undefined;
+  }
+  interface FixReport {
+    fixed: boolean;
+    output: string;
+    messages: LintMessage[];
+  }
+  // Temporarily loosen type for just flat config files (see https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68232)
+  type NonESTreeParser = ESLint.ObjectMetaProperties & ({
+    parse(text: string, options?: any): unknown;
+  } | {
+    parseForESLint(text: string, options?: any): Omit<ESLintParseResult, "ast" | "scopeManager"> & {
+      ast: unknown;
+      scopeManager?: unknown;
+    };
+  });
+  type ESTreeParser = ESLint.ObjectMetaProperties & ({
+    parse(text: string, options?: any): AST.Program;
+  } | {
+    parseForESLint(text: string, options?: any): ESLintParseResult;
+  });
+  type Parser = NonESTreeParser | ESTreeParser;
+  interface ESLintParseResult {
+    /** The AST object. */
+    ast: AST.Program;
+    /** The services that the parser provides. */
+    services?: SourceCode.ParserServices | undefined;
+    /** The scope manager of the AST. */
+    scopeManager?: Scope.ScopeManager | undefined;
+    /** The visitor keys of the AST. */
+    visitorKeys?: SourceCode.VisitorKeys | undefined;
+  }
+  type ProcessorFile = ProcessorFile$1;
+  // https://eslint.org/docs/latest/extend/plugins#processors-in-plugins
+  type Processor<T extends string | ProcessorFile = string | ProcessorFile> = Processor<T>;
+  type Config<Rules extends RulesConfig = RulesConfig> = ConfigObject<Rules>;
+  /** @deprecated  Use `Config` instead of `FlatConfig` */
+  type FlatConfig<Rules extends RulesConfig = RulesConfig> = Config<Rules>;
+  type GlobalConf = GlobalAccess;
+  type Globals = GlobalsConfig;
+  interface LanguageOptions extends 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?: EcmaVersion | undefined;
+    /**
+     * 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?: SourceType | undefined;
+    /**
+     * An object specifying additional objects that should be added to the
+     * global scope during linting.
+     */
+    globals?: Globals | undefined;
+    /**
+     * An object containing a parse() or parseForESLint() method.
+     * If not configured, the default ESLint parser (Espree) will be used.
+     */
+    parser?: Parser | undefined;
+    /**
+     * An object specifying additional options that are passed directly to the
+     * parser() method on the parser. The available options are parser-dependent
+     */
+    parserOptions?: Linter.ParserOptions | undefined;
+  }
+  type LinterOptions = LinterOptionsConfig;
+  /**
+   * Performance statistics.
+   */
+  interface Stats {
+    /**
+     * The number of times ESLint has applied at least one fix after linting.
+     */
+    fixPasses: number;
+    /**
+     * The times spent on (parsing, fixing, linting) a file, where the linting refers to the timing information for each rule.
+     */
+    times: {
+      passes: TimePass[];
+    };
+  }
+  interface TimePass {
+    /**
+     * The parse object containing all parse time information.
+     */
+    parse: {
+      total: number;
+    };
+    /**
+     * The rules object containing all lint time information for each rule.
+     */
+    rules?: Record<string, {
+      total: number;
+    }>;
+    /**
+     * The fix object containing all fix time information.
+     */
+    fix: {
+      total: number;
+    };
+    /**
+     * The total time that is spent on (parsing, fixing, linting) a file.
+     */
+    total: number;
+  }
+}
+// #endregion
+// #region ESLint
+declare class ESLint {
+  static configType: "flat";
+  static readonly version: string;
+  /**
+   * The default configuration that ESLint uses internally. This is provided for tooling that wants to calculate configurations using the same defaults as ESLint.
+   * Keep in mind that the default configuration may change from version to version, so you shouldn't rely on any particular keys or values to be present.
+   */
+  static readonly defaultConfig: Linter.Config[];
+  static outputFixes(results: ESLint.LintResult[]): Promise<void>;
+  static getErrorResults(results: ESLint.LintResult[]): ESLint.LintResult[];
+  constructor(options?: ESLint.Options);
+  lintFiles(patterns: string | string[]): Promise<ESLint.LintResult[]>;
+  lintText(code: string, options?: {
+    filePath?: string | undefined;
+    warnIgnored?: boolean | undefined;
+  }): Promise<ESLint.LintResult[]>;
+  getRulesMetaForResults(results: ESLint.LintResult[]): ESLint.LintResultData["rulesMeta"];
+  hasFlag(flag: string): boolean;
+  calculateConfigForFile(filePath: string): Promise<any>;
+  findConfigFile(filePath?: string): Promise<string | undefined>;
+  isPathIgnored(filePath: string): Promise<boolean>;
+  loadFormatter(nameOrPath?: string): Promise<ESLint.LoadedFormatter>;
+  static fromOptionsModule(optionsURL: {
+    readonly href: string;
+  }): Promise<ESLint>;
+}
+declare namespace ESLint {
+  type ConfigData<Rules extends Linter.RulesRecord = RulesConfig> = Omit<Linter.LegacyConfig<Rules>, "$schema">;
+  type Environment = EnvironmentConfig;
+  type ObjectMetaProperties = ObjectMetaProperties;
+  type Plugin = Plugin$1;
+  type FixType = "directive" | "problem" | "suggestion" | "layout";
+  type CacheStrategy = "content" | "metadata";
+  interface Options {
+    // File enumeration
+    cwd?: string | undefined;
+    errorOnUnmatchedPattern?: boolean | undefined;
+    globInputPaths?: boolean | undefined;
+    ignore?: boolean | undefined;
+    ignorePatterns?: string[] | null | undefined;
+    passOnNoPatterns?: boolean | undefined;
+    warnIgnored?: boolean | undefined;
+    // Linting
+    allowInlineConfig?: boolean | undefined;
+    baseConfig?: Linter.Config | Linter.Config[] | null | undefined;
+    overrideConfig?: Linter.Config | Linter.Config[] | null | undefined;
+    overrideConfigFile?: string | true | null | undefined;
+    plugins?: Record<string, Plugin> | null | undefined;
+    ruleFilter?: ((arg: {
+      ruleId: string;
+      severity: Exclude<Linter.Severity, 0>;
+    }) => boolean) | undefined;
+    stats?: boolean | undefined;
+    // Autofix
+    fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined;
+    fixTypes?: FixType[] | null | undefined;
+    // Cache-related
+    cache?: boolean | undefined;
+    cacheLocation?: string | undefined;
+    cacheStrategy?: CacheStrategy | undefined;
+    // Other Options
+    concurrency?: number | "auto" | "off" | undefined;
+    flags?: string[] | undefined;
+  }
+  interface LegacyOptions {
+    // File enumeration
+    cwd?: string | undefined;
+    errorOnUnmatchedPattern?: boolean | undefined;
+    extensions?: string[] | undefined;
+    globInputPaths?: boolean | undefined;
+    ignore?: boolean | undefined;
+    ignorePath?: string | undefined;
+    // Linting
+    allowInlineConfig?: boolean | undefined;
+    baseConfig?: Linter.LegacyConfig | undefined;
+    overrideConfig?: Linter.LegacyConfig | undefined;
+    overrideConfigFile?: string | undefined;
+    plugins?: Record<string, Plugin> | undefined;
+    reportUnusedDisableDirectives?: Linter.StringSeverity | undefined;
+    resolvePluginsRelativeTo?: string | undefined;
+    rulePaths?: string[] | undefined;
+    useEslintrc?: boolean | undefined;
+    // Autofix
+    fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined;
+    fixTypes?: FixType[] | null | undefined;
+    // Cache-related
+    cache?: boolean | undefined;
+    cacheLocation?: string | undefined;
+    cacheStrategy?: CacheStrategy | undefined;
+    // Other Options
+    flags?: string[] | undefined;
+  }
+  /** A linting result. */
+  interface LintResult {
+    /** The path to the file that was linted. */
+    filePath: string;
+    /** All of the messages for the result. */
+    messages: Linter.LintMessage[];
+    /** All of the suppressed messages for the result. */
+    suppressedMessages: Linter.SuppressedLintMessage[];
+    /** Number of errors for the result. */
+    errorCount: number;
+    /** Number of fatal errors for the result. */
+    fatalErrorCount: number;
+    /** Number of warnings for the result. */
+    warningCount: number;
+    /** Number of fixable errors for the result. */
+    fixableErrorCount: number;
+    /** Number of fixable warnings for the result. */
+    fixableWarningCount: number;
+    /** The source code of the file that was linted, with as many fixes applied as possible. */
+    output?: string | undefined;
+    /** The source code of the file that was linted. */
+    source?: string | undefined;
+    /** The performance statistics collected with the `stats` flag. */
+    stats?: Linter.Stats | undefined;
+    /** The list of used deprecated rules. */
+    usedDeprecatedRules: DeprecatedRuleUse[];
+  }
+  /**
+   * Information provided when the maximum warning threshold is exceeded.
+   */
+  interface MaxWarningsExceeded {
+    /**
+     * Number of warnings to trigger nonzero exit code.
+     */
+    maxWarnings: number;
+    /**
+     * Number of warnings found while linting.
+     */
+    foundWarnings: number;
+  }
+  interface LintResultData {
+    cwd: string;
+    maxWarningsExceeded?: MaxWarningsExceeded | undefined;
+    rulesMeta: {
+      [ruleId: string]: Rule.RuleMetaData;
+    };
+  }
+  /**
+   * Information about deprecated rules.
+   */
+  interface DeprecatedRuleUse {
+    /**
+     * The rule ID.
+     */
+    ruleId: string;
+    /**
+     * The rule IDs that replace this deprecated rule.
+     */
+    replacedBy: string[];
+    /**
+     * The raw deprecated info provided by the rule.
+     * - Undefined if the rule's `meta.deprecated` property is a boolean.
+     * - Unset when using the legacy eslintrc configuration.
+     */
+    info?: DeprecatedInfo | undefined;
+  }
+  /**
+   * Metadata about results for formatters.
+   */
+  interface ResultsMeta {
+    /**
+     * Present if the maxWarnings threshold was exceeded.
+     */
+    maxWarningsExceeded?: MaxWarningsExceeded | undefined;
+  }
+  /** The type of an object resolved by {@link ESLint.loadFormatter}. */
+  interface LoadedFormatter {
+    /**
+     * Used to call the underlying formatter.
+     * @param results An array of lint results to format.
+     * @param resultsMeta An object with an optional `maxWarningsExceeded` property that will be
+     * passed to the underlying formatter function along with other properties set by ESLint.
+     * This argument can be omitted if `maxWarningsExceeded` is not needed.
+     * @return The formatter output.
+     */
+    format(results: LintResult[], resultsMeta?: ResultsMeta): string | Promise<string>;
+  }
+  // The documented type name is `LoadedFormatter`, but `Formatter` has been historically more used.
+  type Formatter = LoadedFormatter;
+  /**
+   * The expected signature of a custom formatter.
+   * @param results An array of lint results to format.
+   * @param context Additional information for the formatter.
+   * @return The formatter output.
+   */
+  type FormatterFunction = (results: LintResult[], context: LintResultData) => string | Promise<string>;
+  // Docs reference the types by those name
+  type EditInfo = Rule.Fix;
+}
+//#endregion
+export { AST, ESLint, JSSyntaxElement, Linter, Rule, Scope, SourceCode };
+//# sourceMappingURL=index.d.mts.map