@saasmakers/eslint 0.2.6 → 0.2.7

package/dist/eslint.config.d.ts

@@ -1,12 +1,3883 @@
 import antfu from '@antfu/eslint-config';
+import { Linter, Rule, ESLint } from 'eslint';
 import saasmakers from '@saasmakers/eslint';
 import vitest from '@vitest/eslint-plugin';
 import packageJson from 'eslint-plugin-package-json';
-import { Linter, ESLint } from 'eslint';
 import storybook from 'eslint-plugin-storybook';
 import turbo from 'eslint-plugin-turbo';
 import zod from 'eslint-plugin-zod';
 
+// ==================================================================================================
+// 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;
+}
+
+/**
+ * @fileoverview Shared types for ESLint Core.
+ */
+
+/**
+ * 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 {
+    /**
+     * 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[] | null | undefined;
+}
+type ViolationMessage<MessageIds = string> = {
+    message: string;
+} | {
+    messageId: MessageIds;
+};
+type ViolationLocation<Node> = {
+    loc: SourceLocation | Position;
+} | {
+    node: Node;
+};
+type ViolationReport<Node = unknown, MessageIds = string> = ViolationReportBase & 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 = {
+    desc: string;
+} | {
+    messageId: string;
+};
+/**
+ * A suggested edit for a rule violation.
+ */
+type SuggestedEdit = SuggestedEditBase & SuggestionMessage;
+/**
+ * The normalized version of a lint suggestion.
+ */
+interface LintSuggestion {
+    /** A short description. */
+    desc: string;
+    /** Fix result info. */
+    fix: RuleTextEdit;
+    /** Id referencing a message for the description. */
+    messageId?: string | undefined;
+}
+/**
+ * The normalized version of a lint violation message.
+ */
+interface LintMessage {
+    /** 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$1<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$1<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$1<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;
+}
+
+/**
+ * @fileoverview Types for this package.
+ */
+
+
+
+/**
+ * Infinite array type.
+ */
+type InfiniteArray<T> = T | InfiniteArray<T>[];
+
+/**
+ * The type of array element in the `extends` property after flattening.
+ */
+type SimpleExtendsElement = string | ConfigObject;
+
+/**
+ * The type of array element in the `extends` property before flattening.
+ */
+type ExtendsElement = SimpleExtendsElement | InfiniteArray<ConfigObject>;
+
+/**
+ * Config with extends. Valid only inside of `defineConfig()`.
+ */
+interface ConfigWithExtends$1 extends ConfigObject {
+	extends?: ExtendsElement[];
+}
+
+type ConfigWithExtends = ConfigWithExtends$1;
+
+/**
+ * A type that can be awaited. Promise<T> or T.
+ */
+type Awaitable<T> = T | Promise<T>;
+/**
+ * A type that can be an array or a single item.
+ */
+type Arrayable<T> = T | T[];
+/**
+ * Default config names map. Used for type augmentation.
+ *
+ * @example
+ * ```ts
+ * declare module 'eslint-flat-config-utils' {
+ *   interface DefaultConfigNamesMap {
+ *     'my-custom-config': true
+ *   }
+ * }
+ * ```
+ */
+interface DefaultConfigNamesMap {
+}
+interface Nothing {
+}
+/**
+ * type StringLiteralUnion<'foo'> = 'foo' | string
+ * This has auto completion whereas `'foo' | string` doesn't
+ * Adapted from https://github.com/microsoft/TypeScript/issues/29729
+ */
+type StringLiteralUnion<T extends U, U = string> = T | (U & Nothing);
+type FilterType<T, F> = T extends F ? T : never;
+type NullableObject<T> = {
+    [K in keyof T]?: T[K] | null | undefined;
+};
+type GetRuleRecordFromConfig<T> = T extends {
+    rules?: infer R;
+} ? R : Linter.RulesRecord;
+interface DisableFixesOptions {
+    builtinRules?: Map<string, Rule.RuleModule> | (() => Awaitable<Map<string, Rule.RuleModule>>);
+}
+type PluginConflictsError<T extends Linter.Config = Linter.Config> = (pluginName: string, configs: T[]) => string;
+/**
+ * Awaitable array of ESLint flat configs or a composer object.
+ */
+type ResolvableFlatConfig<T extends object = ConfigWithExtends> = Awaitable<Arrayable<(T | false | undefined | null)>> | Awaitable<(ConfigWithExtends | false | undefined | null)[]> | Awaitable<(Linter.Config | false | undefined | null)[]> | FlatConfigComposer<any>;
+/**
+ * The underlying impolementation of `composer()`.
+ */
+declare class FlatConfigComposer<T extends object = ConfigWithExtends, ConfigNames extends string = keyof DefaultConfigNamesMap> extends Promise<Linter.Config[]> {
+    private _operations;
+    private _operationsOverrides;
+    private _operationsResolved;
+    private _renames;
+    private _pluginsConflictsError;
+    constructor(...configs: ResolvableFlatConfig<T>[]);
+    /**
+     * Set plugin renames, like `n` -> `node`, `import-x` -> `import`, etc.
+     *
+     * This will runs after all config items are resolved. Applies to `plugins` and `rules`.
+     */
+    renamePlugins(renames: Record<string, string>): this;
+    /**
+     * Append configs to the end of the current configs array.
+     */
+    append(...items: ResolvableFlatConfig<T>[]): this;
+    /**
+     * Prepend configs to the beginning of the current configs array.
+     */
+    prepend(...items: ResolvableFlatConfig<T>[]): this;
+    /**
+     * Insert configs before a specific config.
+     */
+    insertBefore(nameOrIndex: StringLiteralUnion<ConfigNames, string | number>, ...items: ResolvableFlatConfig<T>[]): this;
+    /**
+     * Insert configs after a specific config.
+     */
+    insertAfter(nameOrIndex: StringLiteralUnion<ConfigNames, string | number>, ...items: ResolvableFlatConfig<T>[]): this;
+    /**
+     * Provide overrides to a specific config.
+     *
+     * It will be merged with the original config, or provide a custom function to replace the config entirely.
+     */
+    override(nameOrIndex: StringLiteralUnion<ConfigNames, string | number>, config: T | ((config: T) => Awaitable<T>)): this;
+    /**
+     * Provide overrides to multiple configs as an object map.
+     *
+     * Same as calling `override` multiple times.
+     */
+    overrides(overrides: Partial<Record<StringLiteralUnion<ConfigNames, string | number>, T | ((config: T) => Awaitable<T>)>>): this;
+    /**
+     * Override rules and it's options in **all configs**.
+     *
+     * Pass `null` as the value to remove the rule.
+     *
+     * @example
+     * ```ts
+     * composer
+     *   .overrideRules({
+     *      'no-console': 'off',
+     *      'no-unused-vars': ['error', { vars: 'all', args: 'after-used' }],
+     *      // remove the rule from all configs
+     *      'no-undef': null,
+     *   })
+     * ```
+     */
+    overrideRules(rules: NullableObject<GetRuleRecordFromConfig<T>>): this;
+    /**
+     * Remove rules from **all configs**.
+     *
+     * @example
+     * ```ts
+     * composer
+     *  .removeRules(
+     *    'no-console',
+     *    'no-unused-vars'
+     *  )
+     * ```
+     */
+    removeRules(...rules: StringLiteralUnion<FilterType<keyof GetRuleRecordFromConfig<T>, string>, string>[]): this;
+    /**
+     * Remove plugins by name and all the rules referenced by them.
+     *
+     * @example
+     * ```ts
+     * composer
+     *   .removePlugins(
+     *     'node'
+     *   )
+     * ```
+     *
+     * The `plugins: { node }` and `rules: { 'node/xxx': 'error' }` will be removed from all configs.
+     */
+    removePlugins(...names: string[]): this;
+    /**
+     * Remove a specific config by name or index.
+     */
+    remove(nameOrIndex: ConfigNames | string | number): this;
+    /**
+     * Replace a specific config by name or index.
+     *
+     * The original config will be removed and replaced with the new one.
+     */
+    replace(nameOrIndex: StringLiteralUnion<ConfigNames, string | number>, ...items: ResolvableFlatConfig<T>[]): this;
+    /**
+     * Hijack into plugins to disable fixes for specific rules.
+     *
+     * Note this mutates the plugin object, use with caution.
+     *
+     * @example
+     * ```ts
+     * const config = await composer(...)
+     *  .disableRulesFix([
+     *    'unused-imports/no-unused-imports',
+     *    'vitest/no-only-tests'
+     *  ])
+     * ```
+     */
+    disableRulesFix(ruleIds: string[], options?: DisableFixesOptions): this;
+    /**
+     * Set a custom warning message for plugins conflicts.
+     *
+     * The error message can be a string or a function that returns a string.
+     *
+     * Error message accepts template strings:
+     * - `{{pluginName}}`: the name of the plugin that has conflicts
+     * - `{{configName1}}`: the name of the first config that uses the plugin
+     * - `{{configName2}}`: the name of the second config that uses the plugin
+     * - `{{configNames}}`: a list of config names that uses the plugin
+     *
+     * When only one argument is provided, it will be used as the default error message.
+     */
+    setPluginConflictsError(warning?: string | PluginConflictsError): this;
+    setPluginConflictsError(pluginName: string, warning: string | PluginConflictsError): this;
+    private _verifyPluginsConflicts;
+    /**
+     * Hook when all configs are resolved but before returning the final configs.
+     *
+     * You can modify the final configs here.
+     */
+    onResolved(callback: (configs: T[]) => Awaitable<T[] | void>): this;
+    /**
+     * Clone the composer object.
+     */
+    clone(): FlatConfigComposer<T>;
+    /**
+     * Resolve the pipeline and return the final configs.
+     *
+     * This returns a promise. Calling `.then()` has the same effect.
+     */
+    toConfigs(): Promise<Linter.Config[]>;
+    then<T>(onFulfilled: (value: Linter.Config[]) => T, onRejected?: (reason: any) => any): Promise<Awaited<T>>;
+    catch(onRejected: (reason: any) => any): Promise<any>;
+    finally(onFinally: () => void): Promise<Linter.Config[]>;
+}
+
+//#region rules/array-bracket-newline/types.d.ts
+
+type ArrayBracketNewlineSchema0 = ('always' | 'never' | 'consistent') | {
+  multiline?: boolean;
+  minItems?: number | null;
+};
+type ArrayBracketNewlineRuleOptions = [ArrayBracketNewlineSchema0?];
+//#endregion
+//#region rules/array-bracket-spacing/types.d.ts
+
+type ArrayBracketSpacingSchema0 = 'always' | 'never';
+interface ArrayBracketSpacingSchema1 {
+  singleValue?: boolean;
+  objectsInArrays?: boolean;
+  arraysInArrays?: boolean;
+}
+type ArrayBracketSpacingRuleOptions = [ArrayBracketSpacingSchema0?, ArrayBracketSpacingSchema1?];
+//#endregion
+//#region rules/array-element-newline/types.d.ts
+
+type ArrayElementNewlineSchema0 = [] | [BasicConfig | {
+  ArrayExpression?: BasicConfig;
+  ArrayPattern?: BasicConfig;
+}];
+type BasicConfig = ('always' | 'never' | 'consistent') | {
+  consistent?: boolean;
+  multiline?: boolean;
+  minItems?: number | null;
+};
+type ArrayElementNewlineRuleOptions = ArrayElementNewlineSchema0;
+//#endregion
+//#region rules/arrow-parens/types.d.ts
+
+type ArrowParensSchema0 = 'always' | 'as-needed';
+interface ArrowParensSchema1 {
+  requireForBlockBody?: boolean;
+}
+type ArrowParensRuleOptions = [ArrowParensSchema0?, ArrowParensSchema1?];
+//#endregion
+//#region rules/arrow-spacing/types.d.ts
+
+interface ArrowSpacingSchema0 {
+  before?: boolean;
+  after?: boolean;
+}
+type ArrowSpacingRuleOptions = [ArrowSpacingSchema0?];
+//#endregion
+//#region rules/block-spacing/types.d.ts
+
+type BlockSpacingSchema0 = 'always' | 'never';
+type BlockSpacingRuleOptions = [BlockSpacingSchema0?];
+//#endregion
+//#region rules/brace-style/types.d.ts
+
+type BraceStyleSchema0 = '1tbs' | 'stroustrup' | 'allman';
+interface BraceStyleSchema1 {
+  allowSingleLine?: boolean;
+}
+type BraceStyleRuleOptions = [BraceStyleSchema0?, BraceStyleSchema1?];
+//#endregion
+//#region rules/comma-dangle/types.d.ts
+
+type CommaDangleSchema0 = [] | [Value | {
+  arrays?: ValueWithIgnore;
+  objects?: ValueWithIgnore;
+  imports?: ValueWithIgnore;
+  exports?: ValueWithIgnore;
+  functions?: ValueWithIgnore;
+  importAttributes?: ValueWithIgnore;
+  dynamicImports?: ValueWithIgnore;
+  enums?: ValueWithIgnore;
+  generics?: ValueWithIgnore;
+  tuples?: ValueWithIgnore;
+}];
+type Value = 'always-multiline' | 'always' | 'never' | 'only-multiline';
+type ValueWithIgnore = 'always-multiline' | 'always' | 'never' | 'only-multiline' | 'ignore';
+type CommaDangleRuleOptions = CommaDangleSchema0;
+//#endregion
+//#region rules/comma-spacing/types.d.ts
+
+interface CommaSpacingSchema0 {
+  before?: boolean;
+  after?: boolean;
+}
+type CommaSpacingRuleOptions = [CommaSpacingSchema0?];
+//#endregion
+//#region rules/comma-style/types.d.ts
+
+type CommaStyleSchema0 = 'first' | 'last';
+interface CommaStyleSchema1 {
+  exceptions?: {
+    [k: string]: boolean;
+  };
+}
+type CommaStyleRuleOptions = [CommaStyleSchema0?, CommaStyleSchema1?];
+//#endregion
+//#region rules/computed-property-spacing/types.d.ts
+
+type ComputedPropertySpacingSchema0 = 'always' | 'never';
+interface ComputedPropertySpacingSchema1 {
+  enforceForClassMembers?: boolean;
+}
+type ComputedPropertySpacingRuleOptions = [ComputedPropertySpacingSchema0?, ComputedPropertySpacingSchema1?];
+//#endregion
+//#region rules/curly-newline/types.d.ts
+
+type CurlyNewlineSchema0 = ('always' | 'never') | {
+  IfStatementConsequent?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  IfStatementAlternative?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  DoWhileStatement?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  ForInStatement?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  ForOfStatement?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  ForStatement?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  WhileStatement?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  SwitchStatement?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  SwitchCase?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  TryStatementBlock?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  TryStatementHandler?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  TryStatementFinalizer?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  BlockStatement?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  ArrowFunctionExpression?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  FunctionDeclaration?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  FunctionExpression?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  Property?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  ClassBody?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  StaticBlock?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  WithStatement?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  TSModuleBlock?: ('always' | 'never') | {
+    multiline?: boolean;
+    minElements?: number;
+    consistent?: boolean;
+  };
+  multiline?: boolean;
+  minElements?: number;
+  consistent?: boolean;
+};
+type CurlyNewlineRuleOptions = [CurlyNewlineSchema0?];
+//#endregion
+//#region rules/dot-location/types.d.ts
+
+type DotLocationSchema0 = 'object' | 'property';
+type DotLocationRuleOptions = [DotLocationSchema0?];
+//#endregion
+//#region rules/eol-last/types.d.ts
+
+type EolLastSchema0 = 'always' | 'never' | 'unix' | 'windows';
+type EolLastRuleOptions = [EolLastSchema0?];
+//#endregion
+//#region rules/function-call-argument-newline/types.d.ts
+
+type FunctionCallArgumentNewlineSchema0 = 'always' | 'never' | 'consistent';
+type FunctionCallArgumentNewlineRuleOptions = [FunctionCallArgumentNewlineSchema0?];
+//#endregion
+//#region rules/function-call-spacing/types.d.ts
+
+type FunctionCallSpacingSchema0 = [] | ['never'] | [] | ['always'] | ['always', {
+  allowNewlines?: boolean;
+  optionalChain?: {
+    before?: boolean;
+    after?: boolean;
+  };
+}];
+type FunctionCallSpacingRuleOptions = FunctionCallSpacingSchema0;
+//#endregion
+//#region rules/function-paren-newline/types.d.ts
+
+type FunctionParenNewlineSchema0 = ('always' | 'never' | 'consistent' | 'multiline' | 'multiline-arguments') | {
+  minItems?: number;
+};
+type FunctionParenNewlineRuleOptions = [FunctionParenNewlineSchema0?];
+//#endregion
+//#region rules/generator-star-spacing/types.d.ts
+
+type GeneratorStarSpacingSchema0 = ('before' | 'after' | 'both' | 'neither') | {
+  before?: boolean;
+  after?: boolean;
+  named?: ('before' | 'after' | 'both' | 'neither') | {
+    before?: boolean;
+    after?: boolean;
+  };
+  anonymous?: ('before' | 'after' | 'both' | 'neither') | {
+    before?: boolean;
+    after?: boolean;
+  };
+  method?: ('before' | 'after' | 'both' | 'neither') | {
+    before?: boolean;
+    after?: boolean;
+  };
+  shorthand?: ('before' | 'after' | 'both' | 'neither') | {
+    before?: boolean;
+    after?: boolean;
+  };
+};
+type GeneratorStarSpacingRuleOptions = [GeneratorStarSpacingSchema0?];
+//#endregion
+//#region rules/implicit-arrow-linebreak/types.d.ts
+
+type ImplicitArrowLinebreakSchema0 = 'beside' | 'below';
+type ImplicitArrowLinebreakRuleOptions = [ImplicitArrowLinebreakSchema0?];
+//#endregion
+//#region rules/indent-binary-ops/types.d.ts
+
+type IndentBinaryOpsSchema0 = number | 'tab';
+type IndentBinaryOpsRuleOptions = [IndentBinaryOpsSchema0?];
+//#endregion
+//#region rules/indent/types.d.ts
+
+type IndentSchema0 = 'tab' | number;
+interface IndentSchema1 {
+  SwitchCase?: number;
+  VariableDeclarator?: (number | ('first' | 'off')) | {
+    var?: number | ('first' | 'off');
+    let?: number | ('first' | 'off');
+    const?: number | ('first' | 'off');
+    using?: number | ('first' | 'off');
+  };
+  assignmentOperator?: number | 'off';
+  outerIIFEBody?: number | 'off';
+  MemberExpression?: number | 'off';
+  FunctionDeclaration?: {
+    parameters?: number | ('first' | 'off');
+    body?: number;
+    returnType?: number;
+  };
+  FunctionExpression?: {
+    parameters?: number | ('first' | 'off');
+    body?: number;
+    returnType?: number;
+  };
+  StaticBlock?: {
+    body?: number;
+  };
+  CallExpression?: {
+    arguments?: number | ('first' | 'off');
+  };
+  ArrayExpression?: number | ('first' | 'off');
+  ObjectExpression?: number | ('first' | 'off');
+  ImportDeclaration?: number | ('first' | 'off');
+  flatTernaryExpressions?: boolean;
+  offsetTernaryExpressions?: boolean | {
+    CallExpression?: boolean;
+    AwaitExpression?: boolean;
+    NewExpression?: boolean;
+  };
+  offsetTernaryExpressionsOffsetCallExpressions?: boolean;
+  ignoredNodes?: string[];
+  ignoreComments?: boolean;
+  tabLength?: number;
+}
+type IndentRuleOptions$1 = [IndentSchema0?, IndentSchema1?];
+//#endregion
+//#region rules/jsx-child-element-spacing/types.d.ts
+
+type JsxChildElementSpacingRuleOptions = [];
+//#endregion
+//#region rules/jsx-closing-bracket-location/types.d.ts
+
+type JsxClosingBracketLocationSchema0 = ('after-props' | 'props-aligned' | 'tag-aligned' | 'line-aligned') | {
+  location?: 'after-props' | 'props-aligned' | 'tag-aligned' | 'line-aligned';
+} | {
+  nonEmpty?: ('after-props' | 'props-aligned' | 'tag-aligned' | 'line-aligned') | false;
+  selfClosing?: ('after-props' | 'props-aligned' | 'tag-aligned' | 'line-aligned') | false;
+};
+type JsxClosingBracketLocationRuleOptions = [JsxClosingBracketLocationSchema0?];
+//#endregion
+//#region rules/jsx-closing-tag-location/types.d.ts
+
+type JsxClosingTagLocationSchema0 = 'tag-aligned' | 'line-aligned';
+type JsxClosingTagLocationRuleOptions = [JsxClosingTagLocationSchema0?];
+//#endregion
+//#region rules/jsx-curly-brace-presence/types.d.ts
+
+type JsxCurlyBracePresenceSchema0 = {
+  props?: 'always' | 'never' | 'ignore';
+  children?: 'always' | 'never' | 'ignore';
+  propElementValues?: 'always' | 'never' | 'ignore';
+} | ('always' | 'never' | 'ignore');
+type JsxCurlyBracePresenceRuleOptions = [JsxCurlyBracePresenceSchema0?];
+//#endregion
+//#region rules/jsx-curly-newline/types.d.ts
+
+type JsxCurlyNewlineSchema0 = ('consistent' | 'never') | {
+  singleline?: 'consistent' | 'require' | 'forbid';
+  multiline?: 'consistent' | 'require' | 'forbid';
+};
+type JsxCurlyNewlineRuleOptions = [JsxCurlyNewlineSchema0?];
+//#endregion
+//#region rules/jsx-curly-spacing/types.d.ts
+
+type JsxCurlySpacingSchema0 = [] | [{
+  when?: 'always' | 'never';
+  allowMultiline?: boolean;
+  spacing?: {
+    objectLiterals?: 'always' | 'never';
+  };
+  attributes?: {
+    when?: 'always' | 'never';
+    allowMultiline?: boolean;
+    spacing?: {
+      objectLiterals?: 'always' | 'never';
+    };
+  } | boolean;
+  children?: {
+    when?: 'always' | 'never';
+    allowMultiline?: boolean;
+    spacing?: {
+      objectLiterals?: 'always' | 'never';
+    };
+  } | boolean;
+} | ('always' | 'never')] | [({
+  when?: 'always' | 'never';
+  allowMultiline?: boolean;
+  spacing?: {
+    objectLiterals?: 'always' | 'never';
+  };
+  attributes?: {
+    when?: 'always' | 'never';
+    allowMultiline?: boolean;
+    spacing?: {
+      objectLiterals?: 'always' | 'never';
+    };
+  } | boolean;
+  children?: {
+    when?: 'always' | 'never';
+    allowMultiline?: boolean;
+    spacing?: {
+      objectLiterals?: 'always' | 'never';
+    };
+  } | boolean;
+} | ('always' | 'never')), {
+  allowMultiline?: boolean;
+  spacing?: {
+    objectLiterals?: 'always' | 'never';
+  };
+}];
+type JsxCurlySpacingRuleOptions = JsxCurlySpacingSchema0;
+//#endregion
+//#region rules/jsx-equals-spacing/types.d.ts
+
+type JsxEqualsSpacingSchema0 = 'always' | 'never';
+type JsxEqualsSpacingRuleOptions = [JsxEqualsSpacingSchema0?];
+//#endregion
+//#region rules/jsx-first-prop-new-line/types.d.ts
+
+type JsxFirstPropNewLineSchema0 = 'always' | 'never' | 'multiline' | 'multiline-multiprop' | 'multiprop';
+type JsxFirstPropNewLineRuleOptions = [JsxFirstPropNewLineSchema0?];
+//#endregion
+//#region rules/jsx-function-call-newline/types.d.ts
+
+type JsxFunctionCallNewlineSchema0 = 'always' | 'multiline';
+type JsxFunctionCallNewlineRuleOptions = [JsxFunctionCallNewlineSchema0?];
+//#endregion
+//#region rules/jsx-indent-props/types.d.ts
+
+type JsxIndentPropsSchema0 = ('tab' | 'first') | number | {
+  indentMode?: ('tab' | 'first') | number;
+  ignoreTernaryOperator?: boolean;
+};
+type JsxIndentPropsRuleOptions = [JsxIndentPropsSchema0?];
+//#endregion
+//#region rules/jsx-indent/types.d.ts
+
+type JsxIndentSchema0 = 'tab' | number;
+interface JsxIndentSchema1 {
+  checkAttributes?: boolean;
+  indentLogicalExpressions?: boolean;
+}
+type JsxIndentRuleOptions = [JsxIndentSchema0?, JsxIndentSchema1?];
+//#endregion
+//#region rules/jsx-max-props-per-line/types.d.ts
+
+type JsxMaxPropsPerLineSchema0 = {
+  maximum?: {
+    single?: number;
+    multi?: number;
+  };
+} | {
+  maximum?: number;
+  when?: 'always' | 'multiline';
+};
+type JsxMaxPropsPerLineRuleOptions = [JsxMaxPropsPerLineSchema0?];
+//#endregion
+//#region rules/jsx-newline/types.d.ts
+
+interface JsxNewlineSchema0 {
+  prevent?: boolean;
+  allowMultilines?: boolean;
+}
+type JsxNewlineRuleOptions = [JsxNewlineSchema0?];
+//#endregion
+//#region rules/jsx-one-expression-per-line/types.d.ts
+
+interface JsxOneExpressionPerLineSchema0 {
+  allow?: 'none' | 'literal' | 'single-child' | 'single-line' | 'non-jsx';
+}
+type JsxOneExpressionPerLineRuleOptions = [JsxOneExpressionPerLineSchema0?];
+//#endregion
+//#region rules/jsx-pascal-case/types.d.ts
+
+interface JsxPascalCaseSchema0 {
+  allowAllCaps?: boolean;
+  allowLeadingUnderscore?: boolean;
+  allowNamespace?: boolean;
+  ignore?: string[];
+}
+type JsxPascalCaseRuleOptions = [JsxPascalCaseSchema0?];
+//#endregion
+//#region rules/jsx-props-no-multi-spaces/types.d.ts
+
+type JsxPropsNoMultiSpacesRuleOptions = [];
+//#endregion
+//#region rules/jsx-props-style/types.d.ts
+
+interface JsxPropsStyleSchema0 {
+  singleLine?: {
+    maxItems?: number;
+  };
+  multiLine?: {
+    minItems?: number;
+    maxItemsPerLine?: number;
+  };
+}
+type JsxPropsStyleRuleOptions = [JsxPropsStyleSchema0?];
+//#endregion
+//#region rules/jsx-quotes/types.d.ts
+
+type JsxQuotesSchema0 = 'prefer-single' | 'prefer-double';
+type JsxQuotesRuleOptions = [JsxQuotesSchema0?];
+//#endregion
+//#region rules/jsx-self-closing-comp/types.d.ts
+
+interface JsxSelfClosingCompSchema0 {
+  component?: boolean;
+  html?: boolean;
+}
+type JsxSelfClosingCompRuleOptions = [JsxSelfClosingCompSchema0?];
+//#endregion
+//#region rules/jsx-sort-props/types.d.ts
+
+interface JsxSortPropsSchema0 {
+  callbacksLast?: boolean;
+  shorthandFirst?: boolean;
+  shorthandLast?: boolean;
+  multiline?: 'ignore' | 'first' | 'last';
+  ignoreCase?: boolean;
+  noSortAlphabetically?: boolean;
+  reservedFirst?: string[] | boolean;
+  reservedLast?: string[];
+  locale?: string;
+}
+type JsxSortPropsRuleOptions = [JsxSortPropsSchema0?];
+//#endregion
+//#region rules/jsx-tag-spacing/types.d.ts
+
+interface JsxTagSpacingSchema0 {
+  closingSlash?: 'always' | 'never' | 'allow';
+  beforeSelfClosing?: 'always' | 'proportional-always' | 'never' | 'allow';
+  afterOpening?: 'always' | 'allow-multiline' | 'never' | 'allow';
+  beforeClosing?: 'always' | 'proportional-always' | 'never' | 'allow';
+}
+type JsxTagSpacingRuleOptions = [JsxTagSpacingSchema0?];
+//#endregion
+//#region rules/jsx-wrap-multilines/types.d.ts
+
+interface JsxWrapMultilinesSchema0 {
+  declaration?: true | false | 'ignore' | 'parens' | 'parens-new-line';
+  assignment?: true | false | 'ignore' | 'parens' | 'parens-new-line';
+  return?: true | false | 'ignore' | 'parens' | 'parens-new-line';
+  arrow?: true | false | 'ignore' | 'parens' | 'parens-new-line';
+  condition?: true | false | 'ignore' | 'parens' | 'parens-new-line';
+  logical?: true | false | 'ignore' | 'parens' | 'parens-new-line';
+  prop?: true | false | 'ignore' | 'parens' | 'parens-new-line';
+  propertyValue?: true | false | 'ignore' | 'parens' | 'parens-new-line';
+}
+type JsxWrapMultilinesRuleOptions = [JsxWrapMultilinesSchema0?];
+//#endregion
+//#region rules/key-spacing/types.d.ts
+
+type KeySpacingSchema0 = {
+  align?: ('colon' | 'value') | {
+    mode?: 'strict' | 'minimum';
+    on?: 'colon' | 'value';
+    beforeColon?: boolean;
+    afterColon?: boolean;
+  };
+  mode?: 'strict' | 'minimum';
+  beforeColon?: boolean;
+  afterColon?: boolean;
+  ignoredNodes?: ('ObjectExpression' | 'ObjectPattern' | 'ImportDeclaration' | 'ExportNamedDeclaration' | 'ExportAllDeclaration' | 'TSTypeLiteral' | 'TSInterfaceBody' | 'ClassBody')[];
+} | {
+  singleLine?: {
+    mode?: 'strict' | 'minimum';
+    beforeColon?: boolean;
+    afterColon?: boolean;
+  };
+  multiLine?: {
+    align?: ('colon' | 'value') | {
+      mode?: 'strict' | 'minimum';
+      on?: 'colon' | 'value';
+      beforeColon?: boolean;
+      afterColon?: boolean;
+    };
+    mode?: 'strict' | 'minimum';
+    beforeColon?: boolean;
+    afterColon?: boolean;
+  };
+} | {
+  singleLine?: {
+    mode?: 'strict' | 'minimum';
+    beforeColon?: boolean;
+    afterColon?: boolean;
+  };
+  multiLine?: {
+    mode?: 'strict' | 'minimum';
+    beforeColon?: boolean;
+    afterColon?: boolean;
+  };
+  align?: {
+    mode?: 'strict' | 'minimum';
+    on?: 'colon' | 'value';
+    beforeColon?: boolean;
+    afterColon?: boolean;
+  };
+};
+type KeySpacingRuleOptions = [KeySpacingSchema0?];
+//#endregion
+//#region rules/keyword-spacing/types.d.ts
+
+interface KeywordSpacingSchema0 {
+  before?: boolean;
+  after?: boolean;
+  overrides?: {
+    abstract?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    boolean?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    break?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    byte?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    case?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    catch?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    char?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    class?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    const?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    continue?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    debugger?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    default?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    delete?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    do?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    double?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    else?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    enum?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    export?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    extends?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    false?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    final?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    finally?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    float?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    for?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    function?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    goto?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    if?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    implements?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    import?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    in?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    instanceof?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    int?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    interface?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    long?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    native?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    new?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    null?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    package?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    private?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    protected?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    public?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    return?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    short?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    static?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    super?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    switch?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    synchronized?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    this?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    throw?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    throws?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    transient?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    true?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    try?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    typeof?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    var?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    void?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    volatile?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    while?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    with?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    arguments?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    as?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    async?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    await?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    eval?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    from?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    get?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    let?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    of?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    set?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    type?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    using?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    yield?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    accessor?: {
+      before?: boolean;
+      after?: boolean;
+    };
+    satisfies?: {
+      before?: boolean;
+      after?: boolean;
+    };
+  };
+}
+type KeywordSpacingRuleOptions = [KeywordSpacingSchema0?];
+//#endregion
+//#region rules/line-comment-position/types.d.ts
+
+type LineCommentPositionSchema0 = ('above' | 'beside') | {
+  position?: 'above' | 'beside';
+  ignorePattern?: string;
+  applyDefaultPatterns?: boolean;
+  applyDefaultIgnorePatterns?: boolean;
+};
+type LineCommentPositionRuleOptions = [LineCommentPositionSchema0?];
+//#endregion
+//#region rules/linebreak-style/types.d.ts
+
+type LinebreakStyleSchema0 = 'unix' | 'windows';
+type LinebreakStyleRuleOptions = [LinebreakStyleSchema0?];
+//#endregion
+//#region rules/lines-around-comment/types.d.ts
+
+interface LinesAroundCommentSchema0 {
+  beforeBlockComment?: boolean;
+  afterBlockComment?: boolean;
+  beforeLineComment?: boolean;
+  afterLineComment?: boolean;
+  allowBlockStart?: boolean;
+  allowBlockEnd?: boolean;
+  allowClassStart?: boolean;
+  allowClassEnd?: boolean;
+  allowObjectStart?: boolean;
+  allowObjectEnd?: boolean;
+  allowArrayStart?: boolean;
+  allowArrayEnd?: boolean;
+  allowInterfaceStart?: boolean;
+  allowInterfaceEnd?: boolean;
+  allowTypeStart?: boolean;
+  allowTypeEnd?: boolean;
+  allowEnumStart?: boolean;
+  allowEnumEnd?: boolean;
+  allowModuleStart?: boolean;
+  allowModuleEnd?: boolean;
+  ignorePattern?: string;
+  applyDefaultIgnorePatterns?: boolean;
+  afterHashbangComment?: boolean;
+}
+type LinesAroundCommentRuleOptions = [LinesAroundCommentSchema0?];
+//#endregion
+//#region rules/lines-between-class-members/types.d.ts
+
+type LinesBetweenClassMembersSchema0 = {
+  /**
+   * @minItems 1
+   */
+  enforce: [{
+    blankLine: 'always' | 'never';
+    prev: 'method' | 'field' | '*';
+    next: 'method' | 'field' | '*';
+  }, ...{
+    blankLine: 'always' | 'never';
+    prev: 'method' | 'field' | '*';
+    next: 'method' | 'field' | '*';
+  }[]];
+} | ('always' | 'never');
+interface LinesBetweenClassMembersSchema1 {
+  exceptAfterSingleLine?: boolean;
+  exceptAfterOverload?: boolean;
+}
+type LinesBetweenClassMembersRuleOptions = [LinesBetweenClassMembersSchema0?, LinesBetweenClassMembersSchema1?];
+//#endregion
+//#region rules/list-style/types.d.ts
+
+type OverrideConfig = BaseConfig | 'off';
+interface ListStyleSchema0 {
+  singleLine?: SingleLineConfig;
+  multiLine?: MultiLineConfig;
+  overrides?: {
+    '()'?: OverrideConfig;
+    '[]'?: OverrideConfig;
+    '{}'?: OverrideConfig;
+    '<>'?: OverrideConfig;
+    'ArrayExpression'?: OverrideConfig;
+    'ArrayPattern'?: OverrideConfig;
+    'ArrowFunctionExpression'?: OverrideConfig;
+    'CallExpression'?: OverrideConfig;
+    'ExportNamedDeclaration'?: OverrideConfig;
+    'FunctionDeclaration'?: OverrideConfig;
+    'FunctionExpression'?: OverrideConfig;
+    'IfStatement'?: OverrideConfig;
+    'ImportAttributes'?: OverrideConfig;
+    'ImportDeclaration'?: OverrideConfig;
+    'JSONArrayExpression'?: OverrideConfig;
+    'JSONObjectExpression'?: OverrideConfig;
+    'NewExpression'?: OverrideConfig;
+    'ObjectExpression'?: OverrideConfig;
+    'ObjectPattern'?: OverrideConfig;
+    'TSDeclareFunction'?: OverrideConfig;
+    'TSEnumBody'?: OverrideConfig;
+    'TSFunctionType'?: OverrideConfig;
+    'TSInterfaceBody'?: OverrideConfig;
+    'TSTupleType'?: OverrideConfig;
+    'TSTypeLiteral'?: OverrideConfig;
+    'TSTypeParameterDeclaration'?: OverrideConfig;
+    'TSTypeParameterInstantiation'?: OverrideConfig;
+  };
+}
+interface SingleLineConfig {
+  spacing?: 'always' | 'never';
+  maxItems?: number;
+}
+interface MultiLineConfig {
+  minItems?: number;
+}
+interface BaseConfig {
+  singleLine?: SingleLineConfig;
+  multiline?: MultiLineConfig;
+}
+type ListStyleRuleOptions = [ListStyleSchema0?];
+//#endregion
+//#region rules/max-len/types.d.ts
+
+type MaxLenSchema0 = {
+  code?: number;
+  comments?: number;
+  tabWidth?: number;
+  ignorePattern?: string;
+  ignoreComments?: boolean;
+  ignoreStrings?: boolean;
+  ignoreUrls?: boolean;
+  ignoreTemplateLiterals?: boolean;
+  ignoreRegExpLiterals?: boolean;
+  ignoreTrailingComments?: boolean;
+} | number;
+type MaxLenSchema1 = {
+  code?: number;
+  comments?: number;
+  tabWidth?: number;
+  ignorePattern?: string;
+  ignoreComments?: boolean;
+  ignoreStrings?: boolean;
+  ignoreUrls?: boolean;
+  ignoreTemplateLiterals?: boolean;
+  ignoreRegExpLiterals?: boolean;
+  ignoreTrailingComments?: boolean;
+} | number;
+interface MaxLenSchema2 {
+  code?: number;
+  comments?: number;
+  tabWidth?: number;
+  ignorePattern?: string;
+  ignoreComments?: boolean;
+  ignoreStrings?: boolean;
+  ignoreUrls?: boolean;
+  ignoreTemplateLiterals?: boolean;
+  ignoreRegExpLiterals?: boolean;
+  ignoreTrailingComments?: boolean;
+}
+type MaxLenRuleOptions = [MaxLenSchema0?, MaxLenSchema1?, MaxLenSchema2?];
+//#endregion
+//#region rules/max-statements-per-line/types.d.ts
+
+interface MaxStatementsPerLineSchema0 {
+  max?: number;
+  ignoredNodes?: ('BreakStatement' | 'ClassDeclaration' | 'ContinueStatement' | 'DebuggerStatement' | 'DoWhileStatement' | 'ExpressionStatement' | 'ForInStatement' | 'ForOfStatement' | 'ForStatement' | 'FunctionDeclaration' | 'IfStatement' | 'ImportDeclaration' | 'LabeledStatement' | 'ReturnStatement' | 'SwitchStatement' | 'ThrowStatement' | 'TryStatement' | 'VariableDeclaration' | 'WhileStatement' | 'WithStatement' | 'ExportNamedDeclaration' | 'ExportDefaultDeclaration' | 'ExportAllDeclaration')[];
+}
+type MaxStatementsPerLineRuleOptions = [MaxStatementsPerLineSchema0?];
+//#endregion
+//#region rules/member-delimiter-style/types.d.ts
+
+type MultiLineOption = 'none' | 'semi' | 'comma';
+type SingleLineOption = 'semi' | 'comma';
+interface MemberDelimiterStyleSchema0 {
+  multiline?: {
+    delimiter?: MultiLineOption;
+    requireLast?: boolean;
+  };
+  singleline?: {
+    delimiter?: SingleLineOption;
+    requireLast?: boolean;
+  };
+  overrides?: {
+    interface?: DelimiterConfig;
+    typeLiteral?: DelimiterConfig;
+  };
+  multilineDetection?: 'brackets' | 'last-member';
+}
+interface DelimiterConfig {
+  multiline?: {
+    delimiter?: MultiLineOption;
+    requireLast?: boolean;
+  };
+  singleline?: {
+    delimiter?: SingleLineOption;
+    requireLast?: boolean;
+  };
+}
+type MemberDelimiterStyleRuleOptions = [MemberDelimiterStyleSchema0?];
+//#endregion
+//#region rules/multiline-comment-style/types.d.ts
+
+type MultilineCommentStyleSchema0 = [] | ['starred-block' | 'bare-block'] | [] | ['separate-lines'] | ['separate-lines', {
+  checkJSDoc?: boolean;
+  checkExclamation?: boolean;
+}];
+type MultilineCommentStyleRuleOptions = MultilineCommentStyleSchema0;
+//#endregion
+//#region rules/multiline-ternary/types.d.ts
+
+type MultilineTernarySchema0 = 'always' | 'always-multiline' | 'never';
+interface MultilineTernarySchema1 {
+  ignoreJSX?: boolean;
+}
+type MultilineTernaryRuleOptions = [MultilineTernarySchema0?, MultilineTernarySchema1?];
+//#endregion
+//#region rules/new-parens/types.d.ts
+
+type NewParensSchema0 = 'always' | 'never';
+type NewParensRuleOptions = [NewParensSchema0?];
+//#endregion
+//#region rules/newline-per-chained-call/types.d.ts
+
+interface NewlinePerChainedCallSchema0 {
+  ignoreChainWithDepth?: number;
+}
+type NewlinePerChainedCallRuleOptions = [NewlinePerChainedCallSchema0?];
+//#endregion
+//#region rules/no-confusing-arrow/types.d.ts
+
+interface NoConfusingArrowSchema0 {
+  allowParens?: boolean;
+  onlyOneSimpleParam?: boolean;
+}
+type NoConfusingArrowRuleOptions = [NoConfusingArrowSchema0?];
+//#endregion
+//#region rules/no-extra-parens/types.d.ts
+
+type NoExtraParensSchema0 = [] | ['functions'] | [] | ['all'] | ['all', {
+  conditionalAssign?: boolean;
+  ternaryOperandBinaryExpressions?: boolean;
+  nestedBinaryExpressions?: boolean;
+  returnAssign?: boolean;
+  ignoreJSX?: 'none' | 'all' | 'single-line' | 'multi-line';
+  enforceForArrowConditionals?: boolean;
+  enforceForSequenceExpressions?: boolean;
+  enforceForNewInMemberExpressions?: boolean;
+  enforceForFunctionPrototypeMethods?: boolean;
+  allowParensAfterCommentPattern?: string;
+  nestedConditionalExpressions?: boolean;
+  allowNodesInSpreadElement?: {
+    ConditionalExpression?: boolean;
+    LogicalExpression?: boolean;
+    AwaitExpression?: boolean;
+  };
+  ignoredNodes?: string[];
+}];
+type NoExtraParensRuleOptions = NoExtraParensSchema0;
+//#endregion
+//#region rules/no-extra-semi/types.d.ts
+
+type NoExtraSemiRuleOptions = [];
+//#endregion
+//#region rules/no-floating-decimal/types.d.ts
+
+type NoFloatingDecimalRuleOptions = [];
+//#endregion
+//#region rules/no-mixed-operators/types.d.ts
+
+interface NoMixedOperatorsSchema0 {
+  groups?: [('+' | '-' | '*' | '/' | '%' | '**' | '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>' | '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=' | '&&' | '||' | 'in' | 'instanceof' | '?:' | '??'), ('+' | '-' | '*' | '/' | '%' | '**' | '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>' | '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=' | '&&' | '||' | 'in' | 'instanceof' | '?:' | '??'), ...('+' | '-' | '*' | '/' | '%' | '**' | '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>' | '==' | '!=' | '===' | '!==' | '>' | '>=' | '<' | '<=' | '&&' | '||' | 'in' | 'instanceof' | '?:' | '??')[]][];
+  allowSamePrecedence?: boolean;
+}
+type NoMixedOperatorsRuleOptions = [NoMixedOperatorsSchema0?];
+//#endregion
+//#region rules/no-mixed-spaces-and-tabs/types.d.ts
+
+type NoMixedSpacesAndTabsSchema0 = 'smart-tabs' | boolean;
+type NoMixedSpacesAndTabsRuleOptions = [NoMixedSpacesAndTabsSchema0?];
+//#endregion
+//#region rules/no-multi-spaces/types.d.ts
+
+interface NoMultiSpacesSchema0 {
+  exceptions?: {
+    [k: string]: boolean;
+  };
+  ignoreEOLComments?: boolean;
+  includeTabs?: boolean;
+}
+type NoMultiSpacesRuleOptions = [NoMultiSpacesSchema0?];
+//#endregion
+//#region rules/no-multiple-empty-lines/types.d.ts
+
+interface NoMultipleEmptyLinesSchema0 {
+  max: number;
+  maxEOF?: number;
+  maxBOF?: number;
+}
+type NoMultipleEmptyLinesRuleOptions = [NoMultipleEmptyLinesSchema0?];
+//#endregion
+//#region rules/no-tabs/types.d.ts
+
+interface NoTabsSchema0 {
+  allowIndentationTabs?: boolean;
+}
+type NoTabsRuleOptions = [NoTabsSchema0?];
+//#endregion
+//#region rules/no-trailing-spaces/types.d.ts
+
+interface NoTrailingSpacesSchema0 {
+  skipBlankLines?: boolean;
+  ignoreComments?: boolean;
+}
+type NoTrailingSpacesRuleOptions = [NoTrailingSpacesSchema0?];
+//#endregion
+//#region rules/no-whitespace-before-property/types.d.ts
+
+type NoWhitespaceBeforePropertyRuleOptions = [];
+//#endregion
+//#region rules/nonblock-statement-body-position/types.d.ts
+
+type NonblockStatementBodyPositionSchema0 = 'beside' | 'below' | 'any';
+interface NonblockStatementBodyPositionSchema1 {
+  overrides?: {
+    if?: 'beside' | 'below' | 'any';
+    else?: 'beside' | 'below' | 'any';
+    while?: 'beside' | 'below' | 'any';
+    do?: 'beside' | 'below' | 'any';
+    for?: 'beside' | 'below' | 'any';
+  };
+}
+type NonblockStatementBodyPositionRuleOptions = [NonblockStatementBodyPositionSchema0?, NonblockStatementBodyPositionSchema1?];
+//#endregion
+//#region rules/object-curly-newline/types.d.ts
+
+type ObjectCurlyNewlineSchema0 = (('always' | 'never') | {
+  multiline?: boolean;
+  minProperties?: number;
+  consistent?: boolean;
+}) | {
+  ObjectExpression?: ('always' | 'never') | {
+    multiline?: boolean;
+    minProperties?: number;
+    consistent?: boolean;
+  };
+  ObjectPattern?: ('always' | 'never') | {
+    multiline?: boolean;
+    minProperties?: number;
+    consistent?: boolean;
+  };
+  ImportDeclaration?: ('always' | 'never') | {
+    multiline?: boolean;
+    minProperties?: number;
+    consistent?: boolean;
+  };
+  ExportDeclaration?: ('always' | 'never') | {
+    multiline?: boolean;
+    minProperties?: number;
+    consistent?: boolean;
+  };
+  TSTypeLiteral?: ('always' | 'never') | {
+    multiline?: boolean;
+    minProperties?: number;
+    consistent?: boolean;
+  };
+  TSInterfaceBody?: ('always' | 'never') | {
+    multiline?: boolean;
+    minProperties?: number;
+    consistent?: boolean;
+  };
+  TSEnumBody?: ('always' | 'never') | {
+    multiline?: boolean;
+    minProperties?: number;
+    consistent?: boolean;
+  };
+};
+type ObjectCurlyNewlineRuleOptions = [ObjectCurlyNewlineSchema0?];
+//#endregion
+//#region rules/object-curly-spacing/types.d.ts
+
+type ObjectCurlySpacingSchema0 = 'always' | 'never';
+interface ObjectCurlySpacingSchema1 {
+  arraysInObjects?: boolean;
+  objectsInObjects?: boolean;
+  overrides?: {
+    ObjectPattern?: 'always' | 'never';
+    ObjectExpression?: 'always' | 'never';
+    ImportDeclaration?: 'always' | 'never';
+    ImportAttributes?: 'always' | 'never';
+    ExportNamedDeclaration?: 'always' | 'never';
+    ExportAllDeclaration?: 'always' | 'never';
+    TSMappedType?: 'always' | 'never';
+    TSTypeLiteral?: 'always' | 'never';
+    TSInterfaceBody?: 'always' | 'never';
+    TSEnumBody?: 'always' | 'never';
+  };
+  emptyObjects?: 'ignore' | 'always' | 'never';
+}
+type ObjectCurlySpacingRuleOptions = [ObjectCurlySpacingSchema0?, ObjectCurlySpacingSchema1?];
+//#endregion
+//#region rules/object-property-newline/types.d.ts
+
+interface ObjectPropertyNewlineSchema0 {
+  allowAllPropertiesOnSameLine?: boolean;
+}
+type ObjectPropertyNewlineRuleOptions = [ObjectPropertyNewlineSchema0?];
+//#endregion
+//#region rules/one-var-declaration-per-line/types.d.ts
+
+type OneVarDeclarationPerLineSchema0 = 'always' | 'initializations';
+type OneVarDeclarationPerLineRuleOptions = [OneVarDeclarationPerLineSchema0?];
+//#endregion
+//#region rules/operator-linebreak/types.d.ts
+
+type OperatorLinebreakSchema0 = ('after' | 'before' | 'none') | null;
+interface OperatorLinebreakSchema1 {
+  overrides?: {
+    [k: string]: 'after' | 'before' | 'none' | 'ignore';
+  };
+}
+type OperatorLinebreakRuleOptions = [OperatorLinebreakSchema0?, OperatorLinebreakSchema1?];
+//#endregion
+//#region rules/padded-blocks/types.d.ts
+
+type PaddedBlocksSchema0 = ('always' | 'never' | 'start' | 'end') | {
+  blocks?: 'always' | 'never' | 'start' | 'end';
+  switches?: 'always' | 'never' | 'start' | 'end';
+  classes?: 'always' | 'never' | 'start' | 'end';
+};
+interface PaddedBlocksSchema1 {
+  allowSingleLineBlocks?: boolean;
+}
+type PaddedBlocksRuleOptions = [PaddedBlocksSchema0?, PaddedBlocksSchema1?];
+//#endregion
+//#region rules/padding-line-between-statements/types.d.ts
+
+type PaddingType = 'any' | 'never' | 'always';
+type StatementOption = StatementMatcher | [StatementMatcher, ...StatementMatcher[]];
+type StatementMatcher = StatementType | SelectorOption;
+type StatementType = '*' | 'exports' | 'require' | 'directive' | 'iife' | 'block' | 'empty' | 'function' | 'ts-method' | 'break' | 'case' | 'class' | 'continue' | 'debugger' | 'default' | 'do' | 'for' | 'if' | 'import' | 'switch' | 'throw' | 'try' | 'while' | 'with' | 'cjs-export' | 'cjs-import' | 'enum' | 'interface' | 'function-overload' | 'block-like' | 'singleline-block-like' | 'multiline-block-like' | 'expression' | 'singleline-expression' | 'multiline-expression' | 'return' | 'singleline-return' | 'multiline-return' | 'export' | 'singleline-export' | 'multiline-export' | 'var' | 'singleline-var' | 'multiline-var' | 'let' | 'singleline-let' | 'multiline-let' | 'const' | 'singleline-const' | 'multiline-const' | 'using' | 'singleline-using' | 'multiline-using' | 'type' | 'singleline-type' | 'multiline-type';
+type PaddingLineBetweenStatementsSchema0 = {
+  blankLine: PaddingType;
+  prev: StatementOption;
+  next: StatementOption;
+}[];
+interface SelectorOption {
+  selector: string;
+  lineMode?: 'any' | 'singleline' | 'multiline';
+}
+type PaddingLineBetweenStatementsRuleOptions = PaddingLineBetweenStatementsSchema0;
+//#endregion
+//#region rules/quote-props/types.d.ts
+
+type QuotePropsSchema0 = [] | ['always' | 'as-needed' | 'consistent' | 'consistent-as-needed'] | [] | ['always' | 'as-needed' | 'consistent' | 'consistent-as-needed'] | [('always' | 'as-needed' | 'consistent' | 'consistent-as-needed'), {
+  keywords?: boolean;
+  unnecessary?: boolean;
+  numbers?: boolean;
+}];
+type QuotePropsRuleOptions = QuotePropsSchema0;
+//#endregion
+//#region rules/quotes/types.d.ts
+
+type QuotesSchema0 = 'single' | 'double' | 'backtick';
+type QuotesSchema1 = 'avoid-escape' | {
+  avoidEscape?: boolean;
+  allowTemplateLiterals?: boolean | ('never' | 'avoidEscape' | 'always');
+  ignoreStringLiterals?: boolean;
+};
+type QuotesRuleOptions = [QuotesSchema0?, QuotesSchema1?];
+//#endregion
+//#region rules/rest-spread-spacing/types.d.ts
+
+type RestSpreadSpacingSchema0 = 'always' | 'never';
+type RestSpreadSpacingRuleOptions = [RestSpreadSpacingSchema0?];
+//#endregion
+//#region rules/semi-spacing/types.d.ts
+
+interface SemiSpacingSchema0 {
+  before?: boolean;
+  after?: boolean;
+}
+type SemiSpacingRuleOptions = [SemiSpacingSchema0?];
+//#endregion
+//#region rules/semi-style/types.d.ts
+
+type SemiStyleSchema0 = 'last' | 'first';
+type SemiStyleRuleOptions = [SemiStyleSchema0?];
+//#endregion
+//#region rules/semi/types.d.ts
+
+type SemiSchema0 = [] | ['never'] | ['never', {
+  beforeStatementContinuationChars?: 'always' | 'any' | 'never';
+}] | [] | ['always'] | ['always', {
+  omitLastInOneLineBlock?: boolean;
+  omitLastInOneLineClassBody?: boolean;
+}];
+type SemiRuleOptions = SemiSchema0;
+//#endregion
+//#region rules/space-before-blocks/types.d.ts
+
+type SpaceBeforeBlocksSchema0 = ('always' | 'never') | {
+  keywords?: 'always' | 'never' | 'off';
+  functions?: 'always' | 'never' | 'off';
+  classes?: 'always' | 'never' | 'off';
+  modules?: 'always' | 'never' | 'off';
+};
+type SpaceBeforeBlocksRuleOptions = [SpaceBeforeBlocksSchema0?];
+//#endregion
+//#region rules/space-before-function-paren/types.d.ts
+
+type SpaceBeforeFunctionParenSchema0 = ('always' | 'never') | {
+  anonymous?: 'always' | 'never' | 'ignore';
+  named?: 'always' | 'never' | 'ignore';
+  asyncArrow?: 'always' | 'never' | 'ignore';
+  catch?: 'always' | 'never' | 'ignore';
+};
+type SpaceBeforeFunctionParenRuleOptions = [SpaceBeforeFunctionParenSchema0?];
+//#endregion
+//#region rules/space-in-parens/types.d.ts
+
+type SpaceInParensSchema0 = 'always' | 'never';
+interface SpaceInParensSchema1 {
+  exceptions?: ('{}' | '[]' | '()' | 'empty')[];
+}
+type SpaceInParensRuleOptions = [SpaceInParensSchema0?, SpaceInParensSchema1?];
+//#endregion
+//#region rules/space-infix-ops/types.d.ts
+
+interface SpaceInfixOpsSchema0 {
+  int32Hint?: boolean;
+  ignoreTypes?: boolean;
+}
+type SpaceInfixOpsRuleOptions = [SpaceInfixOpsSchema0?];
+//#endregion
+//#region rules/space-unary-ops/types.d.ts
+
+interface SpaceUnaryOpsSchema0 {
+  words?: boolean;
+  nonwords?: boolean;
+  overrides?: {
+    [k: string]: boolean;
+  };
+}
+type SpaceUnaryOpsRuleOptions = [SpaceUnaryOpsSchema0?];
+//#endregion
+//#region rules/spaced-comment/types.d.ts
+
+type SpacedCommentSchema0 = 'always' | 'never';
+interface SpacedCommentSchema1 {
+  exceptions?: string[];
+  markers?: string[];
+  line?: {
+    exceptions?: string[];
+    markers?: string[];
+  };
+  block?: {
+    exceptions?: string[];
+    markers?: string[];
+    balanced?: boolean;
+  };
+}
+type SpacedCommentRuleOptions = [SpacedCommentSchema0?, SpacedCommentSchema1?];
+//#endregion
+//#region rules/switch-colon-spacing/types.d.ts
+
+interface SwitchColonSpacingSchema0 {
+  before?: boolean;
+  after?: boolean;
+}
+type SwitchColonSpacingRuleOptions = [SwitchColonSpacingSchema0?];
+//#endregion
+//#region rules/template-curly-spacing/types.d.ts
+
+type TemplateCurlySpacingSchema0 = 'always' | 'never';
+type TemplateCurlySpacingRuleOptions = [TemplateCurlySpacingSchema0?];
+//#endregion
+//#region rules/template-tag-spacing/types.d.ts
+
+type TemplateTagSpacingSchema0 = 'always' | 'never';
+type TemplateTagSpacingRuleOptions = [TemplateTagSpacingSchema0?];
+//#endregion
+//#region rules/type-annotation-spacing/types.d.ts
+
+interface TypeAnnotationSpacingSchema0 {
+  before?: boolean;
+  after?: boolean;
+  overrides?: {
+    colon?: SpacingConfig;
+    arrow?: 'ignore' | SpacingConfig;
+    variable?: SpacingConfig;
+    parameter?: SpacingConfig;
+    property?: SpacingConfig;
+    returnType?: SpacingConfig;
+  };
+}
+interface SpacingConfig {
+  before?: boolean;
+  after?: boolean;
+}
+type TypeAnnotationSpacingRuleOptions = [TypeAnnotationSpacingSchema0?];
+//#endregion
+//#region rules/type-generic-spacing/types.d.ts
+
+type TypeGenericSpacingRuleOptions = [];
+//#endregion
+//#region rules/type-named-tuple-spacing/types.d.ts
+
+type TypeNamedTupleSpacingRuleOptions = [];
+//#endregion
+//#region rules/wrap-iife/types.d.ts
+
+type WrapIifeSchema0 = 'outside' | 'inside' | 'any';
+interface WrapIifeSchema1 {
+  functionPrototypeMethods?: boolean;
+}
+type WrapIifeRuleOptions = [WrapIifeSchema0?, WrapIifeSchema1?];
+//#endregion
+//#region rules/wrap-regex/types.d.ts
+
+type WrapRegexRuleOptions = [];
+//#endregion
+//#region rules/yield-star-spacing/types.d.ts
+
+type YieldStarSpacingSchema0 = ('before' | 'after' | 'both' | 'neither') | {
+  before?: boolean;
+  after?: boolean;
+};
+type YieldStarSpacingRuleOptions = [YieldStarSpacingSchema0?];
+
+interface UnprefixedRuleOptions {
+  /**
+   * Enforce linebreaks after opening and before closing array brackets
+   * @see https://eslint.style/rules/array-bracket-newline
+   */
+  'array-bracket-newline': ArrayBracketNewlineRuleOptions;
+  /**
+   * Enforce consistent spacing inside array brackets
+   * @see https://eslint.style/rules/array-bracket-spacing
+   */
+  'array-bracket-spacing': ArrayBracketSpacingRuleOptions;
+  /**
+   * Enforce line breaks after each array element
+   * @see https://eslint.style/rules/array-element-newline
+   */
+  'array-element-newline': ArrayElementNewlineRuleOptions;
+  /**
+   * Require parentheses around arrow function arguments
+   * @see https://eslint.style/rules/arrow-parens
+   */
+  'arrow-parens': ArrowParensRuleOptions;
+  /**
+   * Enforce consistent spacing before and after the arrow in arrow functions
+   * @see https://eslint.style/rules/arrow-spacing
+   */
+  'arrow-spacing': ArrowSpacingRuleOptions;
+  /**
+   * Disallow or enforce spaces inside of blocks after opening block and before closing block
+   * @see https://eslint.style/rules/block-spacing
+   */
+  'block-spacing': BlockSpacingRuleOptions;
+  /**
+   * Enforce consistent brace style for blocks
+   * @see https://eslint.style/rules/brace-style
+   */
+  'brace-style': BraceStyleRuleOptions;
+  /**
+   * Require or disallow trailing commas
+   * @see https://eslint.style/rules/comma-dangle
+   */
+  'comma-dangle': CommaDangleRuleOptions;
+  /**
+   * Enforce consistent spacing before and after commas
+   * @see https://eslint.style/rules/comma-spacing
+   */
+  'comma-spacing': CommaSpacingRuleOptions;
+  /**
+   * Enforce consistent comma style
+   * @see https://eslint.style/rules/comma-style
+   */
+  'comma-style': CommaStyleRuleOptions;
+  /**
+   * Enforce consistent spacing inside computed property brackets
+   * @see https://eslint.style/rules/computed-property-spacing
+   */
+  'computed-property-spacing': ComputedPropertySpacingRuleOptions;
+  /**
+   * Enforce consistent line breaks after opening and before closing braces
+   * @see https://eslint.style/rules/curly-newline
+   */
+  'curly-newline': CurlyNewlineRuleOptions;
+  /**
+   * Enforce consistent newlines before and after dots
+   * @see https://eslint.style/rules/dot-location
+   */
+  'dot-location': DotLocationRuleOptions;
+  /**
+   * Require or disallow newline at the end of files
+   * @see https://eslint.style/rules/eol-last
+   */
+  'eol-last': EolLastRuleOptions;
+  /**
+   * Enforce line breaks between arguments of a function call
+   * @see https://eslint.style/rules/function-call-argument-newline
+   */
+  'function-call-argument-newline': FunctionCallArgumentNewlineRuleOptions;
+  /**
+   * Require or disallow spacing between function identifiers and their invocations
+   * @see https://eslint.style/rules/function-call-spacing
+   */
+  'function-call-spacing': FunctionCallSpacingRuleOptions;
+  /**
+   * Enforce consistent line breaks inside function parentheses
+   * @see https://eslint.style/rules/function-paren-newline
+   */
+  'function-paren-newline': FunctionParenNewlineRuleOptions;
+  /**
+   * Enforce consistent spacing around `*` operators in generator functions
+   * @see https://eslint.style/rules/generator-star-spacing
+   */
+  'generator-star-spacing': GeneratorStarSpacingRuleOptions;
+  /**
+   * Enforce the location of arrow function bodies
+   * @see https://eslint.style/rules/implicit-arrow-linebreak
+   */
+  'implicit-arrow-linebreak': ImplicitArrowLinebreakRuleOptions;
+  /**
+   * Enforce consistent indentation
+   * @see https://eslint.style/rules/indent
+   */
+  'indent': IndentRuleOptions$1;
+  /**
+   * Indentation for binary operators
+   * @see https://eslint.style/rules/indent-binary-ops
+   */
+  'indent-binary-ops': IndentBinaryOpsRuleOptions;
+  /**
+   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
+   * @see https://eslint.style/rules/jsx-child-element-spacing
+   */
+  'jsx-child-element-spacing': JsxChildElementSpacingRuleOptions;
+  /**
+   * Enforce closing bracket location in JSX
+   * @see https://eslint.style/rules/jsx-closing-bracket-location
+   */
+  'jsx-closing-bracket-location': JsxClosingBracketLocationRuleOptions;
+  /**
+   * Enforce closing tag location for multiline JSX
+   * @see https://eslint.style/rules/jsx-closing-tag-location
+   */
+  'jsx-closing-tag-location': JsxClosingTagLocationRuleOptions;
+  /**
+   * Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
+   * @see https://eslint.style/rules/jsx-curly-brace-presence
+   */
+  'jsx-curly-brace-presence': JsxCurlyBracePresenceRuleOptions;
+  /**
+   * Enforce consistent linebreaks in curly braces in JSX attributes and expressions
+   * @see https://eslint.style/rules/jsx-curly-newline
+   */
+  'jsx-curly-newline': JsxCurlyNewlineRuleOptions;
+  /**
+   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
+   * @see https://eslint.style/rules/jsx-curly-spacing
+   */
+  'jsx-curly-spacing': JsxCurlySpacingRuleOptions;
+  /**
+   * Enforce or disallow spaces around equal signs in JSX attributes
+   * @see https://eslint.style/rules/jsx-equals-spacing
+   */
+  'jsx-equals-spacing': JsxEqualsSpacingRuleOptions;
+  /**
+   * Enforce proper position of the first property in JSX
+   * @see https://eslint.style/rules/jsx-first-prop-new-line
+   */
+  'jsx-first-prop-new-line': JsxFirstPropNewLineRuleOptions;
+  /**
+   * Enforce line breaks before and after JSX elements when they are used as arguments to a function.
+   * @see https://eslint.style/rules/jsx-function-call-newline
+   */
+  'jsx-function-call-newline': JsxFunctionCallNewlineRuleOptions;
+  /**
+   * Enforce JSX indentation. Deprecated, use `indent` rule instead.
+   * @see https://eslint.style/rules/jsx-indent
+   */
+  'jsx-indent': JsxIndentRuleOptions;
+  /**
+   * Enforce props indentation in JSX
+   * @see https://eslint.style/rules/jsx-indent-props
+   */
+  'jsx-indent-props': JsxIndentPropsRuleOptions;
+  /**
+   * Enforce maximum of props on a single line in JSX
+   * @see https://eslint.style/rules/jsx-max-props-per-line
+   */
+  'jsx-max-props-per-line': JsxMaxPropsPerLineRuleOptions;
+  /**
+   * Require or prevent a new line after jsx elements and expressions.
+   * @see https://eslint.style/rules/jsx-newline
+   */
+  'jsx-newline': JsxNewlineRuleOptions;
+  /**
+   * Require one JSX element per line
+   * @see https://eslint.style/rules/jsx-one-expression-per-line
+   */
+  'jsx-one-expression-per-line': JsxOneExpressionPerLineRuleOptions;
+  /**
+   * Enforce PascalCase for user-defined JSX components
+   * @see https://eslint.style/rules/jsx-pascal-case
+   */
+  'jsx-pascal-case': JsxPascalCaseRuleOptions;
+  /**
+   * Disallow multiple spaces between inline JSX props. Deprecated, use `no-multi-spaces` rule instead.
+   * @see https://eslint.style/rules/jsx-props-no-multi-spaces
+   */
+  'jsx-props-no-multi-spaces': JsxPropsNoMultiSpacesRuleOptions;
+  /**
+   * Enforce consistent line break styles for JSX props
+   * @see https://eslint.style/rules/jsx-props-style
+   */
+  'exp-jsx-props-style': JsxPropsStyleRuleOptions;
+  /**
+   * Enforce the consistent use of either double or single quotes in JSX attributes
+   * @see https://eslint.style/rules/jsx-quotes
+   */
+  'jsx-quotes': JsxQuotesRuleOptions;
+  /**
+   * Disallow extra closing tags for components without children
+   * @see https://eslint.style/rules/jsx-self-closing-comp
+   */
+  'jsx-self-closing-comp': JsxSelfClosingCompRuleOptions;
+  /**
+   * Enforce props alphabetical sorting
+   * @see https://eslint.style/rules/jsx-sort-props
+   */
+  'jsx-sort-props': JsxSortPropsRuleOptions;
+  /**
+   * Enforce whitespace in and around the JSX opening and closing brackets
+   * @see https://eslint.style/rules/jsx-tag-spacing
+   */
+  'jsx-tag-spacing': JsxTagSpacingRuleOptions;
+  /**
+   * Disallow missing parentheses around multiline JSX
+   * @see https://eslint.style/rules/jsx-wrap-multilines
+   */
+  'jsx-wrap-multilines': JsxWrapMultilinesRuleOptions;
+  /**
+   * Enforce consistent spacing between property names and type annotations in types and interfaces
+   * @see https://eslint.style/rules/key-spacing
+   */
+  'key-spacing': KeySpacingRuleOptions;
+  /**
+   * Enforce consistent spacing before and after keywords
+   * @see https://eslint.style/rules/keyword-spacing
+   */
+  'keyword-spacing': KeywordSpacingRuleOptions;
+  /**
+   * Enforce position of line comments
+   * @see https://eslint.style/rules/line-comment-position
+   */
+  'line-comment-position': LineCommentPositionRuleOptions;
+  /**
+   * Enforce consistent linebreak style
+   * @see https://eslint.style/rules/linebreak-style
+   */
+  'linebreak-style': LinebreakStyleRuleOptions;
+  /**
+   * Require empty lines around comments
+   * @see https://eslint.style/rules/lines-around-comment
+   */
+  'lines-around-comment': LinesAroundCommentRuleOptions;
+  /**
+   * Require or disallow an empty line between class members
+   * @see https://eslint.style/rules/lines-between-class-members
+   */
+  'lines-between-class-members': LinesBetweenClassMembersRuleOptions;
+  /**
+   * Enforce consistent spacing and line break styles inside brackets.
+   * @see https://eslint.style/rules/list-style
+   */
+  'exp-list-style': ListStyleRuleOptions;
+  /**
+   * Enforce a maximum line length
+   * @see https://eslint.style/rules/max-len
+   */
+  'max-len': MaxLenRuleOptions;
+  /**
+   * Enforce a maximum number of statements allowed per line
+   * @see https://eslint.style/rules/max-statements-per-line
+   */
+  'max-statements-per-line': MaxStatementsPerLineRuleOptions;
+  /**
+   * Require a specific member delimiter style for interfaces and type literals
+   * @see https://eslint.style/rules/member-delimiter-style
+   */
+  'member-delimiter-style': MemberDelimiterStyleRuleOptions;
+  /**
+   * Enforce a particular style for multiline comments
+   * @see https://eslint.style/rules/multiline-comment-style
+   */
+  'multiline-comment-style': MultilineCommentStyleRuleOptions;
+  /**
+   * Enforce newlines between operands of ternary expressions
+   * @see https://eslint.style/rules/multiline-ternary
+   */
+  'multiline-ternary': MultilineTernaryRuleOptions;
+  /**
+   * Enforce or disallow parentheses when invoking a constructor with no arguments
+   * @see https://eslint.style/rules/new-parens
+   */
+  'new-parens': NewParensRuleOptions;
+  /**
+   * Require a newline after each call in a method chain
+   * @see https://eslint.style/rules/newline-per-chained-call
+   */
+  'newline-per-chained-call': NewlinePerChainedCallRuleOptions;
+  /**
+   * Disallow arrow functions where they could be confused with comparisons
+   * @see https://eslint.style/rules/no-confusing-arrow
+   */
+  'no-confusing-arrow': NoConfusingArrowRuleOptions;
+  /**
+   * Disallow unnecessary parentheses
+   * @see https://eslint.style/rules/no-extra-parens
+   */
+  'no-extra-parens': NoExtraParensRuleOptions;
+  /**
+   * Disallow unnecessary semicolons
+   * @see https://eslint.style/rules/no-extra-semi
+   */
+  'no-extra-semi': NoExtraSemiRuleOptions;
+  /**
+   * Disallow leading or trailing decimal points in numeric literals
+   * @see https://eslint.style/rules/no-floating-decimal
+   */
+  'no-floating-decimal': NoFloatingDecimalRuleOptions;
+  /**
+   * Disallow mixed binary operators
+   * @see https://eslint.style/rules/no-mixed-operators
+   */
+  'no-mixed-operators': NoMixedOperatorsRuleOptions;
+  /**
+   * Disallow mixed spaces and tabs for indentation
+   * @see https://eslint.style/rules/no-mixed-spaces-and-tabs
+   */
+  'no-mixed-spaces-and-tabs': NoMixedSpacesAndTabsRuleOptions;
+  /**
+   * Disallow multiple spaces
+   * @see https://eslint.style/rules/no-multi-spaces
+   */
+  'no-multi-spaces': NoMultiSpacesRuleOptions;
+  /**
+   * Disallow multiple empty lines
+   * @see https://eslint.style/rules/no-multiple-empty-lines
+   */
+  'no-multiple-empty-lines': NoMultipleEmptyLinesRuleOptions;
+  /**
+   * Disallow all tabs
+   * @see https://eslint.style/rules/no-tabs
+   */
+  'no-tabs': NoTabsRuleOptions;
+  /**
+   * Disallow trailing whitespace at the end of lines
+   * @see https://eslint.style/rules/no-trailing-spaces
+   */
+  'no-trailing-spaces': NoTrailingSpacesRuleOptions;
+  /**
+   * Disallow whitespace before properties
+   * @see https://eslint.style/rules/no-whitespace-before-property
+   */
+  'no-whitespace-before-property': NoWhitespaceBeforePropertyRuleOptions;
+  /**
+   * Enforce the location of single-line statements
+   * @see https://eslint.style/rules/nonblock-statement-body-position
+   */
+  'nonblock-statement-body-position': NonblockStatementBodyPositionRuleOptions;
+  /**
+   * Enforce consistent line breaks after opening and before closing braces
+   * @see https://eslint.style/rules/object-curly-newline
+   */
+  'object-curly-newline': ObjectCurlyNewlineRuleOptions;
+  /**
+   * Enforce consistent spacing inside braces
+   * @see https://eslint.style/rules/object-curly-spacing
+   */
+  'object-curly-spacing': ObjectCurlySpacingRuleOptions;
+  /**
+   * Enforce placing object properties on separate lines
+   * @see https://eslint.style/rules/object-property-newline
+   */
+  'object-property-newline': ObjectPropertyNewlineRuleOptions;
+  /**
+   * Require or disallow newlines around variable declarations
+   * @see https://eslint.style/rules/one-var-declaration-per-line
+   */
+  'one-var-declaration-per-line': OneVarDeclarationPerLineRuleOptions;
+  /**
+   * Enforce consistent linebreak style for operators
+   * @see https://eslint.style/rules/operator-linebreak
+   */
+  'operator-linebreak': OperatorLinebreakRuleOptions;
+  /**
+   * Require or disallow padding within blocks
+   * @see https://eslint.style/rules/padded-blocks
+   */
+  'padded-blocks': PaddedBlocksRuleOptions;
+  /**
+   * Require or disallow padding lines between statements
+   * @see https://eslint.style/rules/padding-line-between-statements
+   */
+  'padding-line-between-statements': PaddingLineBetweenStatementsRuleOptions;
+  /**
+   * Require quotes around object literal, type literal, interfaces and enums property names
+   * @see https://eslint.style/rules/quote-props
+   */
+  'quote-props': QuotePropsRuleOptions;
+  /**
+   * Enforce the consistent use of either backticks, double, or single quotes
+   * @see https://eslint.style/rules/quotes
+   */
+  'quotes': QuotesRuleOptions;
+  /**
+   * Enforce spacing between rest and spread operators and their expressions
+   * @see https://eslint.style/rules/rest-spread-spacing
+   */
+  'rest-spread-spacing': RestSpreadSpacingRuleOptions;
+  /**
+   * Require or disallow semicolons instead of ASI
+   * @see https://eslint.style/rules/semi
+   */
+  'semi': SemiRuleOptions;
+  /**
+   * Enforce consistent spacing before and after semicolons
+   * @see https://eslint.style/rules/semi-spacing
+   */
+  'semi-spacing': SemiSpacingRuleOptions;
+  /**
+   * Enforce location of semicolons
+   * @see https://eslint.style/rules/semi-style
+   */
+  'semi-style': SemiStyleRuleOptions;
+  /**
+   * Enforce consistent spacing before blocks
+   * @see https://eslint.style/rules/space-before-blocks
+   */
+  'space-before-blocks': SpaceBeforeBlocksRuleOptions;
+  /**
+   * Enforce consistent spacing before function parenthesis
+   * @see https://eslint.style/rules/space-before-function-paren
+   */
+  'space-before-function-paren': SpaceBeforeFunctionParenRuleOptions;
+  /**
+   * Enforce consistent spacing inside parentheses
+   * @see https://eslint.style/rules/space-in-parens
+   */
+  'space-in-parens': SpaceInParensRuleOptions;
+  /**
+   * Require spacing around infix operators
+   * @see https://eslint.style/rules/space-infix-ops
+   */
+  'space-infix-ops': SpaceInfixOpsRuleOptions;
+  /**
+   * Enforce consistent spacing before or after unary operators
+   * @see https://eslint.style/rules/space-unary-ops
+   */
+  'space-unary-ops': SpaceUnaryOpsRuleOptions;
+  /**
+   * Enforce consistent spacing after the `//` or `/*` in a comment
+   * @see https://eslint.style/rules/spaced-comment
+   */
+  'spaced-comment': SpacedCommentRuleOptions;
+  /**
+   * Enforce spacing around colons of switch statements
+   * @see https://eslint.style/rules/switch-colon-spacing
+   */
+  'switch-colon-spacing': SwitchColonSpacingRuleOptions;
+  /**
+   * Require or disallow spacing around embedded expressions of template strings
+   * @see https://eslint.style/rules/template-curly-spacing
+   */
+  'template-curly-spacing': TemplateCurlySpacingRuleOptions;
+  /**
+   * Require or disallow spacing between template tags and their literals
+   * @see https://eslint.style/rules/template-tag-spacing
+   */
+  'template-tag-spacing': TemplateTagSpacingRuleOptions;
+  /**
+   * Require consistent spacing around type annotations
+   * @see https://eslint.style/rules/type-annotation-spacing
+   */
+  'type-annotation-spacing': TypeAnnotationSpacingRuleOptions;
+  /**
+   * Enforces consistent spacing inside TypeScript type generics
+   * @see https://eslint.style/rules/type-generic-spacing
+   */
+  'type-generic-spacing': TypeGenericSpacingRuleOptions;
+  /**
+   * Expect space before the type declaration in the named tuple
+   * @see https://eslint.style/rules/type-named-tuple-spacing
+   */
+  'type-named-tuple-spacing': TypeNamedTupleSpacingRuleOptions;
+  /**
+   * Require parentheses around immediate `function` invocations
+   * @see https://eslint.style/rules/wrap-iife
+   */
+  'wrap-iife': WrapIifeRuleOptions;
+  /**
+   * Require parenthesis around regex literals
+   * @see https://eslint.style/rules/wrap-regex
+   */
+  'wrap-regex': WrapRegexRuleOptions;
+  /**
+   * Require or disallow spacing around the `*` in `yield*` expressions
+   * @see https://eslint.style/rules/yield-star-spacing
+   */
+  'yield-star-spacing': YieldStarSpacingRuleOptions;
+}
+
+//#region dts/options.d.ts
+type IndentRuleOptions = UnprefixedRuleOptions['indent'];
+interface StylisticCustomizeOptions {
+  /**
+   * The name of the registered plugin, used to prefix rule IDs
+   * @default '@stylistic'
+   */
+  pluginName?: string;
+  /**
+   * Indentation level
+   * Similar to the `tabWidth` and `useTabs` options in Prettier
+   *
+   * @default 2
+   */
+  indent?: IndentRuleOptions[0] | IndentRuleOptions;
+  /**
+   * Quote style
+   * Similar to `singleQuote` option in Prettier
+   *
+   * @default 'single'
+   */
+  quotes?: 'single' | 'double' | 'backtick';
+  /**
+   * Whether to enable semicolons
+   * Similar to `semi` option in Prettier
+   *
+   * @default false
+   */
+  semi?: boolean;
+  /**
+   * Enable JSX support
+   * @default true
+   */
+  jsx?: boolean;
+  /**
+   * When to enable arrow parenthesis
+   * Similar to `arrowParens` option in Prettier
+   *
+   * @default false
+   */
+  arrowParens?: boolean;
+  /**
+   * Which brace style to use
+   * @default 'stroustrup'
+   */
+  braceStyle?: '1tbs' | 'stroustrup' | 'allman';
+  /**
+   * Whether to require spaces around braces
+   * Similar to `bracketSpacing` option in Prettier
+   *
+   * @default true
+   */
+  blockSpacing?: boolean;
+  /**
+   * When to enable prop quoting
+   * Similar to `quoteProps` option in Prettier
+   *
+   * @default 'consistent-as-needed'
+   */
+  quoteProps?: 'always' | 'as-needed' | 'consistent' | 'consistent-as-needed';
+  /**
+   * When to enable comma dangles
+   * Similar to `trailingComma` option in Prettier
+   *
+   * @default 'always-multiline'
+   */
+  commaDangle?: 'never' | 'always' | 'always-multiline' | 'only-multiline';
+  /**
+   * Severity level of the rules
+   * Determines how violations are reported.
+   *
+   * @default 'error'
+   */
+  severity?: 'error' | 'warn';
+  /**
+   * Enable the experimental rules
+   *
+   * @default false
+   */
+  experimental?: boolean;
+}
+
+interface ToolingOptions {
+    /**
+     * Enable RegExp rules
+     *
+     * @see https://github.com/ota-meshi/eslint-plugin-regexp
+     * @default true
+     */
+    regexp?: boolean;
+    /**
+     * Enable Unicorn rules
+     *
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn
+     * @default true
+     */
+    unicorn?: boolean;
+    /**
+     * Enable jsdoc rules
+     *
+     * @default true
+     */
+    jsdoc?: boolean;
+}
+interface NuxtSpecificOptions {
+    /**
+     * Sort keys in nuxt.config to maintain a consistent order
+     *
+     * @default true when `features.stylistic` is enabled
+     */
+    sortConfigKeys?: boolean;
+}
+interface NuxtESLintFeaturesOptions {
+    /**
+     * Setup basic JavaScript, TypeScript and Vue plugins and rules.
+     *
+     * You might want to disable it when you are using other ESLint config that handles the basic setup.
+     *
+     * @default true
+     */
+    standalone?: boolean;
+    /**
+     * Enable rules for Nuxt module authors or library authors
+     *
+     * @experimental Changes might not follow semver
+     * @default false
+     */
+    tooling?: boolean | ToolingOptions;
+    /**
+     * Enable the import plugin
+     *
+     * @default true
+     */
+    import?: boolean | ImportPluginOptions;
+    /**
+     * Enable stylistic ESLint rules for formatting and code style check
+     *
+     * @see https://eslint.style/guide/config-presets
+     * @default false
+     */
+    stylistic?: boolean | StylisticCustomizeOptions;
+    /**
+     * Enable formatters to handling formatting for different file types
+     *
+     * Requires `eslint-plugin-format` to be installed
+     *
+     * @default false
+     */
+    formatters?: boolean | OptionsFormatters;
+    /**
+     * Options for Nuxt specific rules
+     */
+    nuxt?: NuxtSpecificOptions;
+    /**
+     * Enable TypeScript support. Can also be an object to config the options.
+     *
+     * By default it enables automatic when `typescript` is installed in the project.
+     */
+    typescript?: boolean | {
+        /**
+         * Enable strict rules
+         * @see https://typescript-eslint.io/users/configs#strict
+         * @default true
+         */
+        strict?: boolean;
+        /**
+         * Path to the tsconfig file, when this is provide, type-aware rules will be enabled.
+         */
+        tsconfigPath?: string;
+    };
+}
+interface ImportPluginOptions {
+    /**
+     * The import plugin to use
+     *
+     * @default 'eslint-plugin-import-x'
+     */
+    package?: 'eslint-plugin-import-lite' | 'eslint-plugin-import-x';
+}
+interface NuxtESLintConfigOptions {
+    features?: NuxtESLintFeaturesOptions;
+    dirs?: {
+        /**
+         * Nuxt source directory
+         */
+        src?: string[];
+        /**
+         * Root directory for nuxt project
+         */
+        root?: string[];
+        /**
+         * Directory for pages
+         */
+        pages?: string[];
+        /**
+         * Directory for layouts
+         */
+        layouts?: string[];
+        /**
+         * Directory for components
+         */
+        components?: string[];
+        /**
+         * Directory for components with prefix
+         * Ignore `vue/multi-word-component-names`
+         */
+        componentsPrefixed?: string[];
+        /**
+         * Directory for composobles
+         */
+        composables?: string[];
+        /**
+         * Directory for plugins
+         */
+        plugins?: string[];
+        /**
+         * Directory for modules
+         */
+        modules?: string[];
+        /**
+         * Directory for middleware
+         */
+        middleware?: string[];
+        /**
+         * Directory for server
+         */
+        servers?: string[];
+    };
+}
+interface OptionsFormatters {
+    /**
+     * Enable formatting support for CSS, Less, Sass, and SCSS.
+     *
+     * Currently only support Prettier.
+     */
+    css?: 'prettier' | boolean;
+    /**
+     * Enable formatting support for HTML.
+     *
+     * Currently only support Prettier.
+     */
+    html?: 'prettier' | boolean;
+    /**
+     * Enable formatting support for XML.
+     *
+     * Currently only support Prettier.
+     */
+    xml?: 'prettier' | boolean;
+    /**
+     * Enable formatting support for SVG.
+     *
+     * Currently only support Prettier.
+     */
+    svg?: 'prettier' | boolean;
+    /**
+     * Enable formatting support for Markdown.
+     *
+     * Support both Prettier and dprint.
+     *
+     * When set to `true`, it will use Prettier.
+     */
+    markdown?: 'prettier' | 'dprint' | boolean;
+    /**
+     * Enable formatting support for GraphQL.
+     */
+    graphql?: 'prettier' | boolean;
+    /**
+     * Custom options for Prettier.
+     *
+     * By default it's controlled by our own config.
+     */
+    prettierOptions?: any;
+    /**
+     * Custom options for dprint.
+     *
+     * By default it's controlled by our own config.
+     */
+    dprintOptions?: boolean;
+}
+/**
+ * Create an array of ESLint flat configs for Nuxt 3, based on the given options.
+ * Accepts appending user configs as rest arguments from the second argument.
+ *
+ * For Nuxt apps, it's recommended to use `@nuxt/eslint` module instead, which will generate the necessary configuration based on your project.
+ * @see https://eslint.nuxt.com/packages/module
+ */
+declare function createConfigForNuxt(options?: NuxtESLintConfigOptions, ...userConfigs: ResolvableFlatConfig[]): FlatConfigComposer;
+
 interface PluginConfigs extends Record<
   string,
   Linter.LegacyConfig | Linter.Config[] | Linter.Config
@@ -46,6 +3917,15 @@ var eslint_config = antfu(
     unocss: true,
     vue: { a11y: true }
   },
+  // Antfu changes (keep them minimal)
+  {
+    rules: {
+      "antfu/no-top-level-await": "off",
+      "node/prefer-global/process": "off",
+      "pnpm/yaml-enforce-settings": "off",
+      "ts/no-use-before-define": "off"
+    }
+  },
   ...storybook.configs["flat/recommended"],
   turbo.configs["flat/recommended"],
   zod.configs.recommended,
@@ -91,7 +3971,7 @@ var eslint_config = antfu(
       }],
       "yaml/sort-sequence-values": ["error", {
         order: { type: "asc" },
-        pathPattern: "^services(?:\\.[^.\\[\\]]+|\\[[^\\]]+\\])\\.(?:depends_on|environment|volumes)$"
+        pathPattern: "^services(?:\\.[^.\\[\\]]+|\\[[^\\]]+\\])\\.(?:depends_on|environment|ports|volumes)$"
       }]
     }
   },
@@ -102,17 +3982,9 @@ var eslint_config = antfu(
     files: ["**/package.json"],
     rules: { "jsonc/sort-keys": "off" }
   },
-  // SaaS Makers
+  // ESLint
   {
-    plugins: { saasmakers },
     rules: {
-      // Override rules defined by Antfu ESLint config
-      // Try to keep the disabled rules to a minimum
-      "antfu/no-top-level-await": "off",
-      "node/prefer-global/process": "off",
-      "pnpm/yaml-enforce-settings": "off",
-      "ts/no-use-before-define": "off",
-      // ESLint
       "object-property-newline": ["error", { allowAllPropertiesOnSameLine: false }],
       "object-curly-newline": ["error", {
         ExportDeclaration: {
@@ -125,8 +3997,14 @@ var eslint_config = antfu(
           multiline: true
         },
         ObjectPattern: "never"
-      }],
-      // Perfectionist
+      }]
+    }
+  },
+  // Nuxt
+  createConfigForNuxt({ features: { standalone: false } }),
+  // Perfectionist
+  {
+    rules: {
       ..._default.configs["recommended-natural"].rules,
       "perfectionist/sort-imports": ["error", {
         newlinesBetween: 0,
@@ -140,11 +4018,14 @@ var eslint_config = antfu(
         partitionByComment: true,
         partitionByNewLine: true,
         type: "natural"
-      }],
-      // SaaS Makers
-      "saasmakers/ts-sort-tests": "error"
+      }]
     }
   },
+  // SaaS Makers
+  {
+    plugins: { saasmakers },
+    rules: { "saasmakers/ts-sort-tests": "error" }
+  },
   // Vitest
   {
     files: ["**/*.test.ts"],