eslint-cli-bundle 1.0.4 → 2.0.0

package/dist/types-CXey2reC.d.ts

@@ -0,0 +1,1299 @@
+//#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@1.1.1/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;
+}
+/**
+ * Represents the start and end coordinates of a node inside the source.
+ */
+interface SourceLocation {
+  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;
+  /**
+   * 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;
+  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, 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;
+/**
+ * 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 | 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;
+  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"];
+}
+/**
+ * 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>;
+  /**
+   * 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 = 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[];
+}
+/**
+ * ESLint legacy configuration.
+ *
+ * @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 {
+  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?: 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;
+  /**
+   * 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;
+  /**
+   * 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<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.
+ */
+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
+export { Severity as A, ViolationMessage as B, RuleDefinition as C, RuleVisitor as D, RuleTextEditor as E, SuggestedEditBase as F, ViolationReportBase as H, SuggestionMessage as I, TextSourceCode as L, SeverityName as M, SourceRange as N, RulesConfig as O, SuggestedEdit as P, TraversalStep as R, RuleContext as S, RuleTextEdit as T, ViolationReport as V, ObjectMetaProperties as _, EcmaVersion as a, ProcessorFile as b, GlobalsConfig as c, LanguageOptions as d, LegacyConfigObject as f, MessagePlaceholderData as g, LinterOptionsConfig as h, DeprecatedInfo as i, SeverityLevel as j, RulesMeta as k, HasRules as l, LintSuggestion as m, ConfigObject as n, EnvironmentConfig as o, LintMessage as p, ConfigOverride as r, GlobalAccess as s, BaseConfig as t, JavaScriptSourceType as u, Plugin as v, RuleFixer as w, RuleConfig as x, Processor as y, ViolationLocation as z };