eslint-cli-bundle 2.0.0 → 3.0.0

package/dist/types/plugin-kit.d.ts

@@ -0,0 +1,1732 @@
+//#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;
+}
+declare namespace types_d_exports$1 {
+  export { BaseConfig, BinarySourceCode, CallTraversalStep$1 as CallTraversalStep, ConfigObject, ConfigOverride, CustomRuleDefinitionType$2 as CustomRuleDefinitionType, CustomRuleTypeDefinitions$2 as CustomRuleTypeDefinitions, DeprecatedInfo, Directive$1 as Directive, DirectiveType$1 as DirectiveType, EcmaVersion, EnvironmentConfig, ExternalSpecifier, File, FileError, FileProblem, GlobalAccess, GlobalsConfig, HasRules, JavaScriptParserOptionsConfig, JavaScriptSourceType, Language, LanguageContext, LanguageOptions, LanguageTypeOptions, LegacyConfigObject, LintMessage, LintSuggestion, LinterOptionsConfig, MessagePlaceholderData, NotOkParseResult, ObjectMetaProperties, OkParseResult, ParseResult, Plugin, Position, PositionWithOffset, Processor, ProcessorFile, ReplacedByInfo, RuleConfig$1 as RuleConfig, RuleContext, RuleContextTypeOptions, RuleDefinition, RuleDefinitionTypeOptions, RuleFixType, RuleFixer, RuleTextEdit, RuleTextEditor, RuleType, RuleVisitor$1 as RuleVisitor, RulesConfig$1 as RulesConfig, RulesMeta, RulesMetaDocs, SettingsConfig, Severity, SeverityLevel, SeverityName, SourceCode, SourceCodeBaseTypeOptions$1 as SourceCodeBaseTypeOptions, SourceLocation$1 as SourceLocation, SourceLocationWithOffset$1 as SourceLocationWithOffset, SourceRange$1 as SourceRange, SuggestedEdit, SuggestedEditBase, SuggestionMessage, TextSourceCode$1 as TextSourceCode, TraversalStep$1 as TraversalStep, ViolationLocation, ViolationMessage, ViolationReport, ViolationReportBase, VisitTraversalStep$1 as VisitTraversalStep };
+}
+/**
+ * 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 the start and end coordinates of a node inside the source with an offset.
+ */
+interface SourceLocationWithOffset$1 {
+  start: PositionWithOffset;
+  end: PositionWithOffset;
+}
+/**
+ * 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 location coordinate inside the source with an offset.
+ */
+interface PositionWithOffset extends Position {
+  offset: number;
+}
+/**
+ * Represents a range of characters in the source.
+ */
+type SourceRange$1 = [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$1 = 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;
+  /**
+   * 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;
+  /**
+   * The dialects of the languages that the rule is intended to lint.
+   * @example
+   * ["JavaScript", "TypeScript"]
+   */
+  dialects?: string[] | 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.
+   * @deprecated Use `languages` instead.
+   */
+  language?: string;
+  /**
+   * The dialects of `language` that the rule is intended to lint.
+   * @deprecated Use `docs.dialects` instead.
+   */
+  dialects?: string[];
+  /**
+   * Languages supported by this rule in the format `"plugin/language"`.
+   * Use `"*"` for any language or `"plugin/*"` for any language from a specific plugin.
+   * @example
+   * ["js/js", "markdown/gfm", "json/jsonc", "css/css"]
+   */
+  languages?: string[] | undefined;
+}
+/**
+ * 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;
+  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<Options extends RuleContextTypeOptions = RuleContextTypeOptions> {
+  /**
+   * The current working directory for the session.
+   */
+  cwd: string;
+  /**
+   * The filename of the file being linted.
+   */
+  filename: string;
+  /**
+   * The physical filename of the file being linted.
+   */
+  physicalFilename: string;
+  /**
+   * The source code object that the rule is running on.
+   */
+  sourceCode: Options["Code"];
+  /**
+   * Shared settings for the configuration.
+   */
+  settings: SettingsConfig;
+  /**
+   * The language options for the configuration.
+   */
+  languageOptions: Options["LangOptions"];
+  /**
+   * 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$1, 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$1, 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$1): 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$1, text: string): RuleTextEdit;
+}
+/**
+ * Represents a fix for a rule violation implemented as a text edit.
+ */
+interface RuleTextEdit {
+  /**
+   * The range to replace.
+   */
+  range: SourceRange$1;
+  /**
+   * 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;
+/**
+ * Data that can be used to fill placeholders in error messages.
+ */
+type MessagePlaceholderData = Record<string, string | number | boolean | bigint | null | undefined>;
+interface ViolationReportBase<MessageIds extends string = string> {
+  /**
+   * The data to insert into the message.
+   */
+  data?: MessagePlaceholderData | 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<MessageIds>[] | null | undefined;
+}
+type ViolationMessage<MessageIds extends string = string> = {
+  message: string;
+} | {
+  messageId: MessageIds;
+};
+type ViolationLocation<Node> = {
+  loc: SourceLocation$1 | Position;
+} | {
+  node: Node;
+};
+type ViolationReport<Node = unknown, MessageIds extends string = string> = ViolationReportBase<MessageIds> & ViolationMessage<MessageIds> & ViolationLocation<Node>;
+interface SuggestedEditBase {
+  /**
+   * The data to insert into the message.
+   */
+  data?: MessagePlaceholderData | undefined;
+  /**
+   * The fix to be applied for the suggestion.
+   */
+  fix: RuleFixer;
+}
+type SuggestionMessage<MessageIds extends string = string> = {
+  desc: string;
+} | {
+  messageId: MessageIds;
+};
+/**
+ * A suggested edit for a rule violation.
+ */
+type SuggestedEdit<MessageIds extends string = string> = SuggestedEditBase & SuggestionMessage<MessageIds>;
+/**
+ * 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 {
+  /** 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;
+  /** 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;
+  RuleOptions: unknown[];
+  Visitor: RuleVisitor$1;
+  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<{
+    LangOptions: Options["LangOptions"];
+    Code: Options["Code"];
+    RuleOptions: Options["RuleOptions"];
+    Node: Options["Node"];
+    MessageIds: Options["MessageIds"];
+  }>): Options["Visitor"];
+}
+/**
+ * Defaults for non-language-related `RuleDefinition` options.
+ * @deprecated Use the same type from `@eslint/plugin-kit` instead.
+ */
+interface CustomRuleTypeDefinitions$2 {
+  RuleOptions: unknown[];
+  MessageIds: string;
+  ExtRuleDocs: Record<string, unknown>;
+}
+/**
+ * A helper type to define language specific specializations of the `RuleDefinition` type.
+ * @deprecated Use the same type from `@eslint/plugin-kit` instead.
+ *
+ * @example
+ * ```ts
+ * type YourRuleDefinition<
+ * 	Options extends Partial<CustomRuleTypeDefinitions> = {},
+ * > = CustomRuleDefinitionType<
+ * 	{
+ * 		LangOptions: YourLanguageOptions;
+ * 		Code: YourSourceCode;
+ * 		Visitor: YourRuleVisitor;
+ * 		Node: YourNode;
+ * 	},
+ * 	Options
+ * >;
+ * ```
+ */
+type CustomRuleDefinitionType$2<LanguageSpecificOptions extends Omit<RuleDefinitionTypeOptions, keyof CustomRuleTypeDefinitions$2>, Options extends Partial<CustomRuleTypeDefinitions$2>> = RuleDefinition<LanguageSpecificOptions & Required<Options & Omit<CustomRuleTypeDefinitions$2, keyof Options>>>;
+/**
+ * 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$1<RuleOptions extends unknown[] = unknown[]> = Severity | [Severity, ...Partial<RuleOptions>];
+/**
+ * A collection of rules and their configurations.
+ */
+interface RulesConfig$1 {
+  [key: string]: RuleConfig$1;
+}
+/**
+ * A collection of settings.
+ */
+interface SettingsConfig {
+  [key: string]: unknown;
+}
+/**
+ * The configuration for a set of files.
+ */
+interface ConfigObject<Rules extends RulesConfig$1 = RulesConfig$1> {
+  /**
+   * 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>;
+  /**
+   * 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?: SettingsConfig;
+}
+/** @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 = 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 | 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;
+    [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$1 = RulesConfig$1> {
+  rules?: Partial<Rules> | undefined;
+}
+/**
+ * ESLint legacy configuration.
+ *
+ * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
+ */
+interface BaseConfig<Rules extends RulesConfig$1 = RulesConfig$1, OverrideRules extends RulesConfig$1 = 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$1 = RulesConfig$1> extends BaseConfig<Rules> {
+  /**
+   * The glob patterns for excluded files.
+   */
+  excludedFiles?: string | string[] | undefined;
+  /**
+   * The glob patterns for target files.
+   */
+  files: string | string[];
+}
+/**
+ * ESLint legacy configuration.
+ *
+ * @see [ESLint Legacy Configuration](https://eslint.org/docs/latest/use/configure/)
+ */
+interface LegacyConfigObject<Rules extends RulesConfig$1 = RulesConfig$1, OverrideRules extends RulesConfig$1 = 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 {
+  text: string;
+  filename: string;
+}
+/**
+ * A processor is an object that can preprocess and postprocess files.
+ */
+interface Processor<T extends string | ProcessorFile = string | ProcessorFile> 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[][], filename: string): LintMessage[];
+}
+interface Plugin 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;
+  RootNode: unknown;
+  Node: unknown;
+}
+/**
+ * Represents a plugin language.
+ */
+interface Language<Options extends LanguageTypeOptions = {
+  LangOptions: LanguageOptions;
+  Code: SourceCode;
+  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?: Options["LangOptions"];
+  /**
+   * 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$1;
+  };
+}
+/**
+ * Generic options for the `SourceCodeBase` type.
+ */
+interface SourceCodeBaseTypeOptions$1 {
+  LangOptions: LanguageOptions;
+  RootNode: unknown;
+  SyntaxElementWithLoc: unknown;
+  ConfigNode: unknown;
+}
+/**
+ * Represents the basic interface for a source code object.
+ */
+interface SourceCodeBase<Options extends SourceCodeBaseTypeOptions$1 = {
+  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$1;
+  /**
+   * Traversal of AST.
+   */
+  traverse(): Iterable<TraversalStep$1>;
+  /**
+   * 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$1[];
+    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$1<Options extends SourceCodeBaseTypeOptions$1 = {
+  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$1 = {
+  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<Options extends SourceCodeBaseTypeOptions$1 = {
+  LangOptions: LanguageOptions;
+  RootNode: unknown;
+  SyntaxElementWithLoc: unknown;
+  ConfigNode: unknown;
+}> = TextSourceCode$1<Options> | BinarySourceCode<Options>;
+/**
+ * Represents a traversal step visiting the AST.
+ */
+interface VisitTraversalStep$1 {
+  kind: 1;
+  target: unknown;
+  phase: 1 | 2;
+  args: unknown[];
+}
+/**
+ * Represents a traversal step calling a function.
+ */
+interface CallTraversalStep$1 {
+  kind: 2;
+  target: string;
+  phase?: string;
+  args: unknown[];
+}
+type TraversalStep$1 = VisitTraversalStep$1 | CallTraversalStep$1;
+/**
+ * The type of disable directive. This determines how ESLint will disable rules.
+ */
+type DirectiveType$1 = "disable" | "enable" | "disable-line" | "disable-next-line";
+/**
+ * Represents a disable directive.
+ */
+interface Directive$1 {
+  /**
+   * The type of directive.
+   */
+  type: DirectiveType$1;
+  /**
+   * 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;
+}
+declare namespace types_d_exports {
+  export { BooleanConfig$1 as BooleanConfig, CustomRuleDefinitionType$1 as CustomRuleDefinitionType, CustomRuleTypeDefinitions$1 as CustomRuleTypeDefinitions, CustomRuleVisitorWithExit$1 as CustomRuleVisitorWithExit, StringConfig$1 as StringConfig };
+}
+/**
+ * Defaults for non-language-related `RuleDefinition` options.
+ */
+interface CustomRuleTypeDefinitions$1 {
+  RuleOptions: unknown[];
+  MessageIds: string;
+  ExtRuleDocs: Record<string, unknown>;
+}
+/**
+ * A helper type to define language specific specializations of the `RuleDefinition` type.
+ *
+ * @example
+ * ```ts
+ * type YourRuleDefinition<
+ * 	Options extends Partial<CustomRuleTypeDefinitions> = {},
+ * > = CustomRuleDefinitionType<
+ * 	{
+ * 		LangOptions: YourLanguageOptions;
+ * 		Code: YourSourceCode;
+ * 		Visitor: YourRuleVisitor;
+ * 		Node: YourNode;
+ * 	},
+ * 	Options
+ * >;
+ * ```
+ */
+type CustomRuleDefinitionType$1<LanguageSpecificOptions extends Omit<RuleDefinitionTypeOptions, keyof CustomRuleTypeDefinitions$1>, Options extends Partial<CustomRuleTypeDefinitions$1>> = RuleDefinition<LanguageSpecificOptions & Required<Options & Omit<CustomRuleTypeDefinitions$1, keyof Options>>>;
+/**
+ * Adds matching `:exit` selector properties for each key of a `RuleVisitor`.
+ */
+type CustomRuleVisitorWithExit$1<RuleVisitorType extends RuleVisitor$1> = { [Key in keyof RuleVisitorType as Key | `${Key & string}:exit`]: RuleVisitorType[Key]; };
+/**
+ * A map of names to string values, or `null` when no value is provided.
+ */
+type StringConfig$1 = Record<string, string | null>;
+/**
+ * A map of names to boolean flags.
+ */
+type BooleanConfig$1 = Record<string, boolean>;
+//#endregion
+//#region node_modules/.pnpm/@eslint+plugin-kit@0.7.3/node_modules/@eslint/plugin-kit/dist/cjs/index.d.cts
+type VisitTraversalStep = VisitTraversalStep$1;
+type CallTraversalStep = CallTraversalStep$1;
+type TraversalStep = TraversalStep$1;
+type SourceLocation = SourceLocation$1;
+type SourceLocationWithOffset = SourceLocationWithOffset$1;
+type SourceRange = SourceRange$1;
+type IDirective = Directive$1;
+type DirectiveType = DirectiveType$1;
+type SourceCodeBaseTypeOptions = SourceCodeBaseTypeOptions$1;
+type TextSourceCode<Options extends SourceCodeBaseTypeOptions = SourceCodeBaseTypeOptions$1> = TextSourceCode$1<Options>;
+type RuleVisitor = RuleVisitor$1;
+type CustomRuleVisitorWithExit<RuleVisitorType extends RuleVisitor> = CustomRuleVisitorWithExit$1<RuleVisitorType>;
+type CustomRuleTypeDefinitions = CustomRuleTypeDefinitions$1;
+type CustomRuleDefinitionType<LanguageSpecificOptions extends Omit<RuleDefinitionTypeOptions, keyof CustomRuleTypeDefinitions>, Options extends Partial<CustomRuleTypeDefinitions>> = CustomRuleDefinitionType$1<LanguageSpecificOptions, Options>;
+type RuleConfig = RuleConfig$1;
+type RulesConfig = RulesConfig$1;
+type StringConfig = StringConfig$1;
+type BooleanConfig = BooleanConfig$1;
+/**
+ * A class to represent a step in the traversal process where a
+ * method is called.
+ * @implements {CallTraversalStep}
+ */
+declare class CallMethodStep implements CallTraversalStep {
+  /**
+   * Creates a new instance.
+   * @param {Object} options The options for the step.
+   * @param {string} options.target The target of the step.
+   * @param {Array<any>} options.args The arguments of the step.
+   */
+  constructor({ target, args }: {
+    target: string;
+    args: Array<any>;
+  });
+  /**
+   * The type of the step.
+   * @type {"call"}
+   * @readonly
+   */
+  readonly type: "call";
+  /**
+   * The kind of the step. Represents the same data as the `type` property
+   * but it's a number for performance.
+   * @type {2}
+   * @readonly
+   */
+  readonly kind: 2;
+  /**
+   * The name of the method to call.
+   * @type {string}
+   */
+  target: string;
+  /**
+   * The arguments to pass to the method.
+   * @type {Array<any>}
+   */
+  args: Array<any>;
+}
+/**
+ * Object to parse ESLint configuration comments.
+ */
+declare class ConfigCommentParser {
+  /**
+   * Parses a list of "name:string_value" or/and "name" options divided by comma or
+   * whitespace. Used for "global" comments.
+   * @param {string} string The string to parse.
+   * @returns {StringConfig} Result map object of names and string values, or null values if no value was provided.
+   */
+  parseStringConfig(string: string): StringConfig;
+  /**
+   * Parses a JSON-like config.
+   * @param {string} string The string to parse.
+   * @returns {({ok: true, config: RulesConfig}|{ok: false, error: {message: string}})} Result map object
+   */
+  parseJSONLikeConfig(string: string): ({
+    ok: true;
+    config: RulesConfig;
+  } | {
+    ok: false;
+    error: {
+      message: string;
+    };
+  });
+  /**
+   * Parses a config of values separated by comma.
+   * @param {string} string The string to parse.
+   * @returns {BooleanConfig} Result map of values and true values
+   */
+  parseListConfig(string: string): BooleanConfig;
+  /**
+   * Parses a directive comment into directive text and value.
+   * @param {string} string The string with the directive to be parsed.
+   * @returns {DirectiveComment|undefined} The parsed directive or `undefined` if the directive is invalid.
+   */
+  parseDirective(string: string): DirectiveComment | undefined;
+  #private;
+}
+/**
+ * A class to represent a directive comment.
+ * @implements {IDirective}
+ */
+declare class Directive implements IDirective {
+  /**
+   * Creates a new instance.
+   * @param {Object} options The options for the directive.
+   * @param {"disable"|"enable"|"disable-next-line"|"disable-line"} options.type The type of directive.
+   * @param {unknown} options.node The node representing the directive.
+   * @param {string} options.value The value of the directive.
+   * @param {string} options.justification The justification for the directive.
+   */
+  constructor({ type, node, value, justification }: {
+    type: "disable" | "enable" | "disable-next-line" | "disable-line";
+    node: unknown;
+    value: string;
+    justification: string;
+  });
+  /**
+   * The type of directive.
+   * @type {DirectiveType}
+   * @readonly
+   */
+  readonly type: DirectiveType;
+  /**
+   * The node representing the directive.
+   * @type {unknown}
+   * @readonly
+   */
+  readonly node: unknown;
+  /**
+   * Everything after the "eslint-disable" portion of the directive,
+   * but before the "--" that indicates the justification.
+   * @type {string}
+   * @readonly
+   */
+  readonly value: string;
+  /**
+   * The justification for the directive.
+   * @type {string}
+   * @readonly
+   */
+  readonly justification: string;
+}
+/**
+ * Source Code Base Object
+ * @template {SourceCodeBaseTypeOptions & {RootNode: object, SyntaxElementWithLoc: object}} [Options=SourceCodeBaseTypeOptions & {RootNode: object, SyntaxElementWithLoc: object}]
+ * @implements {TextSourceCode<Options>}
+ */
+declare class TextSourceCodeBase<Options extends SourceCodeBaseTypeOptions & {
+  RootNode: object;
+  SyntaxElementWithLoc: object;
+} = SourceCodeBaseTypeOptions$1 & {
+  RootNode: object;
+  SyntaxElementWithLoc: object;
+}> implements TextSourceCode<Options> {
+  /**
+   * Creates a new instance.
+   * @param {Object} options The options for the instance.
+   * @param {string} options.text The source code text.
+   * @param {Options['RootNode']} options.ast The root AST node.
+   * @param {RegExp} [options.lineEndingPattern] The pattern to match lineEndings in the source code. Defaults to `/\r?\n/u`.
+   */
+  constructor({ text, ast, lineEndingPattern }: {
+    text: string;
+    ast: Options["RootNode"];
+    lineEndingPattern?: RegExp;
+  });
+  /**
+   * The AST of the source code.
+   * @type {Options['RootNode']}
+   */
+  ast: Options["RootNode"];
+  /**
+   * The text of the source code.
+   * @type {string}
+   */
+  text: string;
+  /**
+   * Returns the loc information for the given node or token.
+   * @param {Options['SyntaxElementWithLoc']} nodeOrToken The node or token to get the loc information for.
+   * @returns {SourceLocation} The loc information for the node or token.
+   * @throws {Error} If the node or token does not have loc information.
+   */
+  getLoc(nodeOrToken: Options["SyntaxElementWithLoc"]): SourceLocation;
+  /**
+   * Converts a source text index into a `{ line: number, column: number }` pair.
+   * @param {number} index The index of a character in a file.
+   * @throws {TypeError|RangeError} If non-numeric index or index out of range.
+   * @returns {{line: number, column: number}} A `{ line: number, column: number }` location object with 0 or 1-indexed line and 0 or 1-indexed column based on language.
+   * @public
+   */
+  public getLocFromIndex(index: number): {
+    line: number;
+    column: number;
+  };
+  /**
+   * Converts a `{ line: number, column: number }` pair into a source text index.
+   * @param {Object} loc A line/column location.
+   * @param {number} loc.line The line number of the location. (0 or 1-indexed based on language.)
+   * @param {number} loc.column The column number of the location. (0 or 1-indexed based on language.)
+   * @throws {TypeError|RangeError} If `loc` is not an object with a numeric
+   * `line` and `column`, if the `line` is less than or equal to zero or
+   * the `line` or `column` is out of the expected range.
+   * @returns {number} The index of the line/column location in a file.
+   * @public
+   */
+  public getIndexFromLoc(loc: {
+    line: number;
+    column: number;
+  }): number;
+  /**
+   * Returns the range information for the given node or token.
+   * @param {Options['SyntaxElementWithLoc']} nodeOrToken The node or token to get the range information for.
+   * @returns {SourceRange} The range information for the node or token.
+   * @throws {Error} If the node or token does not have range information.
+   */
+  getRange(nodeOrToken: Options["SyntaxElementWithLoc"]): SourceRange;
+  /**
+   * Returns the parent of the given node.
+   * @abstract
+   * @param {Options['SyntaxElementWithLoc']} node The node to get the parent of.
+   * @returns {Options['SyntaxElementWithLoc']|undefined} The parent of the node.
+   * @throws {Error} If the method is not implemented in the subclass.
+   */
+  getParent(node: Options["SyntaxElementWithLoc"]): Options["SyntaxElementWithLoc"] | undefined;
+  /**
+   * Gets all the ancestors of a given node
+   * @param {Options['SyntaxElementWithLoc']} node The node
+   * @returns {Array<Options['SyntaxElementWithLoc']>} All the ancestor nodes in the AST, not including the provided node, starting
+   * from the root node at index 0 and going inwards to the parent node.
+   * @throws {TypeError} When `node` is missing.
+   */
+  getAncestors(node: Options["SyntaxElementWithLoc"]): Array<Options["SyntaxElementWithLoc"]>;
+  /**
+   * Gets the source code for the given node.
+   * @param {Options['SyntaxElementWithLoc']} [node] The AST node to get the text for.
+   * If `node` is omitted or falsy (such as `undefined`, `null`, or an empty string),
+   * the entire source text is returned.
+   * @param {number} [beforeCount] The number of characters before the node to retrieve.
+   * @param {number} [afterCount] The number of characters after the node to retrieve.
+   * @returns {string} The text representing the AST node.
+   * @public
+   */
+  public getText(node?: Options["SyntaxElementWithLoc"], beforeCount?: number, afterCount?: number): string;
+  /**
+   * Gets the entire source text split into an array of lines.
+   * @returns {Array<string>} The source text as an array of lines.
+   * @public
+   */
+  public get lines(): Array<string>;
+  /**
+   * Traverse the source code and return the steps that were taken.
+   * @abstract
+   * @returns {Iterable<TraversalStep>} The steps that were taken while traversing the source code.
+   */
+  traverse(): Iterable<TraversalStep>;
+  #private;
+}
+/**
+ * A class to represent a step in the traversal process where a node is visited.
+ * @implements {VisitTraversalStep}
+ */
+declare class VisitNodeStep implements VisitTraversalStep {
+  /**
+   * Creates a new instance.
+   * @param {Object} options The options for the step.
+   * @param {object} options.target The target of the step.
+   * @param {1|2} options.phase The phase of the step.
+   * @param {Array<any>} options.args The arguments of the step.
+   */
+  constructor({ target, phase, args }: {
+    target: object;
+    phase: 1 | 2;
+    args: Array<any>;
+  });
+  /**
+   * The type of the step.
+   * @type {"visit"}
+   * @readonly
+   */
+  readonly type: "visit";
+  /**
+   * The kind of the step. Represents the same data as the `type` property
+   * but it's a number for performance.
+   * @type {1}
+   * @readonly
+   */
+  readonly kind: 1;
+  /**
+   * The target of the step.
+   * @type {object}
+   */
+  target: object;
+  /**
+   * The phase of the step.
+   * @type {1|2}
+   */
+  phase: 1 | 2;
+  /**
+   * The arguments of the step.
+   * @type {Array<any>}
+   */
+  args: Array<any>;
+}
+/**
+ * Represents a directive comment.
+ */
+declare class DirectiveComment {
+  /**
+   * Creates a new directive comment.
+   * @param {string} label The label of the directive.
+   * @param {string} value The value of the directive.
+   * @param {string} justification The justification of the directive.
+   */
+  constructor(label: string, value: string, justification: string);
+  /**
+   * The label of the directive, such as "eslint", "eslint-disable", etc.
+   * @type {string}
+   */
+  label: string;
+  /**
+   * The value of the directive (the string after the label).
+   * @type {string}
+   */
+  value: string;
+  /**
+   * The justification of the directive (the string after the --).
+   * @type {string}
+   */
+  justification: string;
+}
+//#endregion
+export type { BooleanConfig, CallMethodStep, CallTraversalStep, ConfigCommentParser, CustomRuleDefinitionType, CustomRuleTypeDefinitions, CustomRuleVisitorWithExit, Directive, DirectiveType, IDirective, RuleConfig, RuleVisitor, RulesConfig, SourceCodeBaseTypeOptions, SourceLocation, SourceLocationWithOffset, SourceRange, StringConfig, TextSourceCode, TextSourceCodeBase, TraversalStep, VisitNodeStep, VisitTraversalStep };