@oxlint/migrate 1.50.0 → 1.51.0

package/dist/src/index.d.mts

@@ -1,2671 +1,102 @@
-//#region node_modules/.pnpm/@types+estree@1.0.8/node_modules/@types/estree/index.d.ts
-// This definition file follows a somewhat unusual format. ESTree allows
-// runtime type checks based on the `type` parameter. In order to explain this
-// to typescript we want to use discriminated union types:
-// https://github.com/Microsoft/TypeScript/pull/9163
-//
-// For ESTree this is a bit tricky because the high level interfaces like
-// Node or Function are pulling double duty. We want to pass common fields down
-// to the interfaces that extend them (like Identifier or
-// ArrowFunctionExpression), but you can't extend a type union or enforce
-// common fields on them. So we've split the high level interfaces into two
-// types, a base type which passes down inherited fields, and a type union of
-// all types which extend the base type. Only the type union is exported, and
-// the union is how other types refer to the collection of inheriting types.
-//
-// This makes the definitions file here somewhat more difficult to maintain,
-// but it has the notable advantage of making ESTree much easier to use as
-// an end user.
-interface BaseNodeWithoutComments {
-  // Every leaf interface that extends BaseNode must specify a type property.
-  // The type property should be a string literal. For example, Identifier
-  // has: `type: "Identifier"`
-  type: string;
-  loc?: SourceLocation$2 | null | undefined;
-  range?: [number, number] | undefined;
-}
-interface BaseNode extends BaseNodeWithoutComments {
-  leadingComments?: Comment[] | undefined;
-  trailingComments?: Comment[] | undefined;
-}
-interface NodeMap {
-  AssignmentProperty: AssignmentProperty;
-  CatchClause: CatchClause;
-  Class: Class;
-  ClassBody: ClassBody;
-  Expression: Expression;
-  Function: Function;
-  Identifier: Identifier;
-  Literal: Literal;
-  MethodDefinition: MethodDefinition;
-  ModuleDeclaration: ModuleDeclaration;
-  ModuleSpecifier: ModuleSpecifier;
-  Pattern: Pattern;
-  PrivateIdentifier: PrivateIdentifier;
-  Program: Program;
-  Property: Property;
-  PropertyDefinition: PropertyDefinition;
-  SpreadElement: SpreadElement;
-  Statement: Statement;
-  Super: Super;
-  SwitchCase: SwitchCase;
-  TemplateElement: TemplateElement;
-  VariableDeclarator: VariableDeclarator;
-}
-type Node$1 = NodeMap[keyof NodeMap];
-interface Comment extends BaseNodeWithoutComments {
-  type: "Line" | "Block";
-  value: string;
-}
-interface SourceLocation$2 {
-  source?: string | null | undefined;
-  start: Position$1;
-  end: Position$1;
-}
-interface Position$1 {
-  /** >= 1 */
-  line: number;
-  /** >= 0 */
-  column: number;
-}
-interface Program extends BaseNode {
-  type: "Program";
-  sourceType: "script" | "module";
-  body: Array<Directive$1 | Statement | ModuleDeclaration>;
-  comments?: Comment[] | undefined;
-}
-interface Directive$1 extends BaseNode {
-  type: "ExpressionStatement";
-  expression: Literal;
-  directive: string;
-}
-interface BaseFunction extends BaseNode {
-  params: Pattern[];
-  generator?: boolean | undefined;
-  async?: boolean | undefined; // The body is either BlockStatement or Expression because arrow functions
-  // can have a body that's either. FunctionDeclarations and
-  // FunctionExpressions have only BlockStatement bodies.
-  body: BlockStatement | Expression;
-}
-type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
-type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
-interface BaseStatement extends BaseNode {}
-interface EmptyStatement extends BaseStatement {
-  type: "EmptyStatement";
-}
-interface BlockStatement extends BaseStatement {
-  type: "BlockStatement";
-  body: Statement[];
-  innerComments?: Comment[] | undefined;
-}
-interface StaticBlock extends Omit<BlockStatement, "type"> {
-  type: "StaticBlock";
-}
-interface ExpressionStatement extends BaseStatement {
-  type: "ExpressionStatement";
-  expression: Expression;
-}
-interface IfStatement extends BaseStatement {
-  type: "IfStatement";
-  test: Expression;
-  consequent: Statement;
-  alternate?: Statement | null | undefined;
-}
-interface LabeledStatement extends BaseStatement {
-  type: "LabeledStatement";
-  label: Identifier;
-  body: Statement;
-}
-interface BreakStatement extends BaseStatement {
-  type: "BreakStatement";
-  label?: Identifier | null | undefined;
-}
-interface ContinueStatement extends BaseStatement {
-  type: "ContinueStatement";
-  label?: Identifier | null | undefined;
-}
-interface WithStatement extends BaseStatement {
-  type: "WithStatement";
-  object: Expression;
-  body: Statement;
-}
-interface SwitchStatement extends BaseStatement {
-  type: "SwitchStatement";
-  discriminant: Expression;
-  cases: SwitchCase[];
-}
-interface ReturnStatement extends BaseStatement {
-  type: "ReturnStatement";
-  argument?: Expression | null | undefined;
-}
-interface ThrowStatement extends BaseStatement {
-  type: "ThrowStatement";
-  argument: Expression;
-}
-interface TryStatement extends BaseStatement {
-  type: "TryStatement";
-  block: BlockStatement;
-  handler?: CatchClause | null | undefined;
-  finalizer?: BlockStatement | null | undefined;
-}
-interface WhileStatement extends BaseStatement {
-  type: "WhileStatement";
-  test: Expression;
-  body: Statement;
-}
-interface DoWhileStatement extends BaseStatement {
-  type: "DoWhileStatement";
-  body: Statement;
-  test: Expression;
-}
-interface ForStatement extends BaseStatement {
-  type: "ForStatement";
-  init?: VariableDeclaration | Expression | null | undefined;
-  test?: Expression | null | undefined;
-  update?: Expression | null | undefined;
-  body: Statement;
-}
-interface BaseForXStatement extends BaseStatement {
-  left: VariableDeclaration | Pattern;
-  right: Expression;
-  body: Statement;
-}
-interface ForInStatement extends BaseForXStatement {
-  type: "ForInStatement";
-}
-interface DebuggerStatement extends BaseStatement {
-  type: "DebuggerStatement";
-}
-type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
-interface BaseDeclaration extends BaseStatement {}
-interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
-  type: "FunctionDeclaration";
-  /** It is null when a function declaration is a part of the `export default function` statement */
-  id: Identifier | null;
-  body: BlockStatement;
-}
-interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
-  id: Identifier;
-}
-interface VariableDeclaration extends BaseDeclaration {
-  type: "VariableDeclaration";
-  declarations: VariableDeclarator[];
-  kind: "var" | "let" | "const" | "using" | "await using";
-}
-interface VariableDeclarator extends BaseNode {
-  type: "VariableDeclarator";
-  id: Pattern;
-  init?: Expression | null | undefined;
-}
-interface ExpressionMap {
-  ArrayExpression: ArrayExpression;
-  ArrowFunctionExpression: ArrowFunctionExpression;
-  AssignmentExpression: AssignmentExpression;
-  AwaitExpression: AwaitExpression;
-  BinaryExpression: BinaryExpression;
-  CallExpression: CallExpression;
-  ChainExpression: ChainExpression;
-  ClassExpression: ClassExpression;
-  ConditionalExpression: ConditionalExpression;
-  FunctionExpression: FunctionExpression;
-  Identifier: Identifier;
-  ImportExpression: ImportExpression;
-  Literal: Literal;
-  LogicalExpression: LogicalExpression;
-  MemberExpression: MemberExpression;
-  MetaProperty: MetaProperty;
-  NewExpression: NewExpression;
-  ObjectExpression: ObjectExpression;
-  SequenceExpression: SequenceExpression;
-  TaggedTemplateExpression: TaggedTemplateExpression;
-  TemplateLiteral: TemplateLiteral;
-  ThisExpression: ThisExpression;
-  UnaryExpression: UnaryExpression;
-  UpdateExpression: UpdateExpression;
-  YieldExpression: YieldExpression;
-}
-type Expression = ExpressionMap[keyof ExpressionMap];
-interface BaseExpression extends BaseNode {}
-type ChainElement = SimpleCallExpression | MemberExpression;
-interface ChainExpression extends BaseExpression {
-  type: "ChainExpression";
-  expression: ChainElement;
-}
-interface ThisExpression extends BaseExpression {
-  type: "ThisExpression";
-}
-interface ArrayExpression extends BaseExpression {
-  type: "ArrayExpression";
-  elements: Array<Expression | SpreadElement | null>;
-}
-interface ObjectExpression extends BaseExpression {
-  type: "ObjectExpression";
-  properties: Array<Property | SpreadElement>;
-}
-interface PrivateIdentifier extends BaseNode {
-  type: "PrivateIdentifier";
-  name: string;
-}
-interface Property extends BaseNode {
-  type: "Property";
-  key: Expression | PrivateIdentifier;
-  value: Expression | Pattern; // Could be an AssignmentProperty
-  kind: "init" | "get" | "set";
-  method: boolean;
-  shorthand: boolean;
-  computed: boolean;
-}
-interface PropertyDefinition extends BaseNode {
-  type: "PropertyDefinition";
-  key: Expression | PrivateIdentifier;
-  value?: Expression | null | undefined;
-  computed: boolean;
-  static: boolean;
-}
-interface FunctionExpression extends BaseFunction, BaseExpression {
-  id?: Identifier | null | undefined;
-  type: "FunctionExpression";
-  body: BlockStatement;
-}
-interface SequenceExpression extends BaseExpression {
-  type: "SequenceExpression";
-  expressions: Expression[];
-}
-interface UnaryExpression extends BaseExpression {
-  type: "UnaryExpression";
-  operator: UnaryOperator;
-  prefix: true;
-  argument: Expression;
-}
-interface BinaryExpression extends BaseExpression {
-  type: "BinaryExpression";
-  operator: BinaryOperator;
-  left: Expression | PrivateIdentifier;
-  right: Expression;
-}
-interface AssignmentExpression extends BaseExpression {
-  type: "AssignmentExpression";
-  operator: AssignmentOperator;
-  left: Pattern | MemberExpression;
-  right: Expression;
-}
-interface UpdateExpression extends BaseExpression {
-  type: "UpdateExpression";
-  operator: UpdateOperator;
-  argument: Expression;
-  prefix: boolean;
-}
-interface LogicalExpression extends BaseExpression {
-  type: "LogicalExpression";
-  operator: LogicalOperator;
-  left: Expression;
-  right: Expression;
-}
-interface ConditionalExpression extends BaseExpression {
-  type: "ConditionalExpression";
-  test: Expression;
-  alternate: Expression;
-  consequent: Expression;
-}
-interface BaseCallExpression extends BaseExpression {
-  callee: Expression | Super;
-  arguments: Array<Expression | SpreadElement>;
-}
-type CallExpression = SimpleCallExpression | NewExpression;
-interface SimpleCallExpression extends BaseCallExpression {
-  type: "CallExpression";
-  optional: boolean;
-}
-interface NewExpression extends BaseCallExpression {
-  type: "NewExpression";
-}
-interface MemberExpression extends BaseExpression, BasePattern {
-  type: "MemberExpression";
-  object: Expression | Super;
-  property: Expression | PrivateIdentifier;
-  computed: boolean;
-  optional: boolean;
-}
-type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
-interface BasePattern extends BaseNode {}
-interface SwitchCase extends BaseNode {
-  type: "SwitchCase";
-  test?: Expression | null | undefined;
-  consequent: Statement[];
-}
-interface CatchClause extends BaseNode {
-  type: "CatchClause";
-  param: Pattern | null;
-  body: BlockStatement;
-}
-interface Identifier extends BaseNode, BaseExpression, BasePattern {
-  type: "Identifier";
-  name: string;
-}
-type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
-interface SimpleLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value: string | boolean | number | null;
-  raw?: string | undefined;
-}
-interface RegExpLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: RegExp | null | undefined;
-  regex: {
-    pattern: string;
-    flags: string;
-  };
-  raw?: string | undefined;
-}
-interface BigIntLiteral extends BaseNode, BaseExpression {
-  type: "Literal";
-  value?: bigint | null | undefined;
-  bigint: string;
-  raw?: string | undefined;
-}
-type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
-type LogicalOperator = "||" | "&&" | "??";
-type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
-type UpdateOperator = "++" | "--";
-interface ForOfStatement extends BaseForXStatement {
-  type: "ForOfStatement";
-  await: boolean;
-}
-interface Super extends BaseNode {
-  type: "Super";
-}
-interface SpreadElement extends BaseNode {
-  type: "SpreadElement";
-  argument: Expression;
-}
-interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
-  type: "ArrowFunctionExpression";
-  expression: boolean;
-  body: BlockStatement | Expression;
-}
-interface YieldExpression extends BaseExpression {
-  type: "YieldExpression";
-  argument?: Expression | null | undefined;
-  delegate: boolean;
-}
-interface TemplateLiteral extends BaseExpression {
-  type: "TemplateLiteral";
-  quasis: TemplateElement[];
-  expressions: Expression[];
-}
-interface TaggedTemplateExpression extends BaseExpression {
-  type: "TaggedTemplateExpression";
-  tag: Expression;
-  quasi: TemplateLiteral;
-}
-interface TemplateElement extends BaseNode {
-  type: "TemplateElement";
-  tail: boolean;
-  value: {
-    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */cooked?: string | null | undefined;
-    raw: string;
-  };
-}
-interface AssignmentProperty extends Property {
-  value: Pattern;
-  kind: "init";
-  method: boolean; // false
-}
-interface ObjectPattern extends BasePattern {
-  type: "ObjectPattern";
-  properties: Array<AssignmentProperty | RestElement>;
-}
-interface ArrayPattern extends BasePattern {
-  type: "ArrayPattern";
-  elements: Array<Pattern | null>;
-}
-interface RestElement extends BasePattern {
-  type: "RestElement";
-  argument: Pattern;
-}
-interface AssignmentPattern extends BasePattern {
-  type: "AssignmentPattern";
-  left: Pattern;
-  right: Expression;
-}
-type Class = ClassDeclaration | ClassExpression;
-interface BaseClass extends BaseNode {
-  superClass?: Expression | null | undefined;
-  body: ClassBody;
-}
-interface ClassBody extends BaseNode {
-  type: "ClassBody";
-  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
-}
-interface MethodDefinition extends BaseNode {
-  type: "MethodDefinition";
-  key: Expression | PrivateIdentifier;
-  value: FunctionExpression;
-  kind: "constructor" | "method" | "get" | "set";
-  computed: boolean;
-  static: boolean;
-}
-interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
-  type: "ClassDeclaration";
-  /** It is null when a class declaration is a part of the `export default class` statement */
-  id: Identifier | null;
-}
-interface ClassDeclaration extends MaybeNamedClassDeclaration {
-  id: Identifier;
-}
-interface ClassExpression extends BaseClass, BaseExpression {
-  type: "ClassExpression";
-  id?: Identifier | null | undefined;
-}
-interface MetaProperty extends BaseExpression {
-  type: "MetaProperty";
-  meta: Identifier;
-  property: Identifier;
-}
-type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
-interface BaseModuleDeclaration extends BaseNode {}
-type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
-interface BaseModuleSpecifier extends BaseNode {
-  local: Identifier;
-}
-interface ImportDeclaration extends BaseModuleDeclaration {
-  type: "ImportDeclaration";
-  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
-  attributes: ImportAttribute[];
-  source: Literal;
-}
-interface ImportSpecifier extends BaseModuleSpecifier {
-  type: "ImportSpecifier";
-  imported: Identifier | Literal;
-}
-interface ImportAttribute extends BaseNode {
-  type: "ImportAttribute";
-  key: Identifier | Literal;
-  value: Literal;
-}
-interface ImportExpression extends BaseExpression {
-  type: "ImportExpression";
-  source: Expression;
-  options?: Expression | null | undefined;
-}
-interface ImportDefaultSpecifier extends BaseModuleSpecifier {
-  type: "ImportDefaultSpecifier";
-}
-interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
-  type: "ImportNamespaceSpecifier";
-}
-interface ExportNamedDeclaration extends BaseModuleDeclaration {
-  type: "ExportNamedDeclaration";
-  declaration?: Declaration | null | undefined;
-  specifiers: ExportSpecifier[];
-  attributes: ImportAttribute[];
-  source?: Literal | null | undefined;
-}
-interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
-  type: "ExportSpecifier";
-  local: Identifier | Literal;
-  exported: Identifier | Literal;
-}
-interface ExportDefaultDeclaration extends BaseModuleDeclaration {
-  type: "ExportDefaultDeclaration";
-  declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
-}
-interface ExportAllDeclaration extends BaseModuleDeclaration {
-  type: "ExportAllDeclaration";
-  exported: Identifier | Literal | null;
-  attributes: ImportAttribute[];
-  source: Literal;
-}
-interface AwaitExpression extends BaseExpression {
-  type: "AwaitExpression";
-  argument: Expression;
-}
-//#endregion
-//#region node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts
-// ==================================================================================================
-// JSON Schema Draft 04
-// ==================================================================================================
-/**
- * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
- */
-type JSONSchema4TypeName = "string" //
-| "number" | "integer" | "boolean" | "object" | "array" | "null" | "any";
-/**
- * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
- */
-type JSONSchema4Type = string //
-| number | boolean | JSONSchema4Object | JSONSchema4Array | null;
-// Workaround for infinite type recursion
-interface JSONSchema4Object {
-  [key: string]: JSONSchema4Type;
-}
-// Workaround for infinite type recursion
-// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
-interface JSONSchema4Array extends Array<JSONSchema4Type> {}
-/**
- * Meta schema
- *
- * Recommended values:
- * - 'http://json-schema.org/schema#'
- * - 'http://json-schema.org/hyper-schema#'
- * - 'http://json-schema.org/draft-04/schema#'
- * - 'http://json-schema.org/draft-04/hyper-schema#'
- * - 'http://json-schema.org/draft-03/schema#'
- * - 'http://json-schema.org/draft-03/hyper-schema#'
- *
- * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
- */
-type JSONSchema4Version = string;
-/**
- * JSON Schema V4
- * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
- */
-interface JSONSchema4 {
-  id?: string | undefined;
-  $ref?: string | undefined;
-  $schema?: JSONSchema4Version | undefined;
-  /**
-   * This attribute is a string that provides a short description of the
-   * instance property.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
-   */
-  title?: string | undefined;
-  /**
-   * This attribute is a string that provides a full description of the of
-   * purpose the instance property.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
-   */
-  description?: string | undefined;
-  default?: JSONSchema4Type | undefined;
-  multipleOf?: number | undefined;
-  maximum?: number | undefined;
-  exclusiveMaximum?: boolean | undefined;
-  minimum?: number | undefined;
-  exclusiveMinimum?: boolean | undefined;
-  maxLength?: number | undefined;
-  minLength?: number | undefined;
-  pattern?: string | undefined;
-  /**
-   * May only be defined when "items" is defined, and is a tuple of JSONSchemas.
-   *
-   * This provides a definition for additional items in an array instance
-   * when tuple definitions of the items is provided.  This can be false
-   * to indicate additional items in the array are not allowed, or it can
-   * be a schema that defines the schema of the additional items.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
-   */
-  additionalItems?: boolean | JSONSchema4 | undefined;
-  /**
-   * This attribute defines the allowed items in an instance array, and
-   * MUST be a schema or an array of schemas.  The default value is an
-   * empty schema which allows any value for items in the instance array.
-   *
-   * When this attribute value is a schema and the instance value is an
-   * array, then all the items in the array MUST be valid according to the
-   * schema.
-   *
-   * When this attribute value is an array of schemas and the instance
-   * value is an array, each position in the instance array MUST conform
-   * to the schema in the corresponding position for this array.  This
-   * called tuple typing.  When tuple typing is used, additional items are
-   * allowed, disallowed, or constrained by the "additionalItems"
-   * (Section 5.6) attribute using the same rules as
-   * "additionalProperties" (Section 5.4) for objects.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
-   */
-  items?: JSONSchema4 | JSONSchema4[] | undefined;
-  maxItems?: number | undefined;
-  minItems?: number | undefined;
-  uniqueItems?: boolean | undefined;
-  maxProperties?: number | undefined;
-  minProperties?: number | undefined;
-  /**
-   * This attribute indicates if the instance must have a value, and not
-   * be undefined. This is false by default, making the instance
-   * optional.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
-   */
-  required?: boolean | string[] | undefined;
-  /**
-   * This attribute defines a schema for all properties that are not
-   * explicitly defined in an object type definition. If specified, the
-   * value MUST be a schema or a boolean. If false is provided, no
-   * additional properties are allowed beyond the properties defined in
-   * the schema. The default value is an empty schema which allows any
-   * value for additional properties.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
-   */
-  additionalProperties?: boolean | JSONSchema4 | undefined;
-  definitions?: {
-    [k: string]: JSONSchema4;
-  } | undefined;
-  /**
-   * This attribute is an object with property definitions that define the
-   * valid values of instance object property values. When the instance
-   * value is an object, the property values of the instance object MUST
-   * conform to the property definitions in this object. In this object,
-   * each property definition's value MUST be a schema, and the property's
-   * name MUST be the name of the instance property that it defines.  The
-   * instance property value MUST be valid according to the schema from
-   * the property definition. Properties are considered unordered, the
-   * order of the instance properties MAY be in any order.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
-   */
-  properties?: {
-    [k: string]: JSONSchema4;
-  } | undefined;
-  /**
-   * This attribute is an object that defines the schema for a set of
-   * property names of an object instance. The name of each property of
-   * this attribute's object is a regular expression pattern in the ECMA
-   * 262/Perl 5 format, while the value is a schema. If the pattern
-   * matches the name of a property on the instance object, the value of
-   * the instance's property MUST be valid against the pattern name's
-   * schema value.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
-   */
-  patternProperties?: {
-    [k: string]: JSONSchema4;
-  } | undefined;
-  dependencies?: {
-    [k: string]: JSONSchema4 | string[];
-  } | undefined;
-  /**
-   * This provides an enumeration of all possible values that are valid
-   * for the instance property. This MUST be an array, and each item in
-   * the array represents a possible value for the instance value. If
-   * this attribute is defined, the instance value MUST be one of the
-   * values in the array in order for the schema to be valid.
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
-   */
-  enum?: JSONSchema4Type[] | undefined;
-  /**
-   * A single type, or a union of simple types
-   */
-  type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;
-  allOf?: JSONSchema4[] | undefined;
-  anyOf?: JSONSchema4[] | undefined;
-  oneOf?: JSONSchema4[] | undefined;
-  not?: JSONSchema4 | undefined;
-  /**
-   * The value of this property MUST be another schema which will provide
-   * a base schema which the current schema will inherit from.  The
-   * inheritance rules are such that any instance that is valid according
-   * to the current schema MUST be valid according to the referenced
-   * schema.  This MAY also be an array, in which case, the instance MUST
-   * be valid for all the schemas in the array.  A schema that extends
-   * another schema MAY define additional attributes, constrain existing
-   * attributes, or add other constraints.
-   *
-   * Conceptually, the behavior of extends can be seen as validating an
-   * instance against all constraints in the extending schema as well as
-   * the extended schema(s).
-   *
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
-   */
-  extends?: string | string[] | undefined;
-  /**
-   * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-5.6
-   */
-  [k: string]: any;
-  format?: string | undefined;
-}
-//#endregion
-//#region node_modules/.pnpm/@eslint+core@0.17.0/node_modules/@eslint/core/dist/esm/types.d.ts
-/**
- * Represents an error inside of a file.
- */
-interface FileError {
-  message: string;
-  line: number;
-  column: number;
-  endLine?: number;
-  endColumn?: number;
-}
-/**
- * Represents a problem found in a file.
- */
-interface FileProblem {
-  ruleId: string | null;
-  message: string;
-  loc: SourceLocation$1;
-}
-/**
- * Represents the start and end coordinates of a node inside the source.
- */
-interface SourceLocation$1 {
-  start: Position;
-  end: Position;
-}
-/**
- * Represents a location coordinate inside the source. ESLint-style formats
- * have just `line` and `column` while others may have `offset` as well.
- */
-interface Position {
-  line: number;
-  column: number;
-}
-/**
- * Represents a range of characters in the source.
- */
-type SourceRange = [number, number];
-/**
- * What the rule is responsible for finding:
- * - `problem` means the rule has noticed a potential error.
- * - `suggestion` means the rule suggests an alternate or better approach.
- * - `layout` means the rule is looking at spacing, indentation, etc.
- */
-type RuleType = "problem" | "suggestion" | "layout";
-/**
- * The type of fix the rule can provide:
- * - `code` means the rule can fix syntax.
- * - `whitespace` means the rule can fix spacing and indentation.
- */
-type RuleFixType = "code" | "whitespace";
-/**
- * An object containing visitor information for a rule. Each method is either the
- * name of a node type or a selector, or is a method that will be called at specific
- * times during the traversal.
- */
-type RuleVisitor = Record<string, ((...args: any[]) => void) | undefined>;
-/**
- * Rule meta information used for documentation.
- */
-interface RulesMetaDocs {
-  /**
-   * A short description of the rule.
-   */
-  description?: string | undefined;
-  /**
-   * The URL to the documentation for the rule.
-   */
-  url?: string | undefined;
-  /**
-   * The category the rule falls under.
-   * @deprecated No longer used.
-   */
-  category?: string | undefined;
-  /**
-   * Indicates if the rule is generally recommended for all users.
-   *
-   * Note - this will always be a boolean for core rules, but may be used in any way by plugins.
-   */
-  recommended?: unknown;
-  /**
-   * Indicates if the rule is frozen (no longer accepting feature requests).
-   */
-  frozen?: boolean | undefined;
-}
-/**
- * Meta information about a rule.
- */
-interface RulesMeta<MessageIds extends string = string, RuleOptions = unknown[], ExtRuleDocs = unknown> {
-  /**
-   * Properties that are used when documenting the rule.
-   */
-  docs?: (RulesMetaDocs & ExtRuleDocs) | undefined;
-  /**
-   * The type of rule.
-   */
-  type?: RuleType | undefined;
-  /**
-   * The schema for the rule options. Required if the rule has options.
-   */
-  schema?: JSONSchema4 | JSONSchema4[] | false | undefined;
-  /**
-   * Any default options to be recursively merged on top of any user-provided options.
-   */
-  defaultOptions?: RuleOptions;
-  /**
-   * The messages that the rule can report.
-   */
-  messages?: Record<MessageIds, string>;
-  /**
-   * Indicates whether the rule has been deprecated or provides additional metadata about the deprecation. Omit if not deprecated.
-   */
-  deprecated?: boolean | DeprecatedInfo | undefined;
-  /**
-   * @deprecated Use deprecated.replacedBy instead.
-   * The name of the rule(s) this rule was replaced by, if it was deprecated.
-   */
-  replacedBy?: readonly string[] | undefined;
-  /**
-   * Indicates if the rule is fixable, and if so, what type of fix it provides.
-   */
-  fixable?: RuleFixType | undefined;
-  /**
-   * Indicates if the rule may provide suggestions.
-   */
-  hasSuggestions?: boolean | undefined;
-  /**
-   * The language the rule is intended to lint.
-   */
-  language?: string;
-  /**
-   * The dialects of `language` that the rule is intended to lint.
-   */
-  dialects?: string[];
-}
-/**
- * Provides additional metadata about a deprecation.
- */
-interface DeprecatedInfo {
-  /**
-   * General message presented to the user, e.g. for the key rule why the rule
-   * is deprecated or for info how to replace the rule.
-   */
-  message?: string;
-  /**
-   * URL to more information about this deprecation in general.
-   */
-  url?: string;
-  /**
-   * An empty array explicitly states that there is no replacement.
-   */
-  replacedBy?: ReplacedByInfo[];
-  /**
-   * The package version since when the rule is deprecated (should use full
-   * semver without a leading "v").
-   */
-  deprecatedSince?: string;
-  /**
-   * The estimated version when the rule is removed (probably the next major
-   * version). null means the rule is "frozen" (will be available but will not
-   * be changed).
-   */
-  availableUntil?: string | null;
-}
-/**
- * Provides metadata about a replacement
- */
-interface ReplacedByInfo {
-  /**
-   * General message presented to the user, e.g. how to replace the rule
-   */
-  message?: string;
-  /**
-   * URL to more information about this replacement in general
-   */
-  url?: string;
-  /**
-   * Name should be "eslint" if the replacement is an ESLint core rule. Omit
-   * the property if the replacement is in the same plugin.
-   */
-  plugin?: ExternalSpecifier;
-  /**
-   * Name and documentation of the replacement rule
-   */
-  rule?: ExternalSpecifier;
-}
-/**
- * Specifies the name and url of an external resource. At least one property
- * should be set.
- */
-interface ExternalSpecifier {
-  /**
-   * Name of the referenced plugin / rule.
-   */
-  name?: string;
-  /**
-   * URL pointing to documentation for the plugin / rule.
-   */
-  url?: string;
-}
-/**
- * Generic type for `RuleContext`.
- */
-interface RuleContextTypeOptions {
-  LangOptions: LanguageOptions;
-  Code: SourceCode$1;
-  RuleOptions: unknown[];
-  Node: unknown;
-  MessageIds: string;
-}
-/**
- * Represents the context object that is passed to a rule. This object contains
- * information about the current state of the linting process and is the rule's
- * view into the outside world.
- */
-interface RuleContext$1<Options extends RuleContextTypeOptions = RuleContextTypeOptions> {
-  /**
-   * The current working directory for the session.
-   */
-  cwd: string;
-  /**
-   * Returns the current working directory for the session.
-   * @deprecated Use `cwd` instead.
-   */
-  getCwd(): string;
-  /**
-   * The filename of the file being linted.
-   */
-  filename: string;
-  /**
-   * Returns the filename of the file being linted.
-   * @deprecated Use `filename` instead.
-   */
-  getFilename(): string;
-  /**
-   * The physical filename of the file being linted.
-   */
-  physicalFilename: string;
-  /**
-   * Returns the physical filename of the file being linted.
-   * @deprecated Use `physicalFilename` instead.
-   */
-  getPhysicalFilename(): string;
-  /**
-   * The source code object that the rule is running on.
-   */
-  sourceCode: Options["Code"];
-  /**
-   * Returns the source code object that the rule is running on.
-   * @deprecated Use `sourceCode` instead.
-   */
-  getSourceCode(): Options["Code"];
-  /**
-   * Shared settings for the configuration.
-   */
-  settings: SettingsConfig;
-  /**
-   * Parser-specific options for the configuration.
-   * @deprecated Use `languageOptions.parserOptions` instead.
-   */
-  parserOptions: Record<string, unknown>;
-  /**
-   * The language options for the configuration.
-   */
-  languageOptions: Options["LangOptions"];
-  /**
-   * The CommonJS path to the parser used while parsing this file.
-   * @deprecated No longer used.
-   */
-  parserPath: string | undefined;
-  /**
-   * The rule ID.
-   */
-  id: string;
-  /**
-   * The rule's configured options.
-   */
-  options: Options["RuleOptions"];
-  /**
-   * The report function that the rule should use to report problems.
-   * @param violation The violation to report.
-   */
-  report(violation: ViolationReport<Options["Node"], Options["MessageIds"]>): void;
-}
-/**
- * Manager of text edits for a rule fix.
- */
-interface RuleTextEditor<EditableSyntaxElement = unknown> {
-  /**
-   * Inserts text after the specified node or token.
-   * @param syntaxElement The node or token to insert after.
-   * @param text The edit to insert after the node or token.
-   */
-  insertTextAfter(syntaxElement: EditableSyntaxElement, text: string): RuleTextEdit;
-  /**
-   * Inserts text after the specified range.
-   * @param range The range to insert after.
-   * @param text The edit to insert after the range.
-   */
-  insertTextAfterRange(range: SourceRange, text: string): RuleTextEdit;
-  /**
-   * Inserts text before the specified node or token.
-   * @param syntaxElement A syntax element with location information to insert before.
-   * @param text The edit to insert before the node or token.
-   */
-  insertTextBefore(syntaxElement: EditableSyntaxElement, text: string): RuleTextEdit;
-  /**
-   * Inserts text before the specified range.
-   * @param range The range to insert before.
-   * @param text The edit to insert before the range.
-   */
-  insertTextBeforeRange(range: SourceRange, text: string): RuleTextEdit;
-  /**
-   * Removes the specified node or token.
-   * @param syntaxElement A syntax element with location information to remove.
-   * @returns The edit to remove the node or token.
-   */
-  remove(syntaxElement: EditableSyntaxElement): RuleTextEdit;
-  /**
-   * Removes the specified range.
-   * @param range The range to remove.
-   * @returns The edit to remove the range.
-   */
-  removeRange(range: SourceRange): RuleTextEdit;
-  /**
-   * Replaces the specified node or token with the given text.
-   * @param syntaxElement A syntax element with location information to replace.
-   * @param text The text to replace the node or token with.
-   * @returns The edit to replace the node or token.
-   */
-  replaceText(syntaxElement: EditableSyntaxElement, text: string): RuleTextEdit;
-  /**
-   * Replaces the specified range with the given text.
-   * @param range The range to replace.
-   * @param text The text to replace the range with.
-   * @returns The edit to replace the range.
-   */
-  replaceTextRange(range: SourceRange, text: string): RuleTextEdit;
-}
-/**
- * Represents a fix for a rule violation implemented as a text edit.
- */
-interface RuleTextEdit {
-  /**
-   * The range to replace.
-   */
-  range: SourceRange;
-  /**
-   * The text to insert.
-   */
-  text: string;
-}
-/**
- * Fixes a violation.
- * @param fixer The text editor to apply the fix.
- * @returns The fix(es) for the violation.
- */
-type RuleFixer = (fixer: RuleTextEditor) => RuleTextEdit | Iterable<RuleTextEdit> | null;
-interface ViolationReportBase {
-  /**
-   * The data to insert into the message.
-   */
-  data?: Record<string, unknown> | undefined;
-  /**
-   * The fix to be applied for the violation.
-   */
-  fix?: RuleFixer | null | undefined;
-  /**
-   * An array of suggested fixes for the problem. These fixes may change the
-   * behavior of the code, so they are not applied automatically.
-   */
-  suggest?: SuggestedEdit[] | null | undefined;
-}
-type ViolationMessage<MessageIds = string> = {
-  message: string;
-} | {
-  messageId: MessageIds;
-};
-type ViolationLocation<Node> = {
-  loc: SourceLocation$1 | Position;
-} | {
-  node: Node;
-};
-type ViolationReport<Node = unknown, MessageIds = string> = ViolationReportBase & ViolationMessage<MessageIds> & ViolationLocation<Node>;
-interface SuggestedEditBase {
-  /**
-   * The data to insert into the message.
-   */
-  data?: Record<string, unknown> | undefined;
-  /**
-   * The fix to be applied for the suggestion.
-   */
-  fix: RuleFixer;
-}
-type SuggestionMessage = {
-  desc: string;
-} | {
-  messageId: string;
-};
-/**
- * A suggested edit for a rule violation.
- */
-type SuggestedEdit = SuggestedEditBase & SuggestionMessage;
-/**
- * The normalized version of a lint suggestion.
- */
-interface LintSuggestion {
-  /** A short description. */
-  desc: string;
-  /** Fix result info. */
-  fix: RuleTextEdit;
-  /** Id referencing a message for the description. */
-  messageId?: string | undefined;
-}
-/**
- * The normalized version of a lint violation message.
- */
-interface LintMessage$1 {
-  /** The 1-based column number. */
-  column: number;
-  /** The 1-based line number. */
-  line: number;
-  /** The 1-based column number of the end location. */
-  endColumn?: number | undefined;
-  /** The 1-based line number of the end location. */
-  endLine?: number | undefined;
-  /** The ID of the rule which makes this message. */
-  ruleId: string | null;
-  /** The reported message. */
-  message: string;
-  /** The ID of the message in the rule's meta. */
-  messageId?: string | undefined;
-  /**
-   * Type of node.
-   * @deprecated `nodeType` is deprecated and will be removed in the next major version.
-   */
-  nodeType?: string | undefined;
-  /** If `true` then this is a fatal error. */
-  fatal?: true | undefined;
-  /** The severity of this message. */
-  severity: Exclude<SeverityLevel, 0>;
-  /** Information for autofix. */
-  fix?: RuleTextEdit | undefined;
-  /** Information for suggestions. */
-  suggestions?: LintSuggestion[] | undefined;
-}
-/**
- * Generic options for the `RuleDefinition` type.
- */
-interface RuleDefinitionTypeOptions {
-  LangOptions: LanguageOptions;
-  Code: SourceCode$1;
-  RuleOptions: unknown[];
-  Visitor: RuleVisitor;
-  Node: unknown;
-  MessageIds: string;
-  ExtRuleDocs: unknown;
-}
-/**
- * The definition of an ESLint rule.
- */
-interface RuleDefinition<Options extends RuleDefinitionTypeOptions = RuleDefinitionTypeOptions> {
-  /**
-   * The meta information for the rule.
-   */
-  meta?: RulesMeta<Options["MessageIds"], Options["RuleOptions"], Options["ExtRuleDocs"]>;
-  /**
-   * Creates the visitor that ESLint uses to apply the rule during traversal.
-   * @param context The rule context.
-   * @returns The rule visitor.
-   */
-  create(context: RuleContext$1<{
-    LangOptions: Options["LangOptions"];
-    Code: Options["Code"];
-    RuleOptions: Options["RuleOptions"];
-    Node: Options["Node"];
-    MessageIds: Options["MessageIds"];
-  }>): Options["Visitor"];
-}
-/**
- * The human readable severity level used in a configuration.
- */
-type SeverityName = "off" | "warn" | "error";
-/**
- * The numeric severity level for a rule.
- *
- * - `0` means off.
- * - `1` means warn.
- * - `2` means error.
- */
-type SeverityLevel = 0 | 1 | 2;
-/**
- * The severity of a rule in a configuration.
- */
-type Severity = SeverityName | SeverityLevel;
-/**
- * Represents the metadata for an object, such as a plugin or processor.
- */
-interface ObjectMetaProperties {
-  /** @deprecated Use `meta.name` instead. */
-  name?: string | undefined;
-  /** @deprecated Use `meta.version` instead. */
-  version?: string | undefined;
-  meta?: {
-    name?: string | undefined;
-    version?: string | undefined;
-  };
-}
-/**
- * Represents the configuration options for the core linter.
- */
-interface LinterOptionsConfig {
-  /**
-   * Indicates whether or not inline configuration is evaluated.
-   */
-  noInlineConfig?: boolean;
-  /**
-   * Indicates what to do when an unused disable directive is found.
-   */
-  reportUnusedDisableDirectives?: boolean | Severity;
-  /**
-   * A severity value indicating if and how unused inline configs should be
-   * tracked and reported.
-   */
-  reportUnusedInlineConfigs?: Severity;
-}
-/**
- * The configuration for a rule.
- */
-type RuleConfig<RuleOptions extends unknown[] = unknown[]> = Severity | [Severity, ...Partial<RuleOptions>];
-/**
- * A collection of rules and their configurations.
- */
-interface RulesConfig {
-  [key: string]: RuleConfig;
-}
-/**
- * A collection of settings.
- */
-interface SettingsConfig {
-  [key: string]: unknown;
-}
-/**
- * The configuration for a set of files.
- */
-interface ConfigObject<Rules extends RulesConfig = RulesConfig> {
-  /**
-   * A string to identify the configuration object. Used in error messages and
-   * inspection tools.
-   */
-  name?: string;
-  /**
-   * Path to the directory where the configuration object should apply.
-   * `files` and `ignores` patterns in the configuration object are
-   * interpreted as relative to this path.
-   */
-  basePath?: string;
-  /**
-   * An array of glob patterns indicating the files that the configuration
-   * object should apply to. If not specified, the configuration object applies
-   * to all files
-   */
-  files?: (string | string[])[];
-  /**
-   * An array of glob patterns indicating the files that the configuration
-   * object should not apply to. If not specified, the configuration object
-   * applies to all files matched by files
-   */
-  ignores?: string[];
-  /**
-   * The name of the language used for linting. This is used to determine the
-   * parser and other language-specific settings.
-   * @since 9.7.0
-   */
-  language?: string;
-  /**
-   * An object containing settings related to how the language is configured for
-   * linting.
-   */
-  languageOptions?: LanguageOptions;
-  /**
-   * An object containing settings related to the linting process
-   */
-  linterOptions?: LinterOptionsConfig;
-  /**
-   * Either an object containing preprocess() and postprocess() methods or a
-   * string indicating the name of a processor inside of a plugin
-   * (i.e., "pluginName/processorName").
-   */
-  processor?: string | Processor;
-  /**
-   * An object containing a name-value mapping of plugin names to plugin objects.
-   * When files is specified, these plugins are only available to the matching files.
-   */
-  plugins?: Record<string, Plugin$1>;
-  /**
-   * An object containing the configured rules. When files or ignores are specified,
-   * these rule configurations are only available to the matching files.
-   */
-  rules?: Partial<Rules>;
-  /**
-   * An object containing name-value pairs of information that should be
-   * available to all rules.
-   */
-  settings?: Record<string, unknown>;
-}
-/** @deprecated Only supported in legacy eslintrc config format. */
-type GlobalAccess = boolean | "off" | "readable" | "readonly" | "writable" | "writeable";
-/** @deprecated Only supported in legacy eslintrc config format. */
-interface GlobalsConfig {
-  [name: string]: GlobalAccess;
-}
-/**
- * The ECMAScript version of the code being linted.
- * @deprecated Only supported in legacy eslintrc config format.
- */
-type EcmaVersion$1 = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | "latest";
-/**
- * The type of JavaScript source code.
- * @deprecated Only supported in legacy eslintrc config format.
- */
-type JavaScriptSourceType = "script" | "module" | "commonjs";
-/**
- * Parser options.
- * @deprecated Only supported in legacy eslintrc config format.
- * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options#specifying-parser-options)
- */
-interface JavaScriptParserOptionsConfig {
-  /**
-   * Allow the use of reserved words as identifiers (if `ecmaVersion` is 3).
-   *
-   * @default false
-   */
-  allowReserved?: boolean | undefined;
-  /**
-   * Accepts any valid ECMAScript version number or `'latest'`:
-   *
-   * - A version: es3, es5, es6, es7, es8, es9, es10, es11, es12, es13, es14, ..., or
-   * - A year: es2015, es2016, es2017, es2018, es2019, es2020, es2021, es2022, es2023, ..., or
-   * - `'latest'`
-   *
-   * When it's a version or a year, the value must be a number - so do not include the `es` prefix.
-   *
-   * Specifies the version of ECMAScript syntax you want to use. This is used by the parser to determine how to perform scope analysis, and it affects the default
-   *
-   * @default 5
-   */
-  ecmaVersion?: EcmaVersion$1 | 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 'script'
-   *
-   * @see https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options
-   */
-  sourceType?: JavaScriptSourceType | undefined;
-  /**
-   * An object indicating which additional language features you'd like to use.
-   *
-   * @see https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options
-   */
-  ecmaFeatures?: {
-    globalReturn?: boolean | undefined;
-    impliedStrict?: boolean | undefined;
-    jsx?: boolean | undefined;
-    experimentalObjectRestSpread?: boolean | undefined;
-    [key: string]: any;
-  } | undefined;
-  [key: string]: any;
-}
-/** @deprecated Only supported in legacy eslintrc config format. */
-interface EnvironmentConfig {
-  /** The definition of global variables. */
-  globals?: GlobalsConfig | undefined;
-  /** The parser options that will be enabled under this environment. */
-  parserOptions?: JavaScriptParserOptionsConfig | undefined;
-}
-/**
- * A configuration object that may have a `rules` block.
- */
-interface HasRules<Rules extends RulesConfig = RulesConfig> {
-  rules?: Partial<Rules> | undefined;
-}
-/**
- * ESLint legacy configuration.
- *
- * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
- */
-interface BaseConfig<Rules extends RulesConfig = RulesConfig, OverrideRules extends RulesConfig = Rules> extends HasRules<Rules> {
-  $schema?: string | undefined;
-  /**
-   * An environment provides predefined global variables.
-   *
-   * @see [Environments](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-environments)
-   */
-  env?: {
-    [name: string]: boolean;
-  } | undefined;
-  /**
-   * Extending configuration files.
-   *
-   * @see [Extends](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#extending-configuration-files)
-   */
-  extends?: string | string[] | undefined;
-  /**
-   * Specifying globals.
-   *
-   * @see [Globals](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-globals)
-   */
-  globals?: GlobalsConfig | undefined;
-  /**
-   * Disable processing of inline comments.
-   *
-   * @see [Disabling Inline Comments](https://eslint.org/docs/latest/use/configure/rules-deprecated#disabling-inline-comments)
-   */
-  noInlineConfig?: boolean | undefined;
-  /**
-   * Overrides can be used to use a differing configuration for matching sub-directories and files.
-   *
-   * @see [How do overrides work](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#how-do-overrides-work)
-   */
-  overrides?: ConfigOverride<OverrideRules>[] | undefined;
-  /**
-   * Parser.
-   *
-   * @see [Working with Custom Parsers](https://eslint.org/docs/latest/extend/custom-parsers)
-   * @see [Specifying Parser](https://eslint.org/docs/latest/use/configure/parser-deprecated)
-   */
-  parser?: string | undefined;
-  /**
-   * Parser options.
-   *
-   * @see [Working with Custom Parsers](https://eslint.org/docs/latest/extend/custom-parsers)
-   * @see [Specifying Parser Options](https://eslint.org/docs/latest/use/configure/language-options-deprecated#specifying-parser-options)
-   */
-  parserOptions?: JavaScriptParserOptionsConfig | undefined;
-  /**
-   * Which third-party plugins define additional rules, environments, configs, etc. for ESLint to use.
-   *
-   * @see [Configuring Plugins](https://eslint.org/docs/latest/use/configure/plugins-deprecated#configure-plugins)
-   */
-  plugins?: string[] | undefined;
-  /**
-   * Specifying processor.
-   *
-   * @see [processor](https://eslint.org/docs/latest/use/configure/plugins-deprecated#specify-a-processor)
-   */
-  processor?: string | undefined;
-  /**
-   * Report unused eslint-disable comments as warning.
-   *
-   * @see [Report unused eslint-disable comments](https://eslint.org/docs/latest/use/configure/rules-deprecated#report-unused-eslint-disable-comments)
-   */
-  reportUnusedDisableDirectives?: boolean | undefined;
-  /**
-   * Settings.
-   *
-   * @see [Settings](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#adding-shared-settings)
-   */
-  settings?: SettingsConfig | undefined;
-}
-/**
- * The overwrites that apply more differing configuration to specific files or directories.
- */
-interface ConfigOverride<Rules extends RulesConfig = RulesConfig> extends BaseConfig<Rules> {
-  /**
-   * The glob patterns for excluded files.
-   */
-  excludedFiles?: string | string[] | undefined;
-  /**
-   * The glob patterns for target files.
-   */
-  files: string | string[];
-}
+//#region src/types.d.ts
 /**
- * ESLint legacy configuration.
+ * ESLint type definitions compatible with ESLint 9 and 10.
+ * Based on @eslint/core types to avoid direct eslint dependency.
  *
- * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
- */
-interface LegacyConfigObject<Rules extends RulesConfig = RulesConfig, OverrideRules extends RulesConfig = Rules> extends BaseConfig<Rules, OverrideRules> {
-  /**
-   * Tell ESLint to ignore specific files and directories.
-   *
-   * @see [Ignore Patterns](https://eslint.org/docs/latest/use/configure/ignore-deprecated#ignorepatterns-in-config-files)
-   */
-  ignorePatterns?: string | string[] | undefined;
-  /**
-   * @see [Using Configuration Files](https://eslint.org/docs/latest/use/configure/configuration-files-deprecated#using-configuration-files)
-   */
-  root?: boolean | undefined;
-}
-/**
- * File information passed to a processor.
- */
-interface ProcessorFile$1 {
-  text: string;
-  filename: string;
-}
-/**
- * A processor is an object that can preprocess and postprocess files.
- */
-interface Processor<T extends string | ProcessorFile$1 = string | ProcessorFile$1> extends ObjectMetaProperties {
-  /** If `true` then it means the processor supports autofix. */
-  supportsAutofix?: boolean | undefined;
-  /** The function to extract code blocks. */
-  preprocess?(text: string, filename: string): T[];
-  /** The function to merge messages. */
-  postprocess?(messages: LintMessage$1[][], filename: string): LintMessage$1[];
-}
-interface Plugin$1 extends ObjectMetaProperties {
-  meta?: ObjectMetaProperties["meta"] & {
-    namespace?: string | undefined;
-  };
-  configs?: Record<string, LegacyConfigObject | ConfigObject | ConfigObject[]> | undefined;
-  environments?: Record<string, EnvironmentConfig> | undefined;
-  languages?: Record<string, Language> | undefined;
-  processors?: Record<string, Processor> | undefined;
-  rules?: Record<string, RuleDefinition> | undefined;
-}
-/**
- * Generic options for the `Language` type.
- */
-interface LanguageTypeOptions {
-  LangOptions: LanguageOptions;
-  Code: SourceCode$1;
-  RootNode: unknown;
-  Node: unknown;
-}
-/**
- * Represents a plugin language.
- */
-interface Language<Options extends LanguageTypeOptions = {
-  LangOptions: LanguageOptions;
-  Code: SourceCode$1;
-  RootNode: unknown;
-  Node: unknown;
-}> {
-  /**
-   * Indicates how ESLint should read the file.
-   */
-  fileType: "text";
-  /**
-   * First line number returned from the parser (text mode only).
-   */
-  lineStart: 0 | 1;
-  /**
-   * First column number returned from the parser (text mode only).
-   */
-  columnStart: 0 | 1;
-  /**
-   * The property to read the node type from. Used in selector querying.
-   */
-  nodeTypeKey: string;
-  /**
-   * The traversal path that tools should take when evaluating the AST
-   */
-  visitorKeys?: Record<string, string[]>;
-  /**
-   * Default language options. User-defined options are merged with this object.
-   */
-  defaultLanguageOptions?: LanguageOptions;
-  /**
-   * Validates languageOptions for this language.
-   */
-  validateLanguageOptions(languageOptions: Options["LangOptions"]): void;
-  /**
-   * Normalizes languageOptions for this language.
-   */
-  normalizeLanguageOptions?(languageOptions: Options["LangOptions"]): Options["LangOptions"];
-  /**
-   * Helper for esquery that allows languages to match nodes against
-   * class. esquery currently has classes like `function` that will
-   * match all the various function nodes. This method allows languages
-   * to implement similar shorthands.
-   */
-  matchesSelectorClass?(className: string, node: Options["Node"], ancestry: Options["Node"][]): boolean;
-  /**
-   * Parses the given file input into its component parts. This file should not
-   * throws errors for parsing errors but rather should return any parsing
-   * errors as parse of the ParseResult object.
-   */
-  parse(file: File, context: LanguageContext<Options["LangOptions"]>): ParseResult<Options["RootNode"]>;
-  /**
-   * Creates SourceCode object that ESLint uses to work with a file.
-   */
-  createSourceCode(file: File, input: OkParseResult<Options["RootNode"]>, context: LanguageContext<Options["LangOptions"]>): Options["Code"];
-}
-/**
- * Plugin-defined options for the language.
- */
-type LanguageOptions = Record<string, unknown>;
-/**
- * The context object that is passed to the language plugin methods.
- */
-interface LanguageContext<LangOptions = LanguageOptions> {
-  languageOptions: LangOptions;
-}
-/**
- * Represents a file read by ESLint.
- */
-interface File {
-  /**
-   * The path that ESLint uses for this file. May be a virtual path
-   * if it was returned by a processor.
-   */
-  path: string;
-  /**
-   * The path to the file on disk. This always maps directly to a file
-   * regardless of whether it was returned from a processor.
-   */
-  physicalPath: string;
-  /**
-   * Indicates if the original source contained a byte-order marker.
-   * ESLint strips the BOM from the `body`, but this info is needed
-   * to correctly apply autofixing.
-   */
-  bom: boolean;
-  /**
-   * The body of the file to parse.
-   */
-  body: string | Uint8Array;
-}
-/**
- * Represents the successful result of parsing a file.
- */
-interface OkParseResult<RootNode = unknown> {
-  /**
-   * Indicates if the parse was successful. If true, the parse was successful
-   * and ESLint should continue on to create a SourceCode object and run rules;
-   * if false, ESLint should just report the error(s) without doing anything
-   * else.
-   */
-  ok: true;
-  /**
-   * The abstract syntax tree created by the parser. (only when ok: true)
-   */
-  ast: RootNode;
-  /**
-   * Any additional data that the parser wants to provide.
-   */
-  [key: string]: any;
-}
-/**
- * Represents the unsuccessful result of parsing a file.
- */
-interface NotOkParseResult {
-  /**
-   * Indicates if the parse was successful. If true, the parse was successful
-   * and ESLint should continue on to create a SourceCode object and run rules;
-   * if false, ESLint should just report the error(s) without doing anything
-   * else.
-   */
-  ok: false;
-  /**
-   * Any parsing errors, whether fatal or not. (only when ok: false)
-   */
-  errors: FileError[];
-  /**
-   * Any additional data that the parser wants to provide.
-   */
-  [key: string]: any;
-}
-type ParseResult<RootNode = unknown> = OkParseResult<RootNode> | NotOkParseResult;
-/**
- * Represents inline configuration found in the source code.
- */
-interface InlineConfigElement {
-  /**
-   * The location of the inline config element.
-   */
-  loc: SourceLocation$1;
-  /**
-   * The interpreted configuration from the inline config element.
-   */
-  config: {
-    rules: RulesConfig;
-  };
-}
-/**
- * Generic options for the `SourceCodeBase` type.
- */
-interface SourceCodeBaseTypeOptions {
-  LangOptions: LanguageOptions;
-  RootNode: unknown;
-  SyntaxElementWithLoc: unknown;
-  ConfigNode: unknown;
-}
-/**
- * Represents the basic interface for a source code object.
- */
-interface SourceCodeBase<Options extends SourceCodeBaseTypeOptions = {
-  LangOptions: LanguageOptions;
-  RootNode: unknown;
-  SyntaxElementWithLoc: unknown;
-  ConfigNode: unknown;
-}> {
-  /**
-   * Root of the AST.
-   */
-  ast: Options["RootNode"];
-  /**
-   * The traversal path that tools should take when evaluating the AST.
-   * When present, this overrides the `visitorKeys` on the language for
-   * just this source code object.
-   */
-  visitorKeys?: Record<string, string[]>;
-  /**
-   * Retrieves the equivalent of `loc` for a given node or token.
-   * @param syntaxElement The node or token to get the location for.
-   * @returns The location of the node or token.
-   */
-  getLoc(syntaxElement: Options["SyntaxElementWithLoc"]): SourceLocation$1;
-  /**
-   * Retrieves the equivalent of `range` for a given node or token.
-   * @param syntaxElement The node or token to get the range for.
-   * @returns The range of the node or token.
-   */
-  getRange(syntaxElement: Options["SyntaxElementWithLoc"]): SourceRange;
-  /**
-   * Traversal of AST.
-   */
-  traverse(): Iterable<TraversalStep>;
-  /**
-   * Applies language options passed in from the ESLint core.
-   */
-  applyLanguageOptions?(languageOptions: Options["LangOptions"]): void;
-  /**
-   * Return all of the inline areas where ESLint should be disabled/enabled
-   * along with any problems found in evaluating the directives.
-   */
-  getDisableDirectives?(): {
-    directives: Directive[];
-    problems: FileProblem[];
-  };
-  /**
-   * Returns an array of all inline configuration nodes found in the
-   * source code.
-   */
-  getInlineConfigNodes?(): Options["ConfigNode"][];
-  /**
-   * Applies configuration found inside of the source code. This method is only
-   * called when ESLint is running with inline configuration allowed.
-   */
-  applyInlineConfig?(): {
-    configs: InlineConfigElement[];
-    problems: FileProblem[];
-  };
-  /**
-   * Called by ESLint core to indicate that it has finished providing
-   * information. We now add in all the missing variables and ensure that
-   * state-changing methods cannot be called by rules.
-   * @returns {void}
-   */
-  finalize?(): void;
-}
-/**
- * Represents the source of a text file being linted.
- */
-interface TextSourceCode<Options extends SourceCodeBaseTypeOptions = {
-  LangOptions: LanguageOptions;
-  RootNode: unknown;
-  SyntaxElementWithLoc: unknown;
-  ConfigNode: unknown;
-}> extends SourceCodeBase<Options> {
-  /**
-   * The body of the file that you'd like rule developers to access.
-   */
-  text: string;
-}
-/**
- * Represents the source of a binary file being linted.
- */
-interface BinarySourceCode<Options extends SourceCodeBaseTypeOptions = {
-  LangOptions: LanguageOptions;
-  RootNode: unknown;
-  SyntaxElementWithLoc: unknown;
-  ConfigNode: unknown;
-}> extends SourceCodeBase<Options> {
-  /**
-   * The body of the file that you'd like rule developers to access.
-   */
-  body: Uint8Array;
-}
-type SourceCode$1<Options extends SourceCodeBaseTypeOptions = {
-  LangOptions: LanguageOptions;
-  RootNode: unknown;
-  SyntaxElementWithLoc: unknown;
-  ConfigNode: unknown;
-}> = TextSourceCode<Options> | BinarySourceCode<Options>;
-/**
- * Represents a traversal step visiting the AST.
- */
-interface VisitTraversalStep {
-  kind: 1;
-  target: unknown;
-  phase: 1 | 2;
-  args: unknown[];
-}
-/**
- * Represents a traversal step calling a function.
- */
-interface CallTraversalStep {
-  kind: 2;
-  target: string;
-  phase?: string;
-  args: unknown[];
-}
-type TraversalStep = VisitTraversalStep | CallTraversalStep;
-/**
- * The type of disable directive. This determines how ESLint will disable rules.
- */
-type DirectiveType = "disable" | "enable" | "disable-line" | "disable-next-line";
-/**
- * Represents a disable directive.
+ * This namespace contains type definitions that mirror ESLint's Linter types,
+ * allowing the codebase to be independent of the eslint package while maintaining
+ * compatibility with both ESLint 9 and 10.
  */
-interface Directive {
-  /**
-   * The type of directive.
-   */
-  type: DirectiveType;
-  /**
-   * The node of the directive. May be in the AST or a comment/token.
-   */
-  node: unknown;
-  /**
-   * The value of the directive.
-   */
-  value: string;
-  /**
-   * The justification for the directive.
-   */
-  justification?: string;
-}
-//#endregion
-//#region node_modules/.pnpm/eslint@9.39.2_jiti@2.6.1/node_modules/eslint/lib/types/index.d.ts
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-/** Adds matching `:exit` selectors for all properties of a `RuleVisitor`. */
-type WithExit<RuleVisitorType extends RuleVisitor> = { [Key in keyof RuleVisitorType as Key | `${Key & string}:exit`]: RuleVisitorType[Key] }; //------------------------------------------------------------------------------
-// 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$1;
-    end: Position$1;
-  }
-  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$2;
-  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$1;
-  getIndexFromLoc(location: Position$1): 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$2 | 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 WithExit<{ [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 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 {
+declare namespace ESLint {
   /**
-   * 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)
+   * Represents the severity level for a rule as a number.
+   * - `0` means off
+   * - `1` means warn
+   * - `2` means error
    */
-  type Severity = SeverityLevel;
+  type SeverityLevel = 0 | 1 | 2;
   /**
-   * The human readable severity level for a rule.
-   *
-   * @see [Rule Severities](https://eslint.org/docs/latest/use/configure/rules#rule-severities)
+   * Represents the severity level for a rule as a string.
    */
-  type StringSeverity = SeverityName;
+  type SeverityName = 'off' | 'warn' | 'error';
   /**
    * 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>];
+  type Severity = SeverityName | SeverityLevel;
   /**
-   * 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)
+   * The configuration for a rule.
+   * Can be a severity level or an array with severity and options.
    */
-  type RuleEntry<Options extends any[] = any[]> = RuleConfig<Options>;
+  type RuleConfig<RuleOptions extends unknown[] = unknown[]> = Severity | [Severity, ...Partial<RuleOptions>];
   /**
-   * The rules config object is a key/value map of rule names and their severity and options.
+   * A collection of rules and their configurations.
    */
-  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;
+  interface RulesRecord {
+    [key: string]: RuleConfig;
+  }
   /**
-   * Options used for linting code with `Linter#verify` and `Linter#verifyAndFix`.
+   * Global variable access configuration.
    */
-  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;
+  type GlobalAccess = boolean | 'off' | 'readable' | 'readonly' | 'writable' | 'writeable';
   /**
-   * Performance statistics.
+   * Configuration for global variables.
    */
-  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 GlobalsConfig {
+    [name: string]: GlobalAccess;
   }
-  interface TimePass {
-    /**
-     * The parse object containing all parse time information.
-     */
-    parse: {
-      total: number;
+  interface Plugin {
+    meta?: {
+      name?: string;
     };
-    /**
-     * 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;
+    configs?: Record<string, unknown[]> | undefined;
+    environments?: Record<string, unknown> | undefined;
+    languages?: Record<string, unknown> | undefined;
+    processors?: Record<string, unknown> | undefined;
+    rules?: RulesRecord | undefined;
+  }
+  /**
+   * ESLint flat configuration object compatible with ESLint 9 and 10.
+   * Uses index signature to allow additional properties from various ESLint configurations.
+   */
+  interface Config<Rules extends RulesRecord = RulesRecord> {
+    /** A string to identify the configuration object */
+    name?: string;
+    /** Path to the directory where the configuration should apply */
+    basePath?: string;
+    /** Glob patterns indicating files this config applies to */
+    files?: (string | string[])[];
+    /** Glob patterns indicating files this config doesn't apply to */
+    ignores?: string[];
+    /** Language options including globals, parser, etc */
+    languageOptions?: {
+      /** Global variables */globals?: GlobalsConfig; /** Parser options */
+      parserOptions?: Record<string, unknown>;
+      [key: string]: unknown;
     };
-    /**
-     * 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;
+    /** Linter options */
+    linterOptions?: {
+      noInlineConfig?: boolean;
+      reportUnusedDisableDirectives?: boolean | Severity;
+      [key: string]: unknown;
     };
+    /** Processor name or object */
+    processor?: string | object;
+    /** Plugin configurations */
+    plugins?: Record<string, Plugin>;
+    /** Rule configurations */
+    rules?: Partial<Rules>;
+    /** Settings available to all rules */
+    settings?: Record<string, unknown>;
+    /** Legacy env configuration */
+    env?: Record<string, boolean>;
+    /** Legacy globals configuration (for backwards compatibility) */
+    globals?: GlobalsConfig;
+    /** Legacy overrides configuration */
+    overrides?: unknown[];
+    /** Index signature to accept any additional properties */
+    [key: string]: any;
   }
-  /**
-   * 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
-//#region src/types.d.ts
 type OxlintConfigPlugins = string[];
 type OxlintConfigJsPlugins = string[];
 type OxlintConfigCategories = Partial<Record<Category, unknown>>;
@@ -2673,26 +104,31 @@ type OxlintConfigEnv = Record<string, boolean>;
 type OxlintConfigIgnorePatterns = string[];
 type OxlintSupportedSettingsKey = 'jsx-a11y' | 'next' | 'react' | 'jsdoc' | 'vitest';
 type OxlintSettings = { [K in OxlintSupportedSettingsKey]?: Record<string, unknown> } & Record<string, Record<string, unknown> | undefined>;
+type OxlintOptions = {
+  typeAware?: boolean;
+  typeCheck?: boolean;
+};
 type OxlintConfigOverride = {
   files: string[];
   env?: OxlintConfigEnv;
-  globals?: Linter.Globals;
+  globals?: ESLint.GlobalsConfig;
   plugins?: OxlintConfigPlugins;
   jsPlugins?: OxlintConfigJsPlugins;
   categories?: OxlintConfigCategories;
-  rules?: Partial<Linter.RulesRecord>;
+  rules?: Partial<ESLint.RulesRecord>;
 };
 type OxlintConfig = {
   $schema?: string;
   env?: OxlintConfigEnv;
-  globals?: Linter.Globals;
+  globals?: ESLint.GlobalsConfig;
   plugins?: OxlintConfigPlugins;
   jsPlugins?: OxlintConfigJsPlugins;
   categories?: OxlintConfigCategories;
-  rules?: Partial<Linter.RulesRecord>;
+  rules?: Partial<ESLint.RulesRecord>;
   overrides?: OxlintConfigOverride[];
   ignorePatterns?: OxlintConfigIgnorePatterns;
   settings?: OxlintSettings;
+  options?: OxlintOptions;
 };
 type RuleSkippedCategory = 'nursery' | 'type-aware' | 'not-implemented' | 'unsupported' | 'js-plugins';
 type SkippedCategoryGroup = Record<RuleSkippedCategory, string[]>;
@@ -2713,6 +149,6 @@ type Options = {
 type Category = 'style' | 'correctness' | 'nursery' | 'suspicious' | 'pedantic' | 'perf' | 'restriction';
 //#endregion
 //#region src/index.d.ts
-declare const main: (configs: Linter.Config | Linter.Config[] | Promise<Linter.Config> | Promise<Linter.Config[]>, oxlintConfig?: OxlintConfig, options?: Options) => Promise<OxlintConfig>;
+declare const main: (configs: ESLint.Config | ESLint.Config[] | Promise<ESLint.Config> | Promise<ESLint.Config[]>, oxlintConfig?: OxlintConfig, options?: Options) => Promise<OxlintConfig>;
 //#endregion
 export { main as default };