@lobehub/ui 5.57.2 → 6.0.0-beta.1

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

@@ -0,0 +1,869 @@
+import { ArrowFunctionExpression, AssignmentExpression, BaseNode, CatchClause, ClassDeclaration, ClassExpression, Comment, Expression, ForInStatement, ForOfStatement, FunctionDeclaration, FunctionExpression, Identifier, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, Node as Node$1, Position, Program, SourceLocation as SourceLocation$1, VariableDeclaration, VariableDeclarator, index_d_exports } 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, 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, RulesConfig, RulesMeta, Severity, SeverityLevel, SeverityName, SourceRange, SuggestedEdit, SuggestedEditBase, SuggestionMessage, TextSourceCode, TraversalStep, ViolationLocation, ViolationMessage, ViolationReport, ViolationReportBase } from "../../../../../@eslint_core@1.2.1/node_modules/@eslint/core/dist/esm/types.mjs";
+import { CustomRuleVisitorWithExit } from "../../../../../@eslint_plugin-kit@0.7.3/node_modules/@eslint/plugin-kit/dist/cjs/index.mjs";
+//#region node_modules/.pnpm/eslint@10.12.0_jiti@2.6.1_supports-color@10.2.2/node_modules/eslint/lib/types/index.d.ts
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+export 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 = SourceRange;
+  interface Program extends Program {
+    comments: Comment[];
+    tokens: Token[];
+    loc: SourceLocation;
+    range: Range;
+  }
+}
+interface JSXIdentifier extends BaseNode {
+  type: "JSXIdentifier";
+  name: string;
+}
+export declare namespace Scope {
+  interface ScopeManager {
+    scopes: Scope[];
+    globalScope: Scope | null;
+    acquire(node: Node$1, inner?: boolean): Scope | null;
+    getDeclaredVariables(node: Node$1): Variable[];
+    addGlobals(names: ReadonlyArray<string>): void;
+  }
+  interface Scope {
+    type: "block" | "catch" | "class" | "class-field-initializer" | "class-static-block" | "for" | "function" | "function-expression-name" | "global" | "module" | "switch" | "with";
+    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 | JSXIdentifier;
+    from: Scope;
+    resolved: Variable | null;
+    writeExpr?: Expression | 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: "Variable";
+    node: VariableDeclarator;
+    parent: VariableDeclaration;
+  };
+  type Definition = DefinitionType & {
+    name: Identifier;
+  };
+}
+// #region SourceCode
+export declare class SourceCode implements TextSourceCode<{
+  LangOptions: Linter.LanguageOptions;
+  RootNode: AST.Program;
+  SyntaxElementWithLoc: AST.Token | Node$1 | Comment;
+  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 | Comment): SourceLocation$1;
+  getRange(syntaxElement: AST.Token | Node$1 | Comment): SourceRange;
+  getText(node?: Node$1 | AST.Token | Comment, beforeCount?: number, afterCount?: number): string;
+  getLines(): string[];
+  getAllComments(): Comment[];
+  getAncestors(node: Node$1): Node$1[];
+  getDeclaredVariables(node: Node$1): Scope.Variable[];
+  getNodeByRangeIndex(index: number): Node$1 | null;
+  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;
+  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>;
+}
+export 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
+export type JSSyntaxElement = {
+  type: string;
+  loc?: SourceLocation$1 | null | undefined;
+};
+export 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 CustomRuleVisitorWithExit<{ [Node in Rule.Node as Node["type"]]?: ((node: Node) => void) | undefined; } & {
+    // A `Program` visitor's node type has no `parent` property.
+    Program?: ((node: AST.Program) => 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 CodePathSegmentTraversalController {
+    skip(): void;
+    break(): void;
+  }
+  type CodePathSegmentTraversalCallback = (this: CodePath, segment: CodePathSegment, controller: CodePathSegmentTraversalController) => void;
+  interface CodePathTraversalOptions {
+    first?: CodePathSegment | undefined;
+    last?: CodePathSegment | undefined;
+  }
+  interface CodePath {
+    id: string;
+    origin: CodePathOrigin;
+    initialSegment: CodePathSegment;
+    finalSegments: CodePathSegment[];
+    returnedSegments: CodePathSegment[];
+    thrownSegments: CodePathSegment[];
+    upper: CodePath | null;
+    childCodePaths: CodePath[];
+    traverseSegments(callback: CodePathSegmentTraversalCallback): void;
+    traverseSegments(options: CodePathTraversalOptions, callback: CodePathSegmentTraversalCallback): void;
+  }
+  interface CodePathSegment {
+    id: string;
+    nextSegments: CodePathSegment[];
+    prevSegments: CodePathSegment[];
+    allNextSegments: CodePathSegment[];
+    allPrevSegments: 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 = Omit<ViolationReportBase, "suggest">;
+  type SuggestionReportOptions = SuggestedEditBase;
+  type SuggestionDescriptorMessage = SuggestionMessage;
+  type SuggestionReportDescriptor = SuggestedEdit;
+  // redundant with ReportDescriptorOptionsBase but kept for clarity
+  type ReportDescriptorOptions = ViolationReportBase;
+  type ReportDescriptor = ViolationReport<JSSyntaxElement>;
+  type ReportDescriptorMessage = ViolationMessage;
+  type ReportDescriptorLocation = ViolationLocation<JSSyntaxElement>;
+  type RuleFixer = RuleTextEditor<Node$1 | AST.Token>;
+  type Fix = RuleTextEdit;
+}
+// #region Linter
+export declare class Linter {
+  static readonly version: string;
+  version: string;
+  constructor(options?: {
+    cwd?: string | undefined;
+    configType?: "flat";
+  });
+  verify(code: SourceCode | string, config: Linter.Config | Linter.Config[], filename?: string): Linter.LintMessage[];
+  verify(code: SourceCode | string, config: Linter.Config | Linter.Config[], options: Linter.LintOptions): Linter.LintMessage[];
+  verifyAndFix(code: string, config: Linter.Config | Linter.Config[], filename?: string): Linter.FixReport;
+  verifyAndFix(code: string, config: Linter.Config | Linter.Config[], options: Linter.FixOptions): Linter.FixReport;
+  getSourceCode(): SourceCode;
+  getTimes(): Linter.Stats["times"];
+  getFixPassCount(): Linter.Stats["fixPasses"];
+}
+export 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)
+   */
+  interface ParserOptions {
+    /**
+     * Allow the use of reserved words as identifiers (if `ecmaVersion` is 3).
+     *
+     * @default false
+     */
+    allowReserved?: boolean | undefined;
+    /**
+     * An object indicating which additional language features you'd like to use.
+     *
+     * @see https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options
+     */
+    ecmaFeatures?: {
+      /**
+       * Allow `return` statements in the global scope.
+       *
+       * @default false
+       */
+      globalReturn?: boolean | undefined;
+      /**
+       * Enable global [strict mode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode) (if `ecmaVersion` is 5 or greater).
+       *
+       * @default false
+       */
+      impliedStrict?: boolean | undefined;
+      /**
+       * Enable [JSX](https://react.github.io/jsx/).
+       *
+       * @default false
+       */
+      jsx?: boolean | undefined;
+      [key: string]: any;
+    } | undefined;
+    [key: string]: any;
+  }
+  /**
+   * 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.
+     * If no parsing was performed, the property is omitted.
+     */
+    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
+export 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>;
+}
+export 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";
+  /** The options with which to configure the ESLint instance. */
+  interface Options {
+    // File enumeration
+    /** The value to use for the current working directory. */
+    cwd?: string | undefined;
+    /** If `false` then `ESLint#lintFiles()` doesn't throw even if no target files found. Defaults to `true`. */
+    errorOnUnmatchedPattern?: boolean | undefined;
+    /**
+     * Set to false to skip glob resolution of input file paths to lint (default: true).
+     * If false, each input file path is assumed to be a non-glob path to an existing file.
+     */
+    globInputPaths?: boolean | undefined;
+    /** False disables all ignore patterns except for the default ones. */
+    ignore?: boolean | undefined;
+    /** Ignore file patterns to use in addition to config ignores. These patterns are relative to `cwd`. */
+    ignorePatterns?: string[] | null | undefined;
+    /** When set to true, missing patterns cause the linting operation to short circuit and not report any failures. */
+    passOnNoPatterns?: boolean | undefined;
+    /** Show warnings when the file list includes ignored files. */
+    warnIgnored?: boolean | undefined;
+    // Linting
+    /** Enable or disable inline configuration comments. */
+    allowInlineConfig?: boolean | undefined;
+    /** Base config, extended by all configs used with this instance. */
+    baseConfig?: Linter.Config | Linter.Config[] | null | undefined;
+    /** Override config, overrides all configs used with this instance. */
+    overrideConfig?: Linter.Config | Linter.Config[] | null | undefined;
+    /**
+     * Searches for default config file when falsy; doesn't do any config file lookup when `true`; considered to be a config filename when a string.
+     */
+    overrideConfigFile?: string | true | null | undefined;
+    /** An array of plugin implementations. */
+    plugins?: Record<string, Plugin> | null | undefined;
+    /**
+     * Default is `() => true`. A predicate function that filters rules to be run.
+     * This function is called with an object containing `ruleId` and `severity`, and returns `true` if the rule should be run.
+     */
+    ruleFilter?: ((arg: {
+      ruleId: string;
+      severity: Exclude<Linter.Severity, 0>;
+    }) => boolean) | undefined;
+    /** True enables added statistics on lint results. */
+    stats?: boolean | undefined;
+    // Autofix
+    /** Execute in autofix mode. If a function, should return a boolean. */
+    fix?: boolean | ((message: Linter.LintMessage) => boolean) | undefined;
+    /** Array of rule types to apply fixes for. */
+    fixTypes?: FixType[] | null | undefined;
+    // Cache-related
+    /** Enable result caching. */
+    cache?: boolean | undefined;
+    /** The cache file to use instead of .eslintcache. */
+    cacheLocation?: string | undefined;
+    /** The strategy used to detect changed files. */
+    cacheStrategy?: CacheStrategy | undefined;
+    /** If true, apply suppressions automatically. Defaults to false. */
+    applySuppressions?: boolean | undefined;
+    /** Path to suppressions file. Relative to cwd. Defaults to eslint-suppressions.json in cwd. */
+    suppressionsLocation?: string | undefined;
+    // Other Options
+    /** Maximum number of linting threads, "auto" to choose automatically, "off" for no multithreading. */
+    concurrency?: number | "auto" | "off" | undefined;
+    /** Array of feature flags to enable. */
+    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 extends ResultsMeta {
+    cwd: string;
+    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 {
+    /**
+     * Whether or not to use color in the formatter output.
+     * - If `--color` was set, this property is `true`.
+     * - If `--no-color` was set, it is `false`.
+     * - If neither option was provided, the property is omitted.
+     */
+    color?: boolean | undefined;
+    /**
+     * 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 optional `color` and `maxWarningsExceeded` properties that will be
+     * passed to the underlying formatter function along with other properties set by ESLint.
+     * This argument can be omitted if `color` and `maxWarningsExceeded` are 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
+//# sourceMappingURL=index.d.mts.map