/* tslint:disable */
/* eslint-disable */
interface SupportsFeatureParams {
    features: FeatureName;
    inlineConfig?: Configuration;
    /**
     * Features that shouldn't be enabled
     */
    notRequestedFeatures?: FeatureName;
    path: BiomePath;
    projectKey: ProjectKey;
    skipIgnoreCheck?: boolean;
}
type FeatureName = FeatureKind[];
interface Configuration {
    /**
     * A field for the JSON schema specification: https://json-schema.org/
     */
    $schema?: Schema;
    /**
     * Specific configuration for assists
     */
    assist?: AssistConfiguration;
    /**
     * Specific configuration for the Css language
     */
    css?: CssConfiguration;
    /**
     * A list of paths to other JSON files, used to extend the current configuration.
     */
    extends?: Extends;
    /**
     * The configuration of the filesystem
     */
    files?: FilesConfiguration;
    /**
     * The configuration of the formatter
     */
    formatter?: FormatterConfiguration;
    /**
     * Specific configuration for the GraphQL language
     */
    graphql?: GraphqlConfiguration;
    /**
     * Specific configuration for the GraphQL language
     */
    grit?: GritConfiguration;
    /**
     * Specific configuration for the HTML language
     */
    html?: HtmlConfiguration;
    /**
     * Specific configuration for the JavaScript language
     */
    javascript?: JsConfiguration;
    /**
     * Specific configuration for the Json language
     */
    json?: JsonConfiguration;
    /**
     * The configuration for the linter
     */
    linter?: LinterConfiguration;
    /**
     * A list of granular patterns that should be applied only to a sub set of files
     */
    overrides?: Overrides;
    /**
     * List of plugins to load.
     */
    plugins?: Plugins;
    /**
     * Indicates whether this configuration file is at the root of a Biome
    project. By default, this is `true`.
     */
    root?: Bool;
    /**
     * The configuration of the VCS integration
     */
    vcs?: VcsConfiguration;
}
type BiomePath = string;
type ProjectKey = number;
type FeatureKind =
| "format"
| "lint"
| "search"
| "assist"
| "debug"
| "htmlFullSupport";
type Schema = string;
interface AssistConfiguration {
    /**
     * Whether Biome should fail in CLI if the assist were not applied to the code.
     */
    actions?: Actions;
    /**
     * Whether Biome should enable assist via LSP and CLI.
     */
    enabled?: Bool;
    /**
     * A list of glob patterns. Biome will include files/folders that will
    match these patterns.
     */
    includes?: NormalizedGlob[];
}
interface CssConfiguration {
    /**
     * CSS assist options
     */
    assist?: CssAssistConfiguration;
    /**
     * CSS formatter options
     */
    formatter?: CssFormatterConfiguration;
    /**
     * CSS globals
     */
    globals?: string[];
    /**
     * CSS linter options
     */
    linter?: CssLinterConfiguration;
    /**
     * CSS parsing options
     */
    parser?: CssParserConfiguration;
}
type Extends = string[] | string;
interface FilesConfiguration {
    /**
     * **Deprecated:** Please use _force-ignore syntax_ in `files.includes`
    instead: <https://biomejs.dev/reference/configuration/#filesincludes>

    Set of file and folder names that should be unconditionally ignored by
    Biome's scanner.
     */
    experimentalScannerIgnores?: string[];
    /**
     * Tells Biome to not emit diagnostics when handling files that it doesn't know
     */
    ignoreUnknown?: Bool;
    /**
     * A list of glob patterns. Biome will handle only those files/folders that will
    match these patterns.
     */
    includes?: NormalizedGlob[];
    /**
     * The maximum allowed size for source code files in bytes. Files above
    this limit will be ignored for performance reasons. Defaults to 1 MiB
     */
    maxSize?: MaxSize;
}
interface FormatterConfiguration {
    /**
     * The attribute position style in HTML-ish languages. Defaults to auto.
     */
    attributePosition?: AttributePosition;
    /**
     * Put the `>` of a multi-line HTML or JSX element at the end of the last line instead of being alone on the next line (does not apply to self closing elements).
     */
    bracketSameLine?: BracketSameLine;
    /**
     * Whether to insert spaces around brackets in object literals. Defaults to true.
     */
    bracketSpacing?: BracketSpacing;
    /**
     * Whether to insert spaces inside delimiters (after the opening delimiter and before the
    closing delimiter), such as parentheses, brackets, angle brackets, and template literal
    interpolations. Spaces are not added before the opening delimiter, and empty delimiters
    are not affected. Only applies when the content fits on a single line. The specific
    delimiters affected depend on the language. Defaults to false.
     */
    delimiterSpacing?: DelimiterSpacing;
    enabled?: Bool;
    /**
     * Whether to expand arrays and objects on multiple lines.
    When set to `auto`, object literals are formatted on multiple lines if the first property has a newline,
    and array literals are formatted on a single line if it fits in the line.
    When set to `always`, these literals are formatted on multiple lines, regardless of length of the list.
    When set to `never`, these literals are formatted on a single line if it fits in the line.
    When formatting `package.json`, Biome will use `always` unless configured otherwise. Defaults to "auto".
     */
    expand?: Expand;
    /**
     * Whether formatting should be allowed to proceed if a given file
    has syntax errors
     */
    formatWithErrors?: Bool;
    /**
     * A list of glob patterns. The formatter will include files/folders that will
    match these patterns.
     */
    includes?: NormalizedGlob[];
    /**
     * The indent style.
     */
    indentStyle?: IndentStyle;
    /**
     * The size of the indentation, 2 by default
     */
    indentWidth?: IndentWidth;
    /**
     * The type of line ending.
     */
    lineEnding?: LineEnding;
    /**
     * What's the max width of a line. Defaults to 80.
     */
    lineWidth?: LineWidth;
    /**
     * Whether to add a trailing newline at the end of the file.

    Setting this option to `false` is **highly discouraged** because it could cause many problems with other tools:
    - https://thoughtbot.com/blog/no-newline-at-end-of-file
    - https://callmeryan.medium.com/no-newline-at-end-of-file-navigating-gits-warning-for-android-developers-af14e73dd804
    - https://unix.stackexchange.com/questions/345548/how-to-cat-files-together-adding-missing-newlines-at-end-of-some-files

    Disable the option at your own risk.

    Defaults to true.
     */
    trailingNewline?: TrailingNewline;
    /**
     * Use any `.editorconfig` files to configure the formatter. Configuration
    in `biome.json` will override `.editorconfig` configuration.

    Default: `false`.
     */
    useEditorconfig?: Bool;
}
interface GraphqlConfiguration {
    /**
     * Assist options
     */
    assist?: GraphqlAssistConfiguration;
    /**
     * GraphQL formatter options
     */
    formatter?: GraphqlFormatterConfiguration;
    linter?: GraphqlLinterConfiguration;
}
interface GritConfiguration {
    /**
     * Assist options
     */
    assist?: GritAssistConfiguration;
    /**
     * Formatting options
     */
    formatter?: GritFormatterConfiguration;
    /**
     * Formatting options
     */
    linter?: GritLinterConfiguration;
}
interface HtmlConfiguration {
    assist?: HtmlAssistConfiguration;
    /**
     * Enables full support for HTML, Vue, Svelte and Astro files.
     */
    experimentalFullSupportEnabled?: Bool;
    /**
     * HTML formatter options
     */
    formatter?: HtmlFormatterConfiguration;
    /**
     * HTML linter options
     */
    linter?: HtmlLinterConfiguration;
    /**
     * HTML parsing options
     */
    parser?: HtmlParserConfiguration;
}
interface JsConfiguration {
    /**
     * Assist options
     */
    assist?: JsAssistConfiguration;
    /**
     * Enables support for embedding snippets.
     */
    experimentalEmbeddedSnippetsEnabled?: Bool;
    /**
     * Formatting options
     */
    formatter?: JsFormatterConfiguration;
    /**
     * A list of global bindings that should be ignored by the analyzers

    If defined here, they should not emit diagnostics.
     */
    globals?: string[];
    /**
     * Indicates the type of runtime or transformation used for interpreting JSX.
     */
    jsxRuntime?: JsxRuntime;
    /**
     * Linter options
     */
    linter?: JsLinterConfiguration;
    /**
     * Parsing options
     */
    parser?: JsParserConfiguration;
    /**
     * Module/dependency resolver options
     */
    resolver?: JsResolverConfiguration;
}
interface JsonConfiguration {
    /**
     * Assist options
     */
    assist?: JsonAssistConfiguration;
    /**
     * Formatting options
     */
    formatter?: JsonFormatterConfiguration;
    /**
     * Linting options
     */
    linter?: JsonLinterConfiguration;
    /**
     * Parsing options
     */
    parser?: JsonParserConfiguration;
}
interface LinterConfiguration {
    /**
     * An object where the keys are the names of the domains, and the values are `all`, `recommended`, or `none`.
     */
    domains?: RuleDomains;
    /**
     * if `false`, it disables the feature and the linter won't be executed. `true` by default
     */
    enabled?: Bool;
    /**
     * A list of glob patterns. The analyzer will handle only those files/folders that will
    match these patterns.
     */
    includes?: NormalizedGlob[];
    /**
     * List of rules
     */
    rules?: Rules;
}
type Overrides = OverridePattern[];
type Plugins = PluginConfiguration[];
type Bool = boolean;
interface VcsConfiguration {
    /**
     * The kind of client.
     */
    clientKind?: VcsClientKind;
    /**
     * The main branch of the project
     */
    defaultBranch?: string;
    /**
     * Whether Biome should integrate itself with the VCS client
     */
    enabled?: Bool;
    /**
     * The folder where Biome should check for VCS files. By default, Biome will use the same
    folder where `biome.json` was found.

    If Biome can't find the configuration, it will attempt to use the current working directory.
    If no current working directory can't be found, Biome won't use the VCS integration, and a diagnostic
    will be emitted
     */
    root?: string;
    /**
     * Whether Biome should use VCS ignore files. When [true], Biome will ignore files
    specified in `.gitignore`, `.ignore`, and Git's local exclude file.
     */
    useIgnoreFile?: Bool;
}
interface Actions {
    /**
     * The actions preset to use.
     */
    preset?: PresetConfig;
    /**
     * It enables the assist actions recommended by Biome. `true` by default.
     */
    recommended?: boolean;
    source?: Source;
}
type NormalizedGlob = string;
interface CssAssistConfiguration {
    /**
     * Control the assist for CSS files.
     */
    enabled?: Bool;
}
interface CssFormatterConfiguration {
    /**
     * Whether to insert spaces inside delimiters (after the opening delimiter and before the
    closing delimiter). Only applies when the content fits on a single line, and empty
    delimiters are not affected. For CSS, affects parentheses (e.g., `rgb( 0, 0, 0 )`) and
    square brackets (e.g., `[ data-attr ]`). Defaults to false.
     */
    delimiterSpacing?: DelimiterSpacing;
    /**
     * Control the formatter for CSS (and its super languages) files.
     */
    enabled?: Bool;
    /**
     * The indent style applied to CSS (and its super languages) files.
     */
    indentStyle?: IndentStyle;
    /**
     * The size of the indentation applied to CSS (and its super languages) files. Default to 2.
     */
    indentWidth?: IndentWidth;
    /**
     * The type of line ending applied to CSS (and its super languages) files. `auto` uses CRLF on Windows and LF on other platforms.
     */
    lineEnding?: LineEnding;
    /**
     * What's the max width of a line applied to CSS (and its super languages) files. Defaults to 80.
     */
    lineWidth?: LineWidth;
    /**
     * The type of quotes used in CSS code. Defaults to double.
     */
    quoteStyle?: QuoteStyle;
    /**
     * Whether to add a trailing newline at the end of the file.

    Setting this option to `false` is **highly discouraged** because it could cause many problems with other tools:
    - https://thoughtbot.com/blog/no-newline-at-end-of-file
    - https://callmeryan.medium.com/no-newline-at-end-of-file-navigating-gits-warning-for-android-developers-af14e73dd804
    - https://unix.stackexchange.com/questions/345548/how-to-cat-files-together-adding-missing-newlines-at-end-of-some-files

    Disable the option at your own risk.

    Defaults to true.
     */
    trailingNewline?: TrailingNewline;
}
interface CssLinterConfiguration {
    /**
     * Control the linter for CSS files.
     */
    enabled?: Bool;
}
interface CssParserConfiguration {
    /**
     * Allow comments to appear on incorrect lines in `.css` files
     */
    allowWrongLineComments?: Bool;
    /**
     * Enables parsing of CSS Modules specific features. Enable this feature only
    when your files don't end in `.module.css`.
     */
    cssModules?: Bool;
    /**
     * Enables parsing of Tailwind CSS 4.0 directives and functions.
     */
    tailwindDirectives?: Bool;
}
type MaxSize = number;
type AttributePosition = "auto" | "multiline";
type BracketSameLine = boolean;
type BracketSpacing = boolean;
type DelimiterSpacing = boolean;
type Expand = "auto" | "always" | "never";
type IndentStyle = "tab" | "space";
type IndentWidth = number;
type LineEnding = "lf" | "crlf" | "cr" | "auto";
type LineWidth = number;
type TrailingNewline = boolean;
interface GraphqlAssistConfiguration {
    /**
     * Control the formatter for GraphQL files.
     */
    enabled?: Bool;
}
interface GraphqlFormatterConfiguration {
    /**
     * Whether to insert spaces around brackets in object literals. Defaults to true.
     */
    bracketSpacing?: BracketSpacing;
    /**
     * Control the formatter for GraphQL files.
     */
    enabled?: Bool;
    /**
     * The indent style applied to GraphQL files.
     */
    indentStyle?: IndentStyle;
    /**
     * The size of the indentation applied to GraphQL files. Default to 2.
     */
    indentWidth?: IndentWidth;
    /**
     * The type of line ending applied to GraphQL files. `auto` uses CRLF on Windows and LF on other platforms.
     */
    lineEnding?: LineEnding;
    /**
     * What's the max width of a line applied to GraphQL files. Defaults to 80.
     */
    lineWidth?: LineWidth;
    /**
     * The type of quotes used in GraphQL code. Defaults to double.
     */
    quoteStyle?: QuoteStyle;
    /**
     * Whether to add a trailing newline at the end of the file.

    Setting this option to `false` is **highly discouraged** because it could cause many problems with other tools:
    - https://thoughtbot.com/blog/no-newline-at-end-of-file
    - https://callmeryan.medium.com/no-newline-at-end-of-file-navigating-gits-warning-for-android-developers-af14e73dd804
    - https://unix.stackexchange.com/questions/345548/how-to-cat-files-together-adding-missing-newlines-at-end-of-some-files

    Disable the option at your own risk.

    Defaults to true.
     */
    trailingNewline?: TrailingNewline;
}
interface GraphqlLinterConfiguration {
    /**
     * Control the formatter for GraphQL files.
     */
    enabled?: Bool;
}
interface GritAssistConfiguration {
    /**
     * Control the assist functionality for Grit files.
     */
    enabled?: Bool;
}
interface GritFormatterConfiguration {
    /**
     * Control the formatter for Grit files.
     */
    enabled?: Bool;
    /**
     * The indent style applied to Grit files.
     */
    indentStyle?: IndentStyle;
    /**
     * The size of the indentation applied to Grit files. Default to 2.
     */
    indentWidth?: IndentWidth;
    /**
     * The type of line ending applied to Grit files.
     */
    lineEnding?: LineEnding;
    /**
     * What's the max width of a line applied to Grit files. Defaults to 80.
     */
    lineWidth?: LineWidth;
    /**
     * Whether to add a trailing newline at the end of the file.

    Setting this option to `false` is **highly discouraged** because it could cause many problems with other tools:
    - https://thoughtbot.com/blog/no-newline-at-end-of-file
    - https://callmeryan.medium.com/no-newline-at-end-of-file-navigating-gits-warning-for-android-developers-af14e73dd804
    - https://unix.stackexchange.com/questions/345548/how-to-cat-files-together-adding-missing-newlines-at-end-of-some-files

    Disable the option at your own risk.

    Defaults to true.
     */
    trailingNewline?: TrailingNewline;
}
interface GritLinterConfiguration {
    /**
     * Control the linter for Grit files.
     */
    enabled?: Bool;
}
interface HtmlAssistConfiguration {
    /**
     * Control the assist for HTML (and its super languages) files.
     */
    enabled?: Bool;
}
interface HtmlFormatterConfiguration {
    /**
     * The attribute position style in HTML elements. Defaults to auto.
     */
    attributePosition?: AttributePosition;
    /**
     * Whether to hug the closing bracket of multiline HTML tags to the end of the last line, rather than being alone on the following line. Defaults to false.
     */
    bracketSameLine?: BracketSameLine;
    /**
     * Control the formatter for HTML (and its super languages) files.
     */
    enabled?: Bool;
    /**
     * Whether to indent the `<script>` and `<style>` tags for HTML (and its super languages). Defaults to false.
     */
    indentScriptAndStyle?: IndentScriptAndStyle;
    /**
     * The indent style applied to HTML (and its super languages) files.
     */
    indentStyle?: IndentStyle;
    /**
     * The size of the indentation applied to HTML (and its super languages) files. Default to 2.
     */
    indentWidth?: IndentWidth;
    /**
     * The type of line ending applied to HTML (and its super languages) files. `auto` uses CRLF on Windows and LF on other platforms.
     */
    lineEnding?: LineEnding;
    /**
     * What's the max width of a line applied to HTML (and its super languages) files. Defaults to 80.
     */
    lineWidth?: LineWidth;
    /**
     * Whether void elements should be self-closed. Defaults to never.
     */
    selfCloseVoidElements?: SelfCloseVoidElements;
    /**
     * Whether to add a trailing newline at the end of the file.

    Setting this option to `false` is **highly discouraged** because it could cause many problems with other tools:
    - https://thoughtbot.com/blog/no-newline-at-end-of-file
    - https://callmeryan.medium.com/no-newline-at-end-of-file-navigating-gits-warning-for-android-developers-af14e73dd804
    - https://unix.stackexchange.com/questions/345548/how-to-cat-files-together-adding-missing-newlines-at-end-of-some-files

    Disable the option at your own risk.

    Defaults to true.
     */
    trailingNewline?: TrailingNewline;
    /**
     * Whether to account for whitespace sensitivity when formatting HTML (and its super languages). Defaults to "css".
     */
    whitespaceSensitivity?: WhitespaceSensitivity;
}
interface HtmlLinterConfiguration {
    /**
     * Control the linter for HTML (and its super languages) files.
     */
    enabled?: Bool;
}
interface HtmlParserConfiguration {
    /**
     * Enables the parsing of double text expressions such as `{{ expression }}` inside `.html` files
     */
    interpolation?: Bool;
    /**
     * Enables parsing of Vue syntax (v-if, v-bind, etc.) in `.html` files. If this option is enabled, it also enables `interpolation` implicitly.

    Biome will already automatically enable Vue parsing in `.vue` files, so you probably don't need
    to enable this option. This only affects `.html` files, and does not change how `.vue`, `.svelte`,
    or `.astro` files are parsed.
     */
    vue?: Bool;
}
interface JsAssistConfiguration {
    /**
     * Control the assist for JavaScript (and its super languages) files.
     */
    enabled?: Bool;
}
interface JsFormatterConfiguration {
    /**
     * Whether to add non-necessary parentheses to arrow functions. Defaults to "always".
     */
    arrowParentheses?: ArrowParentheses;
    /**
     * The attribute position style in JSX elements. Defaults to auto.
     */
    attributePosition?: AttributePosition;
    /**
     * Whether to hug the closing bracket of multiline HTML/JSX tags to the end of the last line, rather than being alone on the following line. Defaults to false.
     */
    bracketSameLine?: BracketSameLine;
    /**
     * Whether to insert spaces around brackets in object literals. Defaults to true.
     */
    bracketSpacing?: BracketSpacing;
    /**
     * Whether to insert spaces inside delimiters (after the opening delimiter and before the
    closing delimiter). Only applies when the content fits on a single line. Spaces are not
    added before the opening delimiter (e.g., `function f()` stays `function f()`, not
    `function f ()`), and empty delimiters are not affected (e.g., `fn()` stays `fn()`).
    For JavaScript and TypeScript, affects parentheses (e.g., `foo( a, b )`), square brackets
    (e.g., `[ a, b ]`), template literal interpolations (e.g., `${ expr }`), TypeScript angle
    brackets (e.g., `foo< T >()`), JSX expression braces (e.g., `{ value }`), and the logical
    NOT operator (e.g., `! x`, but in chains only after the last one: `!! x`). Defaults to
    false.
     */
    delimiterSpacing?: DelimiterSpacing;
    /**
     * Control the formatter for JavaScript (and its super languages) files.
     */
    enabled?: Bool;
    /**
     * Whether to expand arrays and objects on multiple lines.
    When set to `auto`, object literals are formatted on multiple lines if the first property has a newline,
    and array literals are formatted on a single line if it fits in the line.
    When set to `always`, these literals are formatted on multiple lines, regardless of length of the list.
    When set to `never`, these literals are formatted on a single line if it fits in the line.
    When formatting `package.json`, Biome will use `always` unless configured otherwise. Defaults to "auto".
     */
    expand?: Expand;
    /**
     * The indent style applied to JavaScript (and its super languages) files.
     */
    indentStyle?: IndentStyle;
    /**
     * The size of the indentation applied to JavaScript (and its super languages) files. Default to 2.
     */
    indentWidth?: IndentWidth;
    /**
     * The type of quotes used in JSX. Defaults to double.
     */
    jsxQuoteStyle?: QuoteStyle;
    /**
     * The type of line ending applied to JavaScript (and its super languages) files. `auto` uses CRLF on Windows and LF on other platforms.
     */
    lineEnding?: LineEnding;
    /**
     * What's the max width of a line applied to JavaScript (and its super languages) files. Defaults to 80.
     */
    lineWidth?: LineWidth;
    /**
     * When breaking binary expressions into multiple lines, whether to break them before or after the binary operator. Defaults to "after".
     */
    operatorLinebreak?: OperatorLinebreak;
    /**
     * When properties in objects are quoted. Defaults to asNeeded.
     */
    quoteProperties?: QuoteProperties;
    /**
     * The type of quotes used in JavaScript code. Defaults to double.
     */
    quoteStyle?: QuoteStyle;
    /**
     * Whether the formatter prints semicolons for all statements or only in for statements where it is necessary because of ASI.
     */
    semicolons?: Semicolons;
    /**
     * Print trailing commas wherever possible in multi-line comma-separated syntactic structures. Defaults to "all".
     */
    trailingCommas?: JsTrailingCommas;
    /**
     * Whether to add a trailing newline at the end of the file.

    Setting this option to `false` is **highly discouraged** because it could cause many problems with other tools:
    - https://thoughtbot.com/blog/no-newline-at-end-of-file
    - https://callmeryan.medium.com/no-newline-at-end-of-file-navigating-gits-warning-for-android-developers-af14e73dd804
    - https://unix.stackexchange.com/questions/345548/how-to-cat-files-together-adding-missing-newlines-at-end-of-some-files

    Disable the option at your own risk.

    Defaults to true.
     */
    trailingNewline?: TrailingNewline;
}
type JsxRuntime = "transparent" | "reactClassic";
interface JsLinterConfiguration {
    /**
     * Control the linter for JavaScript (and its super languages) files.
     */
    enabled?: Bool;
}
interface JsParserConfiguration {
    /**
     * Enables parsing of Grit metavariables.
    Defaults to `false`.
     */
    gritMetavariables?: Bool;
    /**
     * When enabled, files like `.js`/`.mjs`/`.cjs` may contain JSX syntax.

    Defaults to `true`.
     */
    jsxEverywhere?: Bool;
    /**
     * It enables the experimental and unsafe parsing of parameter decorators

    These decorators belong to an old proposal, and they are subject to change.
     */
    unsafeParameterDecoratorsEnabled?: Bool;
}
interface JsResolverConfiguration {
    /**
     * Enables pnpm workspace catalog resolution for JavaScript package manifests.

    Opt-in:
    - Set `javascript.resolver.experimentalPnpmCatalogs` to `true`.

    Scope:
    - Resolves `catalog:` and `catalog:<name>` dependency versions from
    `package.json`.
    - Applies to `dependencies`, `devDependencies`, and `peerDependencies`.

    Fail-safe behavior:
    - If `pnpm-workspace.yaml` is missing, unreadable, or cannot be parsed,
    Biome silently falls back to the default behavior (as if this option
    were disabled).
    - Unknown keys and unsupported value shapes in `pnpm-workspace.yaml` are
    ignored.

    Limitations:
    - Only `pnpm-workspace.yaml` is read.
    - Biome only reads top-level `catalog` / `catalogs` mappings and scalar
    string entries.

    Default: `false`.
     */
    experimentalPnpmCatalogs?: Bool;
}
interface JsonAssistConfiguration {
    /**
     * Control the assist for JSON (and its super languages) files.
     */
    enabled?: Bool;
}
interface JsonFormatterConfiguration {
    /**
     * Whether to insert spaces around brackets in object literals. Defaults to true.
     */
    bracketSpacing?: BracketSpacing;
    /**
     * Whether to insert spaces inside delimiters (after the opening delimiter and before the
    closing delimiter). Only applies when the content fits on a single line, and empty
    brackets are not affected. For JSON, affects square brackets (e.g., `[ 1, 2, 3 ]`).
    Defaults to false.
     */
    delimiterSpacing?: DelimiterSpacing;
    /**
     * Control the formatter for JSON (and its super languages) files.
     */
    enabled?: Bool;
    /**
     * Whether to expand arrays and objects on multiple lines.
    When set to `auto`, object literals are formatted on multiple lines if the first property has a newline,
    and array literals are formatted on a single line if it fits in the line.
    When set to `always`, these literals are formatted on multiple lines, regardless of length of the list.
    When set to `never`, these literals are formatted on a single line if it fits in the line.
    When formatting `package.json`, Biome will use `always` unless configured otherwise. Defaults to "auto".
     */
    expand?: Expand;
    /**
     * The indent style applied to JSON (and its super languages) files.
     */
    indentStyle?: IndentStyle;
    /**
     * The size of the indentation applied to JSON (and its super languages) files. Default to 2.
     */
    indentWidth?: IndentWidth;
    /**
     * The type of line ending applied to JSON (and its super languages) files. `auto` uses CRLF on Windows and LF on other platforms.
     */
    lineEnding?: LineEnding;
    /**
     * What's the max width of a line applied to JSON (and its super languages) files. Defaults to 80.
     */
    lineWidth?: LineWidth;
    /**
     * Print trailing commas wherever possible in multi-line comma-separated syntactic structures. Defaults to "none".
     */
    trailingCommas?: JsonTrailingCommas;
    /**
     * Whether to add a trailing newline at the end of the file.

    Setting this option to `false` is **highly discouraged** because it could cause many problems with other tools:
    - https://thoughtbot.com/blog/no-newline-at-end-of-file
    - https://callmeryan.medium.com/no-newline-at-end-of-file-navigating-gits-warning-for-android-developers-af14e73dd804
    - https://unix.stackexchange.com/questions/345548/how-to-cat-files-together-adding-missing-newlines-at-end-of-some-files

    Disable the option at your own risk.

    Defaults to true.
     */
    trailingNewline?: TrailingNewline;
}
interface JsonLinterConfiguration {
    /**
     * Control the linter for JSON (and its super languages) files.
     */
    enabled?: Bool;
}
interface JsonParserConfiguration {
    /**
     * Allow parsing comments in `.json` files
     */
    allowComments?: Bool;
    /**
     * Allow parsing trailing commas in `.json` files
     */
    allowTrailingCommas?: Bool;
}
type RuleDomains = { [K in RuleDomain]?: RuleDomainValue };
interface Rules {
    a11y?: SeverityOrA11y;
    complexity?: SeverityOrComplexity;
    correctness?: SeverityOrCorrectness;
    nursery?: SeverityOrNursery;
    performance?: SeverityOrPerformance;
    /**
     * The rule presets to use.
     */
    preset?: PresetConfig;
    /**
     * It enables the lint rules recommended by Biome. `true` by default.
     */
    recommended?: boolean;
    security?: SeverityOrSecurity;
    style?: SeverityOrStyle;
    suspicious?: SeverityOrSuspicious;
}
interface OverridePattern {
    /**
     * Specific configuration for the Json language
     */
    assist?: OverrideAssistConfiguration;
    /**
     * Specific configuration for the CSS language
     */
    css?: CssConfiguration;
    /**
     * Specific configuration for the filesystem
     */
    files?: OverrideFilesConfiguration;
    /**
     * Specific configuration for the Json language
     */
    formatter?: OverrideFormatterConfiguration;
    /**
     * Specific configuration for the Graphql language
     */
    graphql?: GraphqlConfiguration;
    /**
     * Specific configuration for the GritQL language
     */
    grit?: GritConfiguration;
    /**
     * Specific configuration for the GritQL language
     */
    html?: HtmlConfiguration;
    /**
     * A list of glob patterns. Biome will include files/folders that will
    match these patterns.
     */
    includes?: OverrideGlobs;
    /**
     * Specific configuration for the JavaScript language
     */
    javascript?: JsConfiguration;
    /**
     * Specific configuration for the Json language
     */
    json?: JsonConfiguration;
    /**
     * Specific configuration for the Json language
     */
    linter?: OverrideLinterConfiguration;
    /**
     * Specific configuration for additional plugins
     */
    plugins?: Plugins;
}
type PluginConfiguration = string | PluginWithOptions;
type VcsClientKind = "git";
type PresetConfig = "recommended" | "all" | "none";
interface Source {
    /**
     * Remove duplicate CSS classes.
    See https://biomejs.dev/assist/actions/no-duplicate-classes
     */
    noDuplicateClasses?: NoDuplicateClassesConfiguration;
    /**
     * Sorts imports and exports in your JavaScript and TypeScript files.
    See https://biomejs.dev/assist/actions/organize-imports
     */
    organizeImports?: OrganizeImportsConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
    /**
     * Enforce attribute sorting in HTML elements.
    See https://biomejs.dev/assist/actions/use-sorted-attributes
     */
    useSortedAttributes?: UseSortedAttributesConfiguration;
    /**
     * Sort the members of an enum in natural order.
    See https://biomejs.dev/assist/actions/use-sorted-enum-members
     */
    useSortedEnumMembers?: UseSortedEnumMembersConfiguration;
    /**
     * Sort interface members by key.
    See https://biomejs.dev/assist/actions/use-sorted-interface-members
     */
    useSortedInterfaceMembers?: UseSortedInterfaceMembersConfiguration;
    /**
     * Sort the keys of a JSON object in natural order.
    See https://biomejs.dev/assist/actions/use-sorted-keys
     */
    useSortedKeys?: UseSortedKeysConfiguration;
    /**
     * Organize package.json fields according to established conventions.
    See https://biomejs.dev/assist/actions/use-sorted-package-json
     */
    useSortedPackageJson?: UseSortedPackageJsonConfiguration;
    /**
     * Enforce ordering of CSS properties and nested rules.
    See https://biomejs.dev/assist/actions/use-sorted-properties
     */
    useSortedProperties?: UseSortedPropertiesConfiguration;
    /**
     * Sort GraphQL selection sets.
    See https://biomejs.dev/assist/actions/use-sorted-selection-set
     */
    useSortedSelectionSet?: UseSortedSelectionSetConfiguration;
    /**
     * Sort fields in GraphQL type definitions alphabetically.
    See https://biomejs.dev/assist/actions/use-sorted-type-fields
     */
    useSortedTypeFields?: UseSortedTypeFieldsConfiguration;
}
type QuoteStyle = "double" | "single";
type IndentScriptAndStyle = boolean;
type SelfCloseVoidElements = "never" | "always";
type WhitespaceSensitivity = "css" | "strict" | "ignore";
type ArrowParentheses = "always" | "asNeeded";
type OperatorLinebreak = "after" | "before";
type QuoteProperties = "asNeeded" | "preserve";
type Semicolons = "always" | "asNeeded";
type JsTrailingCommas = "all" | "es5" | "none";
type JsonTrailingCommas = "none" | "all";
type RuleDomain =
| "drizzle"
| "react"
| "reactNative"
| "test"
| "solid"
| "next"
| "qwik"
| "svelte"
| "vue"
| "project"
| "tailwind"
| "turborepo"
| "playwright"
| "types";
type RuleDomainValue = "all" | "none" | "recommended";
type SeverityOrA11y = GroupPlainConfiguration | A11y;
type SeverityOrComplexity = GroupPlainConfiguration | Complexity;
type SeverityOrCorrectness = GroupPlainConfiguration | Correctness;
type SeverityOrNursery = GroupPlainConfiguration | Nursery;
type SeverityOrPerformance = GroupPlainConfiguration | Performance;
type SeverityOrSecurity = GroupPlainConfiguration | Security;
type SeverityOrStyle = GroupPlainConfiguration | Style;
type SeverityOrSuspicious = GroupPlainConfiguration | Suspicious;
interface OverrideAssistConfiguration {
    /**
     * List of actions
     */
    actions?: Actions;
    /**
     * if `false`, it disables the feature and the assist won't be executed. `true` by default
     */
    enabled?: Bool;
}
interface OverrideFilesConfiguration {
    /**
     * File size limit in bytes
     */
    maxSize?: MaxSize;
}
interface OverrideFormatterConfiguration {
    /**
     * The attribute position style.
     */
    attributePosition?: AttributePosition;
    /**
     * Put the `>` of a multi-line HTML or JSX element at the end of the last line instead of being alone on the next line (does not apply to self closing elements).
     */
    bracketSameLine?: BracketSameLine;
    /**
     * Whether to insert spaces around brackets in object literals. Defaults to true.
     */
    bracketSpacing?: BracketSpacing;
    /**
     * Whether to insert spaces inside delimiters (after the opening delimiter and before the
    closing delimiter), such as parentheses, brackets, angle brackets, and template literal
    interpolations. Spaces are not added before the opening delimiter, and empty delimiters
    are not affected. Only applies when the content fits on a single line. The specific
    delimiters affected depend on the language. Defaults to false.
     */
    delimiterSpacing?: DelimiterSpacing;
    enabled?: Bool;
    /**
     * Whether to expand arrays and objects on multiple lines.
    When set to `auto`, object literals are formatted on multiple lines if the first property has a newline,
    and array literals are formatted on a single line if it fits in the line.
    When set to `always`, these literals are formatted on multiple lines, regardless of length of the list.
    When set to `never`, these literals are formatted on a single line if it fits in the line.
    When formatting `package.json`, Biome will use `always` unless configured otherwise. Defaults to "auto".
     */
    expand?: Expand;
    /**
     * Stores whether formatting should be allowed to proceed if a given file
    has syntax errors
     */
    formatWithErrors?: Bool;
    /**
     * The size of the indentation, 2 by default (deprecated, use `indent-width`)
     */
    indentSize?: IndentWidth;
    /**
     * The indent style.
     */
    indentStyle?: IndentStyle;
    /**
     * The size of the indentation, 2 by default
     */
    indentWidth?: IndentWidth;
    /**
     * The type of line ending.
     */
    lineEnding?: LineEnding;
    /**
     * What's the max width of a line. Defaults to 80.
     */
    lineWidth?: LineWidth;
    /**
     * Print trailing commas wherever possible in multi-line comma-separated syntactic structures.
     */
    trailingCommas?: JsTrailingCommas;
    /**
     * Whether to add a trailing newline at the end of the file.

    Setting this option to `false` is **highly discouraged** because it could cause many problems with other tools:
    - https://thoughtbot.com/blog/no-newline-at-end-of-file
    - https://callmeryan.medium.com/no-newline-at-end-of-file-navigating-gits-warning-for-android-developers-af14e73dd804
    - https://unix.stackexchange.com/questions/345548/how-to-cat-files-together-adding-missing-newlines-at-end-of-some-files

    Disable the option at your own risk.

    Defaults to true.
     */
    trailingNewline?: TrailingNewline;
}
type OverrideGlobs = Glob[];
interface OverrideLinterConfiguration {
    /**
     * List of rules
     */
    domains?: RuleDomains;
    /**
     * if `false`, it disables the feature and the linter won't be executed. `true` by default
     */
    enabled?: Bool;
    /**
     * List of rules
     */
    rules?: Rules;
}
interface PluginWithOptions {
    /**
     * A list of glob patterns. The plugin will only run on files matching
    these patterns. Use negated globs (e.g., `!**\/*.test.ts`) for exclusions.
     */
    includes?: NormalizedGlob[];
    /**
     * The path to the plugin.
     */
    path: string;
}
type NoDuplicateClassesConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithNoDuplicateClassesOptions;
type OrganizeImportsConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithOrganizeImportsOptions;
type UseSortedAttributesConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithUseSortedAttributesOptions;
type UseSortedEnumMembersConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithUseSortedEnumMembersOptions;
type UseSortedInterfaceMembersConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithUseSortedInterfaceMembersOptions;
type UseSortedKeysConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithUseSortedKeysOptions;
type UseSortedPackageJsonConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithUseSortedPackageJsonOptions;
type UseSortedPropertiesConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithUseSortedPropertiesOptions;
type UseSortedSelectionSetConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithUseSortedSelectionSetOptions;
type UseSortedTypeFieldsConfiguration =
| RuleAssistPlainConfiguration
| RuleAssistWithUseSortedTypeFieldsOptions;
type GroupPlainConfiguration = "off" | "on" | "info" | "warn" | "error";
interface A11y {
    /**
     * Enforce that the accesskey attribute is not used on any HTML element.
    See https://biomejs.dev/linter/rules/no-access-key
     */
    noAccessKey?: NoAccessKeyConfiguration;
    /**
     * Disallow ambiguous anchor descriptions.
    See https://biomejs.dev/linter/rules/no-ambiguous-anchor-text
     */
    noAmbiguousAnchorText?: NoAmbiguousAnchorTextConfiguration;
    /**
     * Enforce that aria-hidden="true" is not set on focusable elements.
    See https://biomejs.dev/linter/rules/no-aria-hidden-on-focusable
     */
    noAriaHiddenOnFocusable?: NoAriaHiddenOnFocusableConfiguration;
    /**
     * Enforce that elements that do not support ARIA roles, states, and properties do not have those attributes.
    See https://biomejs.dev/linter/rules/no-aria-unsupported-elements
     */
    noAriaUnsupportedElements?: NoAriaUnsupportedElementsConfiguration;
    /**
     * Enforce that the autofocus attribute is not used on elements.
    See https://biomejs.dev/linter/rules/no-autofocus
     */
    noAutofocus?: NoAutofocusConfiguration;
    /**
     * Enforces that no distracting elements are used.
    See https://biomejs.dev/linter/rules/no-distracting-elements
     */
    noDistractingElements?: NoDistractingElementsConfiguration;
    /**
     * The scope prop should be used only on \<th> elements.
    See https://biomejs.dev/linter/rules/no-header-scope
     */
    noHeaderScope?: NoHeaderScopeConfiguration;
    /**
     * Enforce that non-interactive ARIA roles are not assigned to interactive HTML elements.
    See https://biomejs.dev/linter/rules/no-interactive-element-to-noninteractive-role
     */
    noInteractiveElementToNoninteractiveRole?: NoInteractiveElementToNoninteractiveRoleConfiguration;
    /**
     * Enforce that a label element or component has a text label and an associated input.
    See https://biomejs.dev/linter/rules/no-label-without-control
     */
    noLabelWithoutControl?: NoLabelWithoutControlConfiguration;
    /**
     * Disallow use event handlers on non-interactive elements.
    See https://biomejs.dev/linter/rules/no-noninteractive-element-interactions
     */
    noNoninteractiveElementInteractions?: NoNoninteractiveElementInteractionsConfiguration;
    /**
     * Enforce that interactive ARIA roles are not assigned to non-interactive HTML elements.
    See https://biomejs.dev/linter/rules/no-noninteractive-element-to-interactive-role
     */
    noNoninteractiveElementToInteractiveRole?: NoNoninteractiveElementToInteractiveRoleConfiguration;
    /**
     * Enforce that tabindex is not assigned to non-interactive HTML elements.
    See https://biomejs.dev/linter/rules/no-noninteractive-tabindex
     */
    noNoninteractiveTabindex?: NoNoninteractiveTabindexConfiguration;
    /**
     * Prevent the usage of positive integers on tabindex attribute.
    See https://biomejs.dev/linter/rules/no-positive-tabindex
     */
    noPositiveTabindex?: NoPositiveTabindexConfiguration;
    /**
     * Enforce img alt prop does not contain the word "image", "picture", or "photo".
    See https://biomejs.dev/linter/rules/no-redundant-alt
     */
    noRedundantAlt?: NoRedundantAltConfiguration;
    /**
     * Enforce explicit role property is not the same as implicit/default role property on an element.
    See https://biomejs.dev/linter/rules/no-redundant-roles
     */
    noRedundantRoles?: NoRedundantRolesConfiguration;
    /**
     * Enforce that static, visible elements (such as \<div>) that have click handlers use the valid role attribute.
    See https://biomejs.dev/linter/rules/no-static-element-interactions
     */
    noStaticElementInteractions?: NoStaticElementInteractionsConfiguration;
    /**
     * Enforces the usage of the title element for the svg element.
    See https://biomejs.dev/linter/rules/no-svg-without-title
     */
    noSvgWithoutTitle?: NoSvgWithoutTitleConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
    /**
     * Enforce that all elements that require alternative text have meaningful information to relay back to the end user.
    See https://biomejs.dev/linter/rules/use-alt-text
     */
    useAltText?: UseAltTextConfiguration;
    /**
     * Enforce that anchors have content and that the content is accessible to screen readers.
    See https://biomejs.dev/linter/rules/use-anchor-content
     */
    useAnchorContent?: UseAnchorContentConfiguration;
    /**
     * Enforce that tabindex is assigned to non-interactive HTML elements with aria-activedescendant.
    See https://biomejs.dev/linter/rules/use-aria-activedescendant-with-tabindex
     */
    useAriaActivedescendantWithTabindex?: UseAriaActivedescendantWithTabindexConfiguration;
    /**
     * Enforce that elements with ARIA roles must have all required ARIA attributes for that role.
    See https://biomejs.dev/linter/rules/use-aria-props-for-role
     */
    useAriaPropsForRole?: UseAriaPropsForRoleConfiguration;
    /**
     * Enforce that ARIA properties are valid for the roles that are supported by the element.
    See https://biomejs.dev/linter/rules/use-aria-props-supported-by-role
     */
    useAriaPropsSupportedByRole?: UseAriaPropsSupportedByRoleConfiguration;
    /**
     * Enforces the usage and validity of the attribute type for the element button.
    See https://biomejs.dev/linter/rules/use-button-type
     */
    useButtonType?: UseButtonTypeConfiguration;
    /**
     * Elements with an interactive role and interaction handlers must be focusable.
    See https://biomejs.dev/linter/rules/use-focusable-interactive
     */
    useFocusableInteractive?: UseFocusableInteractiveConfiguration;
    /**
     * Disallow a missing generic family keyword within font families.
    See https://biomejs.dev/linter/rules/use-generic-font-names
     */
    useGenericFontNames?: UseGenericFontNamesConfiguration;
    /**
     * Enforce that heading elements (h1, h2, etc.) have content and that the content is accessible to screen readers.
    See https://biomejs.dev/linter/rules/use-heading-content
     */
    useHeadingContent?: UseHeadingContentConfiguration;
    /**
     * Enforce that html element has lang attribute.
    See https://biomejs.dev/linter/rules/use-html-lang
     */
    useHtmlLang?: UseHtmlLangConfiguration;
    /**
     * Enforces the usage of the attribute title for the element iframe.
    See https://biomejs.dev/linter/rules/use-iframe-title
     */
    useIframeTitle?: UseIframeTitleConfiguration;
    /**
     * Enforce elements with a click event handler to also have at least one keyboard event handler.
    See https://biomejs.dev/linter/rules/use-key-with-click-events
     */
    useKeyWithClickEvents?: UseKeyWithClickEventsConfiguration;
    /**
     * Enforce that onmouseover is accompanied by onfocus and onmouseout by onblur.
    See https://biomejs.dev/linter/rules/use-key-with-mouse-events
     */
    useKeyWithMouseEvents?: UseKeyWithMouseEventsConfiguration;
    /**
     * Enforces that audio and video elements must have a track for captions.
    See https://biomejs.dev/linter/rules/use-media-caption
     */
    useMediaCaption?: UseMediaCaptionConfiguration;
    /**
     * Enforces using semantic DOM elements over the ARIA role property.
    See https://biomejs.dev/linter/rules/use-semantic-elements
     */
    useSemanticElements?: UseSemanticElementsConfiguration;
    /**
     * Enforce that all anchors are valid, and they are navigable elements.
    See https://biomejs.dev/linter/rules/use-valid-anchor
     */
    useValidAnchor?: UseValidAnchorConfiguration;
    /**
     * Ensures that ARIA properties aria-* are all valid.
    See https://biomejs.dev/linter/rules/use-valid-aria-props
     */
    useValidAriaProps?: UseValidAriaPropsConfiguration;
    /**
     * Elements with ARIA roles must use a valid, non-abstract ARIA role.
    See https://biomejs.dev/linter/rules/use-valid-aria-role
     */
    useValidAriaRole?: UseValidAriaRoleConfiguration;
    /**
     * Enforce that ARIA state and property values are valid.
    See https://biomejs.dev/linter/rules/use-valid-aria-values
     */
    useValidAriaValues?: UseValidAriaValuesConfiguration;
    /**
     * Use valid values for the autocomplete attribute on input elements.
    See https://biomejs.dev/linter/rules/use-valid-autocomplete
     */
    useValidAutocomplete?: UseValidAutocompleteConfiguration;
    /**
     * Ensure that the attribute passed to the lang attribute is a correct ISO language and/or country.
    See https://biomejs.dev/linter/rules/use-valid-lang
     */
    useValidLang?: UseValidLangConfiguration;
}
interface Complexity {
    /**
     * Disallow unclear usage of consecutive space characters in regular expression literals.
    See https://biomejs.dev/linter/rules/no-adjacent-spaces-in-regex
     */
    noAdjacentSpacesInRegex?: NoAdjacentSpacesInRegexConfiguration;
    /**
     * Disallow the use of arguments.
    See https://biomejs.dev/linter/rules/no-arguments
     */
    noArguments?: NoArgumentsConfiguration;
    /**
     * Disallow primitive type aliases and misleading types.
    See https://biomejs.dev/linter/rules/no-banned-types
     */
    noBannedTypes?: NoBannedTypesConfiguration;
    /**
     * Disallow comma operator.
    See https://biomejs.dev/linter/rules/no-comma-operator
     */
    noCommaOperator?: NoCommaOperatorConfiguration;
    /**
     * Disallow equal signs explicitly at the beginning of regular expressions.
    See https://biomejs.dev/linter/rules/no-div-regex
     */
    noDivRegex?: NoDivRegexConfiguration;
    /**
     * Disallow empty type parameters in type aliases and interfaces.
    See https://biomejs.dev/linter/rules/no-empty-type-parameters
     */
    noEmptyTypeParameters?: NoEmptyTypeParametersConfiguration;
    /**
     * Disallow functions that exceed a given Cognitive Complexity score.
    See https://biomejs.dev/linter/rules/no-excessive-cognitive-complexity
     */
    noExcessiveCognitiveComplexity?: NoExcessiveCognitiveComplexityConfiguration;
    /**
     * Restrict the number of lines of code in a function.
    See https://biomejs.dev/linter/rules/no-excessive-lines-per-function
     */
    noExcessiveLinesPerFunction?: NoExcessiveLinesPerFunctionConfiguration;
    /**
     * This rule enforces a maximum depth to nested describe() in test files.
    See https://biomejs.dev/linter/rules/no-excessive-nested-test-suites
     */
    noExcessiveNestedTestSuites?: NoExcessiveNestedTestSuitesConfiguration;
    /**
     * Disallow unnecessary boolean casts.
    See https://biomejs.dev/linter/rules/no-extra-boolean-cast
     */
    noExtraBooleanCast?: NoExtraBooleanCastConfiguration;
    /**
     * Disallow to use unnecessary callback on flatMap.
    See https://biomejs.dev/linter/rules/no-flat-map-identity
     */
    noFlatMapIdentity?: NoFlatMapIdentityConfiguration;
    /**
     * Prefer for...of statement instead of Array.forEach.
    See https://biomejs.dev/linter/rules/no-for-each
     */
    noForEach?: NoForEachConfiguration;
    /**
     * Encourage use of explicit type conversion functions over their shorthand counterparts.
    See https://biomejs.dev/linter/rules/no-implicit-coercions
     */
    noImplicitCoercions?: NoImplicitCoercionsConfiguration;
    /**
     * Disallow the use of the !important style.
    See https://biomejs.dev/linter/rules/no-important-styles
     */
    noImportantStyles?: NoImportantStylesConfiguration;
    /**
     * Checks if a default export exports the same symbol as a named export.
    See https://biomejs.dev/linter/rules/no-redundant-default-export
     */
    noRedundantDefaultExport?: NoRedundantDefaultExportConfiguration;
    /**
     * This rule reports when a class has no non-static members, such as for a class used exclusively as a static namespace.
    See https://biomejs.dev/linter/rules/no-static-only-class
     */
    noStaticOnlyClass?: NoStaticOnlyClassConfiguration;
    /**
     * Disallow this and super in static contexts.
    See https://biomejs.dev/linter/rules/no-this-in-static
     */
    noThisInStatic?: NoThisInStaticConfiguration;
    /**
     * Disallow unnecessary catch clauses.
    See https://biomejs.dev/linter/rules/no-useless-catch
     */
    noUselessCatch?: NoUselessCatchConfiguration;
    /**
     * Disallow unused catch bindings.
    See https://biomejs.dev/linter/rules/no-useless-catch-binding
     */
    noUselessCatchBinding?: NoUselessCatchBindingConfiguration;
    /**
     * Disallow unnecessary constructors.
    See https://biomejs.dev/linter/rules/no-useless-constructor
     */
    noUselessConstructor?: NoUselessConstructorConfiguration;
    /**
     * Avoid using unnecessary continue.
    See https://biomejs.dev/linter/rules/no-useless-continue
     */
    noUselessContinue?: NoUselessContinueConfiguration;
    /**
     * Disallow empty exports that don't change anything in a module file.
    See https://biomejs.dev/linter/rules/no-useless-empty-export
     */
    noUselessEmptyExport?: NoUselessEmptyExportConfiguration;
    /**
     * Disallow unnecessary escape sequence in regular expression literals.
    See https://biomejs.dev/linter/rules/no-useless-escape-in-regex
     */
    noUselessEscapeInRegex?: NoUselessEscapeInRegexConfiguration;
    /**
     * Disallow unnecessary fragments.
    See https://biomejs.dev/linter/rules/no-useless-fragments
     */
    noUselessFragments?: NoUselessFragmentsConfiguration;
    /**
     * Disallow unnecessary labels.
    See https://biomejs.dev/linter/rules/no-useless-label
     */
    noUselessLabel?: NoUselessLabelConfiguration;
    /**
     * Disallow unnecessary nested block statements.
    See https://biomejs.dev/linter/rules/no-useless-lone-block-statements
     */
    noUselessLoneBlockStatements?: NoUselessLoneBlockStatementsConfiguration;
    /**
     * Disallow renaming import, export, and destructured assignments to the same name.
    See https://biomejs.dev/linter/rules/no-useless-rename
     */
    noUselessRename?: NoUselessRenameConfiguration;
    /**
     * Disallow redundant return statements.
    See https://biomejs.dev/linter/rules/no-useless-return
     */
    noUselessReturn?: NoUselessReturnConfiguration;
    /**
     * Disallow unnecessary concatenation of string or template literals.
    See https://biomejs.dev/linter/rules/no-useless-string-concat
     */
    noUselessStringConcat?: NoUselessStringConcatConfiguration;
    /**
     * Disallow unnecessary String.raw function in template string literals without any escape sequence.
    See https://biomejs.dev/linter/rules/no-useless-string-raw
     */
    noUselessStringRaw?: NoUselessStringRawConfiguration;
    /**
     * Disallow useless case in switch statements.
    See https://biomejs.dev/linter/rules/no-useless-switch-case
     */
    noUselessSwitchCase?: NoUselessSwitchCaseConfiguration;
    /**
     * Disallow ternary operators when simpler alternatives exist.
    See https://biomejs.dev/linter/rules/no-useless-ternary
     */
    noUselessTernary?: NoUselessTernaryConfiguration;
    /**
     * Disallow useless this aliasing.
    See https://biomejs.dev/linter/rules/no-useless-this-alias
     */
    noUselessThisAlias?: NoUselessThisAliasConfiguration;
    /**
     * Disallow using any or unknown as type constraint.
    See https://biomejs.dev/linter/rules/no-useless-type-constraint
     */
    noUselessTypeConstraint?: NoUselessTypeConstraintConfiguration;
    /**
     * Disallow the use of useless undefined.
    See https://biomejs.dev/linter/rules/no-useless-undefined
     */
    noUselessUndefined?: NoUselessUndefinedConfiguration;
    /**
     * Disallow initializing variables to undefined.
    See https://biomejs.dev/linter/rules/no-useless-undefined-initialization
     */
    noUselessUndefinedInitialization?: NoUselessUndefinedInitializationConfiguration;
    /**
     * Disallow the use of void operators, which is not a familiar operator.
    See https://biomejs.dev/linter/rules/no-void
     */
    noVoid?: NoVoidConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
    /**
     * Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result.
    See https://biomejs.dev/linter/rules/use-array-find
     */
    useArrayFind?: UseArrayFindConfiguration;
    /**
     * Use arrow functions over function expressions.
    See https://biomejs.dev/linter/rules/use-arrow-function
     */
    useArrowFunction?: UseArrowFunctionConfiguration;
    /**
     * Use Date.now() to get the number of milliseconds since the Unix Epoch.
    See https://biomejs.dev/linter/rules/use-date-now
     */
    useDateNow?: UseDateNowConfiguration;
    /**
     * Promotes the use of .flatMap() when map().flat() are used together.
    See https://biomejs.dev/linter/rules/use-flat-map
     */
    useFlatMap?: UseFlatMapConfiguration;
    /**
     * Prefer Array#{indexOf,lastIndexOf}() over Array#{findIndex,findLastIndex}() when looking for the index of an item.
    See https://biomejs.dev/linter/rules/use-index-of
     */
    useIndexOf?: UseIndexOfConfiguration;
    /**
     * Enforce the usage of a literal access to properties over computed property access.
    See https://biomejs.dev/linter/rules/use-literal-keys
     */
    useLiteralKeys?: UseLiteralKeysConfiguration;
    /**
     * Enforce a maximum number of parameters in function definitions.
    See https://biomejs.dev/linter/rules/use-max-params
     */
    useMaxParams?: UseMaxParamsConfiguration;
    /**
     * Disallow parseInt() and Number.parseInt() in favor of binary, octal, and hexadecimal literals.
    See https://biomejs.dev/linter/rules/use-numeric-literals
     */
    useNumericLiterals?: UseNumericLiteralsConfiguration;
    /**
     * Enforce using concise optional chain instead of chained logical expressions.
    See https://biomejs.dev/linter/rules/use-optional-chain
     */
    useOptionalChain?: UseOptionalChainConfiguration;
    /**
     * Enforce the use of the regular expression literals instead of the RegExp constructor if possible.
    See https://biomejs.dev/linter/rules/use-regex-literals
     */
    useRegexLiterals?: UseRegexLiteralsConfiguration;
    /**
     * Disallow number literal object member names which are not base 10 or use underscore as separator.
    See https://biomejs.dev/linter/rules/use-simple-number-keys
     */
    useSimpleNumberKeys?: UseSimpleNumberKeysConfiguration;
    /**
     * Discard redundant terms from logical expressions.
    See https://biomejs.dev/linter/rules/use-simplified-logic-expression
     */
    useSimplifiedLogicExpression?: UseSimplifiedLogicExpressionConfiguration;
    /**
     * Enforce the use of while loops instead of for loops when the initializer and update expressions are not needed.
    See https://biomejs.dev/linter/rules/use-while
     */
    useWhile?: UseWhileConfiguration;
}
interface Correctness {
    /**
     * Prevent usage of next/script's beforeInteractive strategy outside of pages/_document.js in a Next.js project.
    See https://biomejs.dev/linter/rules/no-before-interactive-script-outside-document
     */
    noBeforeInteractiveScriptOutsideDocument?: NoBeforeInteractiveScriptOutsideDocumentConfiguration;
    /**
     * Prevent passing of children as props.
    See https://biomejs.dev/linter/rules/no-children-prop
     */
    noChildrenProp?: NoChildrenPropConfiguration;
    /**
     * Prevents from having const variables being re-assigned.
    See https://biomejs.dev/linter/rules/no-const-assign
     */
    noConstAssign?: NoConstAssignConfiguration;
    /**
     * Disallow constant expressions in conditions.
    See https://biomejs.dev/linter/rules/no-constant-condition
     */
    noConstantCondition?: NoConstantConditionConfiguration;
    /**
     * Disallow the use of Math.min and Math.max to clamp a value where the result itself is constant.
    See https://biomejs.dev/linter/rules/no-constant-math-min-max-clamp
     */
    noConstantMathMinMaxClamp?: NoConstantMathMinMaxClampConfiguration;
    /**
     * Disallow returning a value from a constructor.
    See https://biomejs.dev/linter/rules/no-constructor-return
     */
    noConstructorReturn?: NoConstructorReturnConfiguration;
    /**
     * Require all argument names for fields & directives to be unique.
    See https://biomejs.dev/linter/rules/no-duplicate-argument-names
     */
    noDuplicateArgumentNames?: NoDuplicateArgumentNamesConfiguration;
    /**
     * Disallow duplication of attributes.
    See https://biomejs.dev/linter/rules/no-duplicate-attributes
     */
    noDuplicateAttributes?: NoDuplicateAttributesConfiguration;
    /**
     * Require all enum value names to be unique.
    See https://biomejs.dev/linter/rules/no-duplicate-enum-value-names
     */
    noDuplicateEnumValueNames?: NoDuplicateEnumValueNamesConfiguration;
    /**
     * Require fields within an input object to be unique.
    See https://biomejs.dev/linter/rules/no-duplicate-input-field-names
     */
    noDuplicateInputFieldNames?: NoDuplicateInputFieldNamesConfiguration;
    /**
     * Require all variable definitions to be unique.
    See https://biomejs.dev/linter/rules/no-duplicate-variable-names
     */
    noDuplicateVariableNames?: NoDuplicateVariableNamesConfiguration;
    /**
     * Disallow empty character classes in regular expression literals.
    See https://biomejs.dev/linter/rules/no-empty-character-class-in-regex
     */
    noEmptyCharacterClassInRegex?: NoEmptyCharacterClassInRegexConfiguration;
    /**
     * Disallows empty destructuring patterns.
    See https://biomejs.dev/linter/rules/no-empty-pattern
     */
    noEmptyPattern?: NoEmptyPatternConfiguration;
    /**
     * Disallow the use of __dirname and __filename in the global scope.
    See https://biomejs.dev/linter/rules/no-global-dirname-filename
     */
    noGlobalDirnameFilename?: NoGlobalDirnameFilenameConfiguration;
    /**
     * Disallow calling global object properties as functions.
    See https://biomejs.dev/linter/rules/no-global-object-calls
     */
    noGlobalObjectCalls?: NoGlobalObjectCallsConfiguration;
    /**
     * Disallow function and var declarations that are accessible outside their block.
    See https://biomejs.dev/linter/rules/no-inner-declarations
     */
    noInnerDeclarations?: NoInnerDeclarationsConfiguration;
    /**
     * Ensure that builtins are correctly instantiated.
    See https://biomejs.dev/linter/rules/no-invalid-builtin-instantiation
     */
    noInvalidBuiltinInstantiation?: NoInvalidBuiltinInstantiationConfiguration;
    /**
     * Prevents the incorrect use of super() inside classes. It also checks whether a call super() is missing from classes that extends other constructors.
    See https://biomejs.dev/linter/rules/no-invalid-constructor-super
     */
    noInvalidConstructorSuper?: NoInvalidConstructorSuperConfiguration;
    /**
     * Disallow non-standard direction values for linear gradient functions.
    See https://biomejs.dev/linter/rules/no-invalid-direction-in-linear-gradient
     */
    noInvalidDirectionInLinearGradient?: NoInvalidDirectionInLinearGradientConfiguration;
    /**
     * Disallows invalid named grid areas in CSS Grid Layouts.
    See https://biomejs.dev/linter/rules/no-invalid-grid-areas
     */
    noInvalidGridAreas?: NoInvalidGridAreasConfiguration;
    /**
     * Disallow the use of @import at-rules in invalid positions.
    See https://biomejs.dev/linter/rules/no-invalid-position-at-import-rule
     */
    noInvalidPositionAtImportRule?: NoInvalidPositionAtImportRuleConfiguration;
    /**
     * Disallow the use of variables, function parameters, classes, and enums before their declaration.
    See https://biomejs.dev/linter/rules/no-invalid-use-before-declaration
     */
    noInvalidUseBeforeDeclaration?: NoInvalidUseBeforeDeclarationConfiguration;
    /**
     * Disallow missing var function for css variables.
    See https://biomejs.dev/linter/rules/no-missing-var-function
     */
    noMissingVarFunction?: NoMissingVarFunctionConfiguration;
    /**
     * Disallows defining React components inside other components.
    See https://biomejs.dev/linter/rules/no-nested-component-definitions
     */
    noNestedComponentDefinitions?: NoNestedComponentDefinitionsConfiguration;
    /**
     * Prevent client components from being async functions.
    See https://biomejs.dev/linter/rules/no-next-async-client-component
     */
    noNextAsyncClientComponent?: NoNextAsyncClientComponentConfiguration;
    /**
     * Forbid the use of Node.js builtin modules.
    See https://biomejs.dev/linter/rules/no-nodejs-modules
     */
    noNodejsModules?: NoNodejsModulesConfiguration;
    /**
     * Disallow \8 and \9 escape sequences in string literals.
    See https://biomejs.dev/linter/rules/no-nonoctal-decimal-escape
     */
    noNonoctalDecimalEscape?: NoNonoctalDecimalEscapeConfiguration;
    /**
     * Disallow literal numbers that lose precision.
    See https://biomejs.dev/linter/rules/no-precision-loss
     */
    noPrecisionLoss?: NoPrecisionLossConfiguration;
    /**
     * Restrict imports of private exports.
    See https://biomejs.dev/linter/rules/no-private-imports
     */
    noPrivateImports?: NoPrivateImportsConfiguration;
    /**
     * Disallow the use of process global.
    See https://biomejs.dev/linter/rules/no-process-global
     */
    noProcessGlobal?: NoProcessGlobalConfiguration;
    /**
     * Disallow useVisibleTask$() functions in Qwik components.
    See https://biomejs.dev/linter/rules/no-qwik-use-visible-task
     */
    noQwikUseVisibleTask?: NoQwikUseVisibleTaskConfiguration;
    /**
     * Disallow assigning to React component props.
    See https://biomejs.dev/linter/rules/no-react-prop-assignments
     */
    noReactPropAssignments?: NoReactPropAssignmentsConfiguration;
    /**
     * Prevent the usage of the return value of React.render.
    See https://biomejs.dev/linter/rules/no-render-return-value
     */
    noRenderReturnValue?: NoRenderReturnValueConfiguration;
    /**
     * Disallow the use of configured elements.
    See https://biomejs.dev/linter/rules/no-restricted-elements
     */
    noRestrictedElements?: NoRestrictedElementsConfiguration;
    /**
     * Disallow assignments where both sides are exactly the same.
    See https://biomejs.dev/linter/rules/no-self-assign
     */
    noSelfAssign?: NoSelfAssignConfiguration;
    /**
     * Disallow returning a value from a setter.
    See https://biomejs.dev/linter/rules/no-setter-return
     */
    noSetterReturn?: NoSetterReturnConfiguration;
    /**
     * Disallow destructuring props inside JSX components in Solid projects.
    See https://biomejs.dev/linter/rules/no-solid-destructured-props
     */
    noSolidDestructuredProps?: NoSolidDestructuredPropsConfiguration;
    /**
     * Disallow comparison of expressions modifying the string case with non-compliant value.
    See https://biomejs.dev/linter/rules/no-string-case-mismatch
     */
    noStringCaseMismatch?: NoStringCaseMismatchConfiguration;
    /**
     * Disallow lexical declarations in switch clauses.
    See https://biomejs.dev/linter/rules/no-switch-declarations
     */
    noSwitchDeclarations?: NoSwitchDeclarationsConfiguration;
    /**
     * Disallow the use of dependencies that aren't specified in the package.json.
    See https://biomejs.dev/linter/rules/no-undeclared-dependencies
     */
    noUndeclaredDependencies?: NoUndeclaredDependenciesConfiguration;
    /**
     * Prevents the usage of variables that haven't been declared inside the document.
    See https://biomejs.dev/linter/rules/no-undeclared-variables
     */
    noUndeclaredVariables?: NoUndeclaredVariablesConfiguration;
    /**
     * Disallow unknown CSS value functions.
    See https://biomejs.dev/linter/rules/no-unknown-function
     */
    noUnknownFunction?: NoUnknownFunctionConfiguration;
    /**
     * Disallow unknown media feature names.
    See https://biomejs.dev/linter/rules/no-unknown-media-feature-name
     */
    noUnknownMediaFeatureName?: NoUnknownMediaFeatureNameConfiguration;
    /**
     * Disallow unknown properties.
    See https://biomejs.dev/linter/rules/no-unknown-property
     */
    noUnknownProperty?: NoUnknownPropertyConfiguration;
    /**
     * Disallow unknown pseudo-class selectors.
    See https://biomejs.dev/linter/rules/no-unknown-pseudo-class
     */
    noUnknownPseudoClass?: NoUnknownPseudoClassConfiguration;
    /**
     * Disallow unknown pseudo-element selectors.
    See https://biomejs.dev/linter/rules/no-unknown-pseudo-element
     */
    noUnknownPseudoElement?: NoUnknownPseudoElementConfiguration;
    /**
     * Disallow unknown type selectors.
    See https://biomejs.dev/linter/rules/no-unknown-type-selector
     */
    noUnknownTypeSelector?: NoUnknownTypeSelectorConfiguration;
    /**
     * Disallow unknown CSS units.
    See https://biomejs.dev/linter/rules/no-unknown-unit
     */
    noUnknownUnit?: NoUnknownUnitConfiguration;
    /**
     * Disallow unmatchable An+B selectors.
    See https://biomejs.dev/linter/rules/no-unmatchable-anb-selector
     */
    noUnmatchableAnbSelector?: NoUnmatchableAnbSelectorConfiguration;
    /**
     * Disallow unreachable code.
    See https://biomejs.dev/linter/rules/no-unreachable
     */
    noUnreachable?: NoUnreachableConfiguration;
    /**
     * Ensures the super() constructor is called exactly once on every code  path in a class constructor before this is accessed if the class has a superclass.
    See https://biomejs.dev/linter/rules/no-unreachable-super
     */
    noUnreachableSuper?: NoUnreachableSuperConfiguration;
    /**
     * Warn when importing non-existing exports.
    See https://biomejs.dev/linter/rules/no-unresolved-imports
     */
    noUnresolvedImports?: NoUnresolvedImportsConfiguration;
    /**
     * Disallow control flow statements in finally blocks.
    See https://biomejs.dev/linter/rules/no-unsafe-finally
     */
    noUnsafeFinally?: NoUnsafeFinallyConfiguration;
    /**
     * Disallow the use of optional chaining in contexts where the undefined value is not allowed.
    See https://biomejs.dev/linter/rules/no-unsafe-optional-chaining
     */
    noUnsafeOptionalChaining?: NoUnsafeOptionalChainingConfiguration;
    /**
     * Disallow unused function parameters.
    See https://biomejs.dev/linter/rules/no-unused-function-parameters
     */
    noUnusedFunctionParameters?: NoUnusedFunctionParametersConfiguration;
    /**
     * Disallow unused imports.
    See https://biomejs.dev/linter/rules/no-unused-imports
     */
    noUnusedImports?: NoUnusedImportsConfiguration;
    /**
     * Disallow new operators outside of assignments or comparisons.
    See https://biomejs.dev/linter/rules/no-unused-instantiation
     */
    noUnusedInstantiation?: NoUnusedInstantiationConfiguration;
    /**
     * Disallow unused labels.
    See https://biomejs.dev/linter/rules/no-unused-labels
     */
    noUnusedLabels?: NoUnusedLabelsConfiguration;
    /**
     * Disallow unused private class members.
    See https://biomejs.dev/linter/rules/no-unused-private-class-members
     */
    noUnusedPrivateClassMembers?: NoUnusedPrivateClassMembersConfiguration;
    /**
     * Disallow unused variables.
    See https://biomejs.dev/linter/rules/no-unused-variables
     */
    noUnusedVariables?: NoUnusedVariablesConfiguration;
    /**
     * This rules prevents void elements (AKA self-closing elements) from having children.
    See https://biomejs.dev/linter/rules/no-void-elements-with-children
     */
    noVoidElementsWithChildren?: NoVoidElementsWithChildrenConfiguration;
    /**
     * Disallow returning a value from a function with the return type 'void'.
    See https://biomejs.dev/linter/rules/no-void-type-return
     */
    noVoidTypeReturn?: NoVoidTypeReturnConfiguration;
    /**
     * Enforce that Vue component data options are declared as functions.
    See https://biomejs.dev/linter/rules/no-vue-data-object-declaration
     */
    noVueDataObjectDeclaration?: NoVueDataObjectDeclarationConfiguration;
    /**
     * Disallow duplicate keys in Vue component data, methods, computed properties, and other options.
    See https://biomejs.dev/linter/rules/no-vue-duplicate-keys
     */
    noVueDuplicateKeys?: NoVueDuplicateKeysConfiguration;
    /**
     * Disallow reserved keys in Vue component data and computed properties.
    See https://biomejs.dev/linter/rules/no-vue-reserved-keys
     */
    noVueReservedKeys?: NoVueReservedKeysConfiguration;
    /**
     * Disallow reserved names to be used as props.
    See https://biomejs.dev/linter/rules/no-vue-reserved-props
     */
    noVueReservedProps?: NoVueReservedPropsConfiguration;
    /**
     * Disallow destructuring of props passed to setup in Vue projects.
    See https://biomejs.dev/linter/rules/no-vue-setup-props-reactivity-loss
     */
    noVueSetupPropsReactivityLoss?: NoVueSetupPropsReactivityLossConfiguration;
    /**
     * Disallow using v-if and v-for directives on the same element.
    See https://biomejs.dev/linter/rules/no-vue-v-if-with-v-for
     */
    noVueVIfWithVFor?: NoVueVIfWithVForConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
    /**
     * Enforce correct dependency usage within React hooks.
    See https://biomejs.dev/linter/rules/use-exhaustive-dependencies
     */
    useExhaustiveDependencies?: UseExhaustiveDependenciesConfiguration;
    /**
     * Enforce specifying the name of GraphQL operations.
    See https://biomejs.dev/linter/rules/use-graphql-named-operations
     */
    useGraphqlNamedOperations?: UseGraphqlNamedOperationsConfiguration;
    /**
     * Enforce that all React hooks are being called from the Top Level component functions.
    See https://biomejs.dev/linter/rules/use-hook-at-top-level
     */
    useHookAtTopLevel?: UseHookAtTopLevelConfiguration;
    /**
     * Enforces that \<img> elements have both width and height attributes.
    See https://biomejs.dev/linter/rules/use-image-size
     */
    useImageSize?: UseImageSizeConfiguration;
    /**
     * Enforce file extensions for relative imports.
    See https://biomejs.dev/linter/rules/use-import-extensions
     */
    useImportExtensions?: UseImportExtensionsConfiguration;
    /**
     * Enforce id attribute on next/script components with inline content or dangerouslySetInnerHTML.
    See https://biomejs.dev/linter/rules/use-inline-script-id
     */
    useInlineScriptId?: UseInlineScriptIdConfiguration;
    /**
     * Require calls to isNaN() when checking for NaN.
    See https://biomejs.dev/linter/rules/use-is-nan
     */
    useIsNan?: UseIsNanConfiguration;
    /**
     * Enforces the use of with { type: "json" } for JSON module imports.
    See https://biomejs.dev/linter/rules/use-json-import-attributes
     */
    useJsonImportAttributes?: UseJsonImportAttributesConfiguration;
    /**
     * Disallow missing key props in iterators/collection literals.
    See https://biomejs.dev/linter/rules/use-jsx-key-in-iterable
     */
    useJsxKeyInIterable?: UseJsxKeyInIterableConfiguration;
    /**
     * Disallow anonymous operations when more than one operation specified in document.
    See https://biomejs.dev/linter/rules/use-lone-anonymous-operation
     */
    useLoneAnonymousOperation?: UseLoneAnonymousOperationConfiguration;
    /**
     * Enforce the consistent use of the radix argument when using parseInt().
    See https://biomejs.dev/linter/rules/use-parse-int-radix
     */
    useParseIntRadix?: UseParseIntRadixConfiguration;
    /**
     * Prefer using the class prop as a classlist over the classnames helper.
    See https://biomejs.dev/linter/rules/use-qwik-classlist
     */
    useQwikClasslist?: UseQwikClasslistConfiguration;
    /**
     * Disallow use* hooks outside of component$ or other use* hooks in Qwik applications.
    See https://biomejs.dev/linter/rules/use-qwik-method-usage
     */
    useQwikMethodUsage?: UseQwikMethodUsageConfiguration;
    /**
     * Disallow unserializable expressions in Qwik dollar ($) scopes.
    See https://biomejs.dev/linter/rules/use-qwik-valid-lexical-scope
     */
    useQwikValidLexicalScope?: UseQwikValidLexicalScopeConfiguration;
    /**
     * Enforce JSDoc comment lines to start with a single asterisk, except for the first one.
    See https://biomejs.dev/linter/rules/use-single-js-doc-asterisk
     */
    useSingleJsDocAsterisk?: UseSingleJsDocAsteriskConfiguration;
    /**
     * Prevent the usage of static string literal id attribute on elements.
    See https://biomejs.dev/linter/rules/use-unique-element-ids
     */
    useUniqueElementIds?: UseUniqueElementIdsConfiguration;
    /**
     * Enforce "for" loop update clause moving the counter in the right direction.
    See https://biomejs.dev/linter/rules/use-valid-for-direction
     */
    useValidForDirection?: UseValidForDirectionConfiguration;
    /**
     * This rule checks that the result of a typeof expression is compared to a valid value.
    See https://biomejs.dev/linter/rules/use-valid-typeof
     */
    useValidTypeof?: UseValidTypeofConfiguration;
    /**
     * Enforce that elements using v-for also specify a unique key.
    See https://biomejs.dev/linter/rules/use-vue-v-for-key
     */
    useVueVForKey?: UseVueVForKeyConfiguration;
    /**
     * Enforce valid Vue \<template> root usage.
    See https://biomejs.dev/linter/rules/use-vue-valid-template-root
     */
    useVueValidTemplateRoot?: UseVueValidTemplateRootConfiguration;
    /**
     * Forbids v-bind directives with missing values or invalid modifiers.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-bind
     */
    useVueValidVBind?: UseVueValidVBindConfiguration;
    /**
     * Enforce valid v-cloak Vue directives.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-cloak
     */
    useVueValidVCloak?: UseVueValidVCloakConfiguration;
    /**
     * Enforce valid usage of v-else.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-else
     */
    useVueValidVElse?: UseVueValidVElseConfiguration;
    /**
     * Enforce valid v-else-if directives.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-else-if
     */
    useVueValidVElseIf?: UseVueValidVElseIfConfiguration;
    /**
     * Enforce valid v-html directives.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-html
     */
    useVueValidVHtml?: UseVueValidVHtmlConfiguration;
    /**
     * Enforces valid v-if usage for Vue templates.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-if
     */
    useVueValidVIf?: UseVueValidVIfConfiguration;
    /**
     * Enforce valid v-on directives with proper arguments, modifiers, and handlers.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-on
     */
    useVueValidVOn?: UseVueValidVOnConfiguration;
    /**
     * Enforce valid v-once Vue directives.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-once
     */
    useVueValidVOnce?: UseVueValidVOnceConfiguration;
    /**
     * Enforce valid v-pre Vue directives.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-pre
     */
    useVueValidVPre?: UseVueValidVPreConfiguration;
    /**
     * Enforce valid v-text Vue directives.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-text
     */
    useVueValidVText?: UseVueValidVTextConfiguration;
    /**
     * Require generator functions to contain yield.
    See https://biomejs.dev/linter/rules/use-yield
     */
    useYield?: UseYieldConfiguration;
}
interface Nursery {
    /**
     * Require stringification to avoid values that only use the default object representation.
    See https://biomejs.dev/linter/rules/no-base-to-string
     */
    noBaseToString?: NoBaseToStringConfiguration;
    /**
     * Disallows defining React components or custom hooks inside other functions.
    See https://biomejs.dev/linter/rules/no-component-hook-factories
     */
    noComponentHookFactories?: NoComponentHookFactoriesConfiguration;
    /**
     * Disallow conditional expect() calls inside tests.
    See https://biomejs.dev/linter/rules/no-conditional-expect
     */
    noConditionalExpect?: NoConditionalExpectConfiguration;
    /**
     * Require .where() to be called when using .delete() with Drizzle ORM.
    See https://biomejs.dev/linter/rules/no-drizzle-delete-without-where
     */
    noDrizzleDeleteWithoutWhere?: NoDrizzleDeleteWithoutWhereConfiguration;
    /**
     * Require .where() to be called when using .update() with Drizzle ORM.
    See https://biomejs.dev/linter/rules/no-drizzle-update-without-where
     */
    noDrizzleUpdateWithoutWhere?: NoDrizzleUpdateWithoutWhereConfiguration;
    /**
     * Require all fields of a type to be unique.
    See https://biomejs.dev/linter/rules/no-duplicate-field-definition-names
     */
    noDuplicateFieldDefinitionNames?: NoDuplicateFieldDefinitionNamesConfiguration;
    /**
     * Disallow duplicate selectors.
    See https://biomejs.dev/linter/rules/no-duplicate-selectors
     */
    noDuplicateSelectors?: NoDuplicateSelectorsConfiguration;
    /**
     * Disallow empty keys in JSON objects.
    See https://biomejs.dev/linter/rules/no-empty-object-keys
     */
    noEmptyObjectKeys?: NoEmptyObjectKeysConfiguration;
    /**
     * Enforce a maximum depth that callbacks can be nested.
    See https://biomejs.dev/linter/rules/no-excessive-nested-callbacks
     */
    noExcessiveNestedCallbacks?: NoExcessiveNestedCallbacksConfiguration;
    /**
     * Limit the number of classes in a selector.
    See https://biomejs.dev/linter/rules/no-excessive-selector-classes
     */
    noExcessiveSelectorClasses?: NoExcessiveSelectorClassesConfiguration;
    /**
     * Require Promise-like statements to be handled appropriately.
    See https://biomejs.dev/linter/rules/no-floating-promises
     */
    noFloatingPromises?: NoFloatingPromisesConfiguration;
    /**
     * Disallow identical titles in test suites and test cases.
    See https://biomejs.dev/linter/rules/no-identical-test-title
     */
    noIdenticalTestTitle?: NoIdenticalTestTitleConfiguration;
    /**
     * Disallow the use of eval()-like methods.
    See https://biomejs.dev/linter/rules/no-implied-eval
     */
    noImpliedEval?: NoImpliedEvalConfiguration;
    /**
     * Disallow the use of inline styles.
    See https://biomejs.dev/linter/rules/no-inline-styles
     */
    noInlineStyles?: NoInlineStylesConfiguration;
    /**
     * Flags text nodes with a trailing $ before a JSX expression.
    See https://biomejs.dev/linter/rules/no-jsx-leaked-dollar
     */
    noJsxLeakedDollar?: NoJsxLeakedDollarConfiguration;
    /**
     * Disallow JSX namespace syntax.
    See https://biomejs.dev/linter/rules/no-jsx-namespace
     */
    noJsxNamespace?: NoJsxNamespaceConfiguration;
    /**
     * Disallow functions declared inside loops that capture unsafe outer variables.
    See https://biomejs.dev/linter/rules/no-loop-func
     */
    noLoopFunc?: NoLoopFuncConfiguration;
    /**
     * Detect return type annotations that are misleadingly wider than what the implementation actually returns.
    See https://biomejs.dev/linter/rules/no-misleading-return-type
     */
    noMisleadingReturnType?: NoMisleadingReturnTypeConfiguration;
    /**
     * Disallow Promises to be used in places where they are almost certainly a mistake.
    See https://biomejs.dev/linter/rules/no-misused-promises
     */
    noMisusedPromises?: NoMisusedPromisesConfiguration;
    /**
     * Disallow negated expressions on the left side of an equality check.
    See https://biomejs.dev/linter/rules/no-negation-in-equality-check
     */
    noNegationInEqualityCheck?: NoNegationInEqualityCheckConfiguration;
    /**
     * Disallow usage of element handles (page.$() and page.$$()).
    See https://biomejs.dev/linter/rules/no-playwright-element-handle
     */
    noPlaywrightElementHandle?: NoPlaywrightElementHandleConfiguration;
    /**
     * Disallow usage of page.$eval() and page.$$eval().
    See https://biomejs.dev/linter/rules/no-playwright-eval
     */
    noPlaywrightEval?: NoPlaywrightEvalConfiguration;
    /**
     * Disallow usage of the { force: true } option.
    See https://biomejs.dev/linter/rules/no-playwright-force-option
     */
    noPlaywrightForceOption?: NoPlaywrightForceOptionConfiguration;
    /**
     * Enforce Playwright async APIs to be awaited or returned.
    See https://biomejs.dev/linter/rules/no-playwright-missing-await
     */
    noPlaywrightMissingAwait?: NoPlaywrightMissingAwaitConfiguration;
    /**
     * Disallow usage of the networkidle option.
    See https://biomejs.dev/linter/rules/no-playwright-networkidle
     */
    noPlaywrightNetworkidle?: NoPlaywrightNetworkidleConfiguration;
    /**
     * Disallow using page.pause().
    See https://biomejs.dev/linter/rules/no-playwright-page-pause
     */
    noPlaywrightPagePause?: NoPlaywrightPagePauseConfiguration;
    /**
     * Disallow unnecessary await for Playwright methods that don't return promises.
    See https://biomejs.dev/linter/rules/no-playwright-useless-await
     */
    noPlaywrightUselessAwait?: NoPlaywrightUselessAwaitConfiguration;
    /**
     * Disallow using page.waitForNavigation().
    See https://biomejs.dev/linter/rules/no-playwright-wait-for-navigation
     */
    noPlaywrightWaitForNavigation?: NoPlaywrightWaitForNavigationConfiguration;
    /**
     * Disallow using page.waitForSelector().
    See https://biomejs.dev/linter/rules/no-playwright-wait-for-selector
     */
    noPlaywrightWaitForSelector?: NoPlaywrightWaitForSelectorConfiguration;
    /**
     * Disallow using page.waitForTimeout().
    See https://biomejs.dev/linter/rules/no-playwright-wait-for-timeout
     */
    noPlaywrightWaitForTimeout?: NoPlaywrightWaitForTimeoutConfiguration;
    /**
     * Disallow deep imports from the react-native package.
    See https://biomejs.dev/linter/rules/no-react-native-deep-imports
     */
    noReactNativeDeepImports?: NoReactNativeDeepImportsConfiguration;
    /**
     * Disallow color literals in React Native styles.
    See https://biomejs.dev/linter/rules/no-react-native-literal-colors
     */
    noReactNativeLiteralColors?: NoReactNativeLiteralColorsConfiguration;
    /**
     * Disallow raw text outside \<Text> components in React Native.
    See https://biomejs.dev/linter/rules/no-react-native-raw-text
     */
    noReactNativeRawText?: NoReactNativeRawTextConfiguration;
    /**
     * Disallow string refs in React components.
    See https://biomejs.dev/linter/rules/no-react-string-refs
     */
    noReactStringRefs?: NoReactStringRefsConfiguration;
    /**
     * Disallow dependencies that are known to have better alternatives.
    See https://biomejs.dev/linter/rules/no-restricted-dependencies
     */
    noRestrictedDependencies?: NoRestrictedDependenciesConfiguration;
    /**
     * Disallow unnecessary $state wrapping of reactive classes.
    See https://biomejs.dev/linter/rules/no-svelte-unnecessary-state-wrap
     */
    noSvelteUnnecessaryStateWrap?: NoSvelteUnnecessaryStateWrapConfiguration;
    /**
     * Require the JSON top-level value to be an array or object.
    See https://biomejs.dev/linter/rules/no-top-level-literals
     */
    noTopLevelLiterals?: NoTopLevelLiteralsConfiguration;
    /**
     * Reports CSS class names in HTML class attributes that are not defined in any \<style> block or linked stylesheet available to the file.
    See https://biomejs.dev/linter/rules/no-undeclared-classes
     */
    noUndeclaredClasses?: NoUndeclaredClassesConfiguration;
    /**
     * Disallow unnecessary template expressions.
    See https://biomejs.dev/linter/rules/no-unnecessary-template-expression
     */
    noUnnecessaryTemplateExpression?: NoUnnecessaryTemplateExpressionConfiguration;
    /**
     * Disallow + operations with operands that are known to be unsafe.
    See https://biomejs.dev/linter/rules/no-unsafe-plus-operands
     */
    noUnsafePlusOperands?: NoUnsafePlusOperandsConfiguration;
    /**
     * Disallow dependencies with untrusted licenses.
    See https://biomejs.dev/linter/rules/no-untrusted-licenses
     */
    noUntrustedLicenses?: NoUntrustedLicensesConfiguration;
    /**
     * Reports CSS class selectors that are never referenced in any JSX or HTML file.
    See https://biomejs.dev/linter/rules/no-unused-classes
     */
    noUnusedClasses?: NoUnusedClassesConfiguration;
    /**
     * Disallow type conversions that do not change the type of an expression.
    See https://biomejs.dev/linter/rules/no-useless-type-conversion
     */
    noUselessTypeConversion?: NoUselessTypeConversionConfiguration;
    /**
     * Disallow importing Vue compiler macros.
    See https://biomejs.dev/linter/rules/no-vue-import-compiler-macros
     */
    noVueImportCompilerMacros?: NoVueImportCompilerMacrosConfiguration;
    /**
     * Disallow the use of value wrapped by ref()(Composition API) as operand.
    See https://biomejs.dev/linter/rules/no-vue-ref-as-operand
     */
    noVueRefAsOperand?: NoVueRefAsOperandConfiguration;
    /**
     * Disallow deprecated number modifiers on Vue v-on directives.
    See https://biomejs.dev/linter/rules/no-vue-v-on-number-values
     */
    noVueVOnNumberValues?: NoVueVOnNumberValuesConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
    /**
     * Prefer Array.prototype.some() over verbose existence checks.
    See https://biomejs.dev/linter/rules/use-array-some
     */
    useArraySome?: UseArraySomeConfiguration;
    /**
     * Enforce that await is only used on Promise values.
    See https://biomejs.dev/linter/rules/use-await-thenable
     */
    useAwaitThenable?: UseAwaitThenableConfiguration;
    /**
     * Disallow CSS properties, values, at-rules, functions, and selectors that are not part of the configured Baseline.
    See https://biomejs.dev/linter/rules/use-baseline
     */
    useBaseline?: UseBaselineConfiguration;
    /**
     * Enforce consistent use of it or test for test functions.
    See https://biomejs.dev/linter/rules/use-consistent-test-it
     */
    useConsistentTestIt?: UseConsistentTestItConfiguration;
    /**
     * Detects a disposable object assigned to a variable without using or await using syntax.
    See https://biomejs.dev/linter/rules/use-disposables
     */
    useDisposables?: UseDisposablesConfiguration;
    /**
     * Prefer .textContent over .innerText for DOM node text.
    See https://biomejs.dev/linter/rules/use-dom-node-text-content
     */
    useDomNodeTextContent?: UseDomNodeTextContentConfiguration;
    /**
     * Prefer querySelector() and querySelectorAll() over older DOM query APIs.
    See https://biomejs.dev/linter/rules/use-dom-query-selector
     */
    useDomQuerySelector?: UseDomQuerySelectorConfiguration;
    /**
     * Require switch-case statements to be exhaustive.
    See https://biomejs.dev/linter/rules/use-exhaustive-switch-cases
     */
    useExhaustiveSwitchCases?: UseExhaustiveSwitchCasesConfiguration;
    /**
     * Ensure that test functions contain at least one expect() or similar assertion.
    See https://biomejs.dev/linter/rules/use-expect
     */
    useExpect?: UseExpectConfiguration;
    /**
     * Require explicit return types on functions and class methods.
    See https://biomejs.dev/linter/rules/use-explicit-return-type
     */
    useExplicitReturnType?: UseExplicitReturnTypeConfiguration;
    /**
     * Enforce types in functions, methods, variables, and parameters.
    See https://biomejs.dev/linter/rules/use-explicit-type
     */
    useExplicitType?: UseExplicitTypeConfiguration;
    /**
     * Enforce the 'sandbox' attribute for 'iframe' elements.
    See https://biomejs.dev/linter/rules/use-iframe-sandbox
     */
    useIframeSandbox?: UseIframeSandboxConfiguration;
    /**
     * Enforce that all imports appear at the top of the module.
    See https://biomejs.dev/linter/rules/use-imports-first
     */
    useImportsFirst?: UseImportsFirstConfiguration;
    /**
     * Prefer Array#includes() over Array#indexOf() checks.
    See https://biomejs.dev/linter/rules/use-includes
     */
    useIncludes?: UseIncludesConfiguration;
    /**
     * Prefer Math.min() and Math.max() over ternaries for simple comparisons.
    See https://biomejs.dev/linter/rules/use-math-min-max
     */
    useMathMinMax?: UseMathMinMaxConfiguration;
    /**
     * Enforce using named capture groups in regular expression.
    See https://biomejs.dev/linter/rules/use-named-capture-group
     */
    useNamedCaptureGroup?: UseNamedCaptureGroupConfiguration;
    /**
     * Enforce using the nullish coalescing operator (??) instead of logical or (||).
    See https://biomejs.dev/linter/rules/use-nullish-coalescing
     */
    useNullishCoalescing?: UseNullishCoalescingConfiguration;
    /**
     * Enforce valid describe() callback.
    See https://biomejs.dev/linter/rules/use-playwright-valid-describe-callback
     */
    usePlaywrightValidDescribeCallback?: UsePlaywrightValidDescribeCallbackConfiguration;
    /**
     * Enforce that Qwik loader functions are declared in the correct location.
    See https://biomejs.dev/linter/rules/use-qwik-loader-location
     */
    useQwikLoaderLocation?: UseQwikLoaderLocationConfiguration;
    /**
     * Require functions with the "use server" directive to be async.
    See https://biomejs.dev/linter/rules/use-react-async-server-function
     */
    useReactAsyncServerFunction?: UseReactAsyncServerFunctionConfiguration;
    /**
     * Enforce a specific function type for React function components.
    See https://biomejs.dev/linter/rules/use-react-function-component-definition
     */
    useReactFunctionComponentDefinition?: UseReactFunctionComponentDefinitionConfiguration;
    /**
     * Ensure that platform-specific React Native components are only imported in files named for that platform.
    See https://biomejs.dev/linter/rules/use-react-native-platform-components
     */
    useReactNativePlatformComponents?: UseReactNativePlatformComponentsConfiguration;
    /**
     * Enforce using a type parameter on Array#reduce instead of casting the initial value.
    See https://biomejs.dev/linter/rules/use-reduce-type-parameter
     */
    useReduceTypeParameter?: UseReduceTypeParameterConfiguration;
    /**
     * Enforce RegExp#exec over String#match if no global flag is provided.
    See https://biomejs.dev/linter/rules/use-regexp-exec
     */
    useRegexpExec?: UseRegexpExecConfiguration;
    /**
     * Enforce the use of RegExp.prototype.test() over String.prototype.match() and RegExp.prototype.exec() in boolean contexts.
    See https://biomejs.dev/linter/rules/use-regexp-test
     */
    useRegexpTest?: UseRegexpTestConfiguration;
    /**
     * Enforce that \<style> blocks in Vue SFCs have the scoped attribute and that \<style> blocks in Astro components do not have the is:global directive.
    See https://biomejs.dev/linter/rules/use-scoped-styles
     */
    useScopedStyles?: UseScopedStylesConfiguration;
    /**
     * Enforce the sorting of CSS utility classes.
    See https://biomejs.dev/linter/rules/use-sorted-classes
     */
    useSortedClasses?: UseSortedClassesConfiguration;
    /**
     * Prefer String#startsWith() and String#endsWith() over verbose prefix and suffix checks.
    See https://biomejs.dev/linter/rules/use-string-starts-ends-with
     */
    useStringStartsEndsWith?: UseStringStartsEndsWithConfiguration;
    /**
     * Require keyed {#each} blocks in Svelte templates.
    See https://biomejs.dev/linter/rules/use-svelte-require-each-key
     */
    useSvelteRequireEachKey?: UseSvelteRequireEachKeyConfiguration;
    /**
     * Enforce that test lifecycle hooks are declared in the order they execute.
    See https://biomejs.dev/linter/rules/use-test-hooks-in-order
     */
    useTestHooksInOrder?: UseTestHooksInOrderConfiguration;
    /**
     * Enforce that lifecycle hooks appear before any test cases in the same block.
    See https://biomejs.dev/linter/rules/use-test-hooks-on-top
     */
    useTestHooksOnTop?: UseTestHooksOnTopConfiguration;
    /**
     * Enforce that class methods utilize this.
    See https://biomejs.dev/linter/rules/use-this-in-class-methods
     */
    useThisInClassMethods?: UseThisInClassMethodsConfiguration;
    /**
     * Enforce the use of the u or v flag for regular expressions.
    See https://biomejs.dev/linter/rules/use-unicode-regex
     */
    useUnicodeRegex?: UseUnicodeRegexConfiguration;
    /**
     * Require var declarations to appear at the top of their containing scope.
    See https://biomejs.dev/linter/rules/use-vars-on-top
     */
    useVarsOnTop?: UseVarsOnTopConfiguration;
    /**
     * Enforce consistent defineProps declaration style.
    See https://biomejs.dev/linter/rules/use-vue-consistent-define-props-declaration
     */
    useVueConsistentDefinePropsDeclaration?: UseVueConsistentDefinePropsDeclarationConfiguration;
    /**
     * Enforces Promise syntax when using Vue nextTick.
    See https://biomejs.dev/linter/rules/use-vue-next-tick-promise
     */
    useVueNextTickPromise?: UseVueNextTickPromiseConfiguration;
    /**
     * Enforces valid v-for directives in Vue templates.
    See https://biomejs.dev/linter/rules/use-vue-valid-v-for
     */
    useVueValidVFor?: UseVueValidVForConfiguration;
}
interface Performance {
    /**
     * Disallow the use of spread (...) syntax on accumulators.
    See https://biomejs.dev/linter/rules/no-accumulating-spread
     */
    noAccumulatingSpread?: NoAccumulatingSpreadConfiguration;
    /**
     * Disallow await inside loops.
    See https://biomejs.dev/linter/rules/no-await-in-loops
     */
    noAwaitInLoops?: NoAwaitInLoopsConfiguration;
    /**
     * Disallow the use of barrel file.
    See https://biomejs.dev/linter/rules/no-barrel-file
     */
    noBarrelFile?: NoBarrelFileConfiguration;
    /**
     * Disallow the use of the delete operator.
    See https://biomejs.dev/linter/rules/no-delete
     */
    noDelete?: NoDeleteConfiguration;
    /**
     * Disallow accessing namespace imports dynamically.
    See https://biomejs.dev/linter/rules/no-dynamic-namespace-import-access
     */
    noDynamicNamespaceImportAccess?: NoDynamicNamespaceImportAccessConfiguration;
    /**
     * Prevent usage of \<img> element in a Next.js project.
    See https://biomejs.dev/linter/rules/no-img-element
     */
    noImgElement?: NoImgElementConfiguration;
    /**
     * Disallow .bind(), arrow functions, or function expressions in JSX props.
    See https://biomejs.dev/linter/rules/no-jsx-props-bind
     */
    noJsxPropsBind?: NoJsxPropsBindConfiguration;
    /**
     * Disallow the use of namespace imports.
    See https://biomejs.dev/linter/rules/no-namespace-import
     */
    noNamespaceImport?: NoNamespaceImportConfiguration;
    /**
     * Avoid re-export all.
    See https://biomejs.dev/linter/rules/no-re-export-all
     */
    noReExportAll?: NoReExportAllConfiguration;
    /**
     * Prevent the usage of synchronous scripts.
    See https://biomejs.dev/linter/rules/no-sync-scripts
     */
    noSyncScripts?: NoSyncScriptsConfiguration;
    /**
     * Prevent duplicate polyfills from Polyfill.io.
    See https://biomejs.dev/linter/rules/no-unwanted-polyfillio
     */
    noUnwantedPolyfillio?: NoUnwantedPolyfillioConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
    /**
     * Ensure the preconnect attribute is used when using Google Fonts.
    See https://biomejs.dev/linter/rules/use-google-font-preconnect
     */
    useGoogleFontPreconnect?: UseGoogleFontPreconnectConfiguration;
    /**
     * Enforce using Solid's \<For /> component for mapping an array to JSX elements.
    See https://biomejs.dev/linter/rules/use-solid-for-component
     */
    useSolidForComponent?: UseSolidForComponentConfiguration;
    /**
     * Require regex literals to be declared at the top level.
    See https://biomejs.dev/linter/rules/use-top-level-regex
     */
    useTopLevelRegex?: UseTopLevelRegexConfiguration;
    /**
     * Enforce opting in to Vue Vapor mode in \<script setup> blocks.
    See https://biomejs.dev/linter/rules/use-vue-vapor
     */
    useVueVapor?: UseVueVaporConfiguration;
}
interface Security {
    /**
     * Disallow target="_blank" attribute without rel="noopener".
    See https://biomejs.dev/linter/rules/no-blank-target
     */
    noBlankTarget?: NoBlankTargetConfiguration;
    /**
     * Prevent the usage of dangerous JSX props.
    See https://biomejs.dev/linter/rules/no-dangerously-set-inner-html
     */
    noDangerouslySetInnerHtml?: NoDangerouslySetInnerHtmlConfiguration;
    /**
     * Report when a DOM element or a component uses both children and dangerouslySetInnerHTML prop.
    See https://biomejs.dev/linter/rules/no-dangerously-set-inner-html-with-children
     */
    noDangerouslySetInnerHtmlWithChildren?: NoDangerouslySetInnerHtmlWithChildrenConfiguration;
    /**
     * Disallow the use of global eval().
    See https://biomejs.dev/linter/rules/no-global-eval
     */
    noGlobalEval?: NoGlobalEvalConfiguration;
    /**
     * Disallow javascript: URLs in HTML.
    See https://biomejs.dev/linter/rules/no-script-url
     */
    noScriptUrl?: NoScriptUrlConfiguration;
    /**
     * Disallow usage of sensitive data such as API keys and tokens.
    See https://biomejs.dev/linter/rules/no-secrets
     */
    noSecrets?: NoSecretsConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
}
interface Style {
    /**
     * Disallow use of CommonJs module system in favor of ESM style imports.
    See https://biomejs.dev/linter/rules/no-common-js
     */
    noCommonJs?: NoCommonJsConfiguration;
    /**
     * Disallow continue statements.
    See https://biomejs.dev/linter/rules/no-continue
     */
    noContinue?: NoContinueConfiguration;
    /**
     * Disallow default exports.
    See https://biomejs.dev/linter/rules/no-default-export
     */
    noDefaultExport?: NoDefaultExportConfiguration;
    /**
     * Disallow a lower specificity selector from coming after a higher specificity selector.
    See https://biomejs.dev/linter/rules/no-descending-specificity
     */
    noDescendingSpecificity?: NoDescendingSpecificityConfiguration;
    /**
     * Disallow using a callback in asynchronous tests and hooks.
    See https://biomejs.dev/linter/rules/no-done-callback
     */
    noDoneCallback?: NoDoneCallbackConfiguration;
    /**
     * Disallow TypeScript enum.
    See https://biomejs.dev/linter/rules/no-enum
     */
    noEnum?: NoEnumConfiguration;
    /**
     * Enforce a maximum number of classes per file.
    See https://biomejs.dev/linter/rules/no-excessive-classes-per-file
     */
    noExcessiveClassesPerFile?: NoExcessiveClassesPerFileConfiguration;
    /**
     * Restrict the number of lines in a file.
    See https://biomejs.dev/linter/rules/no-excessive-lines-per-file
     */
    noExcessiveLinesPerFile?: NoExcessiveLinesPerFileConfiguration;
    /**
     * Disallow exporting an imported variable.
    See https://biomejs.dev/linter/rules/no-exported-imports
     */
    noExportedImports?: NoExportedImportsConfiguration;
    /**
     * Prevent usage of \<head> element in a Next.js project.
    See https://biomejs.dev/linter/rules/no-head-element
     */
    noHeadElement?: NoHeadElementConfiguration;
    /**
     * Disallow hex colors.
    See https://biomejs.dev/linter/rules/no-hex-colors
     */
    noHexColors?: NoHexColorsConfiguration;
    /**
     * Disallow implicit true values on JSX boolean attributes.
    See https://biomejs.dev/linter/rules/no-implicit-boolean
     */
    noImplicitBoolean?: NoImplicitBooleanConfiguration;
    /**
     * Disallows the usage of the unary operators ++ and --.
    See https://biomejs.dev/linter/rules/no-increment-decrement
     */
    noIncrementDecrement?: NoIncrementDecrementConfiguration;
    /**
     * Disallow type annotations for variables, parameters, and class properties initialized with a literal expression.
    See https://biomejs.dev/linter/rules/no-inferrable-types
     */
    noInferrableTypes?: NoInferrableTypesConfiguration;
    /**
     * Disallow string literals inside JSX elements.
    See https://biomejs.dev/linter/rules/no-jsx-literals
     */
    noJsxLiterals?: NoJsxLiteralsConfiguration;
    /**
     * Reports usage of "magic numbers" — numbers used directly instead of being assigned to named constants.
    See https://biomejs.dev/linter/rules/no-magic-numbers
     */
    noMagicNumbers?: NoMagicNumbersConfiguration;
    /**
     * Disallow use of chained assignment expressions.
    See https://biomejs.dev/linter/rules/no-multi-assign
     */
    noMultiAssign?: NoMultiAssignConfiguration;
    /**
     * Disallow creating multiline strings by escaping newlines.
    See https://biomejs.dev/linter/rules/no-multiline-string
     */
    noMultilineString?: NoMultilineStringConfiguration;
    /**
     * Disallow the use of TypeScript's namespaces.
    See https://biomejs.dev/linter/rules/no-namespace
     */
    noNamespace?: NoNamespaceConfiguration;
    /**
     * Disallow negation in the condition of an if statement if it has an else clause.
    See https://biomejs.dev/linter/rules/no-negation-else
     */
    noNegationElse?: NoNegationElseConfiguration;
    /**
     * Disallow nested ternary expressions.
    See https://biomejs.dev/linter/rules/no-nested-ternary
     */
    noNestedTernary?: NoNestedTernaryConfiguration;
    /**
     * Disallow non-null assertions using the ! postfix operator.
    See https://biomejs.dev/linter/rules/no-non-null-assertion
     */
    noNonNullAssertion?: NoNonNullAssertionConfiguration;
    /**
     * Disallow reassigning function parameters.
    See https://biomejs.dev/linter/rules/no-parameter-assign
     */
    noParameterAssign?: NoParameterAssignConfiguration;
    /**
     * Disallow the use of parameter properties in class constructors.
    See https://biomejs.dev/linter/rules/no-parameter-properties
     */
    noParameterProperties?: NoParameterPropertiesConfiguration;
    /**
     * Disallow the use of process.env.
    See https://biomejs.dev/linter/rules/no-process-env
     */
    noProcessEnv?: NoProcessEnvConfiguration;
    /**
     * This rule allows you to specify global variable names that you don’t want to use in your application.
    See https://biomejs.dev/linter/rules/no-restricted-globals
     */
    noRestrictedGlobals?: NoRestrictedGlobalsConfiguration;
    /**
     * Disallow specified modules when loaded by import or require.
    See https://biomejs.dev/linter/rules/no-restricted-imports
     */
    noRestrictedImports?: NoRestrictedImportsConfiguration;
    /**
     * Disallow user defined types.
    See https://biomejs.dev/linter/rules/no-restricted-types
     */
    noRestrictedTypes?: NoRestrictedTypesConfiguration;
    /**
     * Disallow the usage of specified root types.
    See https://biomejs.dev/linter/rules/no-root-type
     */
    noRootType?: NoRootTypeConfiguration;
    /**
     * Disallow the use of constants which its value is the upper-case version of its name.
    See https://biomejs.dev/linter/rules/no-shouty-constants
     */
    noShoutyConstants?: NoShoutyConstantsConfiguration;
    /**
     * Enforce the use of String.slice() over String.substr() and String.substring().
    See https://biomejs.dev/linter/rules/no-substr
     */
    noSubstr?: NoSubstrConfiguration;
    /**
     * Disallow ternary operators.
    See https://biomejs.dev/linter/rules/no-ternary
     */
    noTernary?: NoTernaryConfiguration;
    /**
     * Disallow template literals if interpolation and special-character handling are not needed.
    See https://biomejs.dev/linter/rules/no-unused-template-literal
     */
    noUnusedTemplateLiteral?: NoUnusedTemplateLiteralConfiguration;
    /**
     * Disallow else block when the if block breaks early.
    See https://biomejs.dev/linter/rules/no-useless-else
     */
    noUselessElse?: NoUselessElseConfiguration;
    /**
     * Disallow use of @value rule in CSS modules.
    See https://biomejs.dev/linter/rules/no-value-at-rule
     */
    noValueAtRule?: NoValueAtRuleConfiguration;
    /**
     * Disallow the use of Vue Options API.
    See https://biomejs.dev/linter/rules/no-vue-options-api
     */
    noVueOptionsApi?: NoVueOptionsApiConfiguration;
    /**
     * Disallow the use of yoda expressions.
    See https://biomejs.dev/linter/rules/no-yoda-expression
     */
    noYodaExpression?: NoYodaExpressionConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
    /**
     * Disallow Array constructors.
    See https://biomejs.dev/linter/rules/use-array-literals
     */
    useArrayLiterals?: UseArrayLiteralsConfiguration;
    /**
     * Enforce the use of as const over literal type and type annotation.
    See https://biomejs.dev/linter/rules/use-as-const-assertion
     */
    useAsConstAssertion?: UseAsConstAssertionConfiguration;
    /**
     * Use at() instead of integer index access.
    See https://biomejs.dev/linter/rules/use-at-index
     */
    useAtIndex?: UseAtIndexConfiguration;
    /**
     * Requires following curly brace conventions.
    See https://biomejs.dev/linter/rules/use-block-statements
     */
    useBlockStatements?: UseBlockStatementsConfiguration;
    /**
     * Enforce using else if instead of nested if in else clauses.
    See https://biomejs.dev/linter/rules/use-collapsed-else-if
     */
    useCollapsedElseIf?: UseCollapsedElseIfConfiguration;
    /**
     * Enforce using single if instead of nested if clauses.
    See https://biomejs.dev/linter/rules/use-collapsed-if
     */
    useCollapsedIf?: UseCollapsedIfConfiguration;
    /**
     * Enforce declaring components only within modules that export React Components exclusively.
    See https://biomejs.dev/linter/rules/use-component-export-only-modules
     */
    useComponentExportOnlyModules?: UseComponentExportOnlyModulesConfiguration;
    /**
     * Require consistently using either T\[] or Array\<T>.
    See https://biomejs.dev/linter/rules/use-consistent-array-type
     */
    useConsistentArrayType?: UseConsistentArrayTypeConfiguration;
    /**
     * Enforce consistent arrow function bodies.
    See https://biomejs.dev/linter/rules/use-consistent-arrow-return
     */
    useConsistentArrowReturn?: UseConsistentArrowReturnConfiguration;
    /**
     * Enforce the use of new for all builtins, except String, Number and Boolean.
    See https://biomejs.dev/linter/rules/use-consistent-builtin-instantiation
     */
    useConsistentBuiltinInstantiation?: UseConsistentBuiltinInstantiationConfiguration;
    /**
     * This rule enforces consistent use of curly braces inside JSX attributes and JSX children.
    See https://biomejs.dev/linter/rules/use-consistent-curly-braces
     */
    useConsistentCurlyBraces?: UseConsistentCurlyBracesConfiguration;
    /**
     * Disallow enums from having both number and string members.
    See https://biomejs.dev/linter/rules/use-consistent-enum-value-type
     */
    useConsistentEnumValueType?: UseConsistentEnumValueTypeConfiguration;
    /**
     * Require all descriptions to follow the same style (either block or inline) to  maintain consistency and improve readability across the schema.
    See https://biomejs.dev/linter/rules/use-consistent-graphql-descriptions
     */
    useConsistentGraphqlDescriptions?: UseConsistentGraphqlDescriptionsConfiguration;
    /**
     * Require consistent accessibility modifiers on class properties and methods.
    See https://biomejs.dev/linter/rules/use-consistent-member-accessibility
     */
    useConsistentMemberAccessibility?: UseConsistentMemberAccessibilityConfiguration;
    /**
     * Enforce consistent use of either method signatures or function properties within interfaces and type aliases.
    See https://biomejs.dev/linter/rules/use-consistent-method-signatures
     */
    useConsistentMethodSignatures?: UseConsistentMethodSignaturesConfiguration;
    /**
     * Require the consistent declaration of object literals.
    See https://biomejs.dev/linter/rules/use-consistent-object-definitions
     */
    useConsistentObjectDefinitions?: UseConsistentObjectDefinitionsConfiguration;
    /**
     * Enforce type definitions to consistently use either interface or type.
    See https://biomejs.dev/linter/rules/use-consistent-type-definitions
     */
    useConsistentTypeDefinitions?: UseConsistentTypeDefinitionsConfiguration;
    /**
     * Require const declarations for variables that are only assigned once.
    See https://biomejs.dev/linter/rules/use-const
     */
    useConst?: UseConstConfiguration;
    /**
     * Enforce default function parameters and optional function parameters to be last.
    See https://biomejs.dev/linter/rules/use-default-parameter-last
     */
    useDefaultParameterLast?: UseDefaultParameterLastConfiguration;
    /**
     * Require the default clause in switch statements.
    See https://biomejs.dev/linter/rules/use-default-switch-clause
     */
    useDefaultSwitchClause?: UseDefaultSwitchClauseConfiguration;
    /**
     * Require specifying the reason argument when using @deprecated directive.
    See https://biomejs.dev/linter/rules/use-deprecated-reason
     */
    useDeprecatedReason?: UseDeprecatedReasonConfiguration;
    /**
     * Require destructuring from arrays and/or objects.
    See https://biomejs.dev/linter/rules/use-destructuring
     */
    useDestructuring?: UseDestructuringConfiguration;
    /**
     * Require that each enum member value be explicitly initialized.
    See https://biomejs.dev/linter/rules/use-enum-initializers
     */
    useEnumInitializers?: UseEnumInitializersConfiguration;
    /**
     * Enforce that new Error() is thrown with the original error as cause.
    See https://biomejs.dev/linter/rules/use-error-cause
     */
    useErrorCause?: UseErrorCauseConfiguration;
    /**
     * Enforce explicitly comparing the length, size, byteLength or byteOffset property of a value.
    See https://biomejs.dev/linter/rules/use-explicit-length-check
     */
    useExplicitLengthCheck?: UseExplicitLengthCheckConfiguration;
    /**
     * Disallow the use of Math.pow in favor of the ** operator.
    See https://biomejs.dev/linter/rules/use-exponentiation-operator
     */
    useExponentiationOperator?: UseExponentiationOperatorConfiguration;
    /**
     * Promotes the use of export type for types.
    See https://biomejs.dev/linter/rules/use-export-type
     */
    useExportType?: UseExportTypeConfiguration;
    /**
     * Require that all exports are declared after all non-export statements.
    See https://biomejs.dev/linter/rules/use-exports-last
     */
    useExportsLast?: UseExportsLastConfiguration;
    /**
     * Enforce naming conventions for JavaScript and TypeScript filenames.
    See https://biomejs.dev/linter/rules/use-filenaming-convention
     */
    useFilenamingConvention?: UseFilenamingConventionConfiguration;
    /**
     * Prefer using for...of loops over standard for loops where possible.
    See https://biomejs.dev/linter/rules/use-for-of
     */
    useForOf?: UseForOfConfiguration;
    /**
     * This rule enforces the use of \<>...\</> over \<Fragment>...\</Fragment>.
    See https://biomejs.dev/linter/rules/use-fragment-syntax
     */
    useFragmentSyntax?: UseFragmentSyntaxConfiguration;
    /**
     * Enforce the use of globalThis over window, self, and global.
    See https://biomejs.dev/linter/rules/use-global-this
     */
    useGlobalThis?: UseGlobalThisConfiguration;
    /**
     * Validates that all enum values are capitalized.
    See https://biomejs.dev/linter/rules/use-graphql-naming-convention
     */
    useGraphqlNamingConvention?: UseGraphqlNamingConventionConfiguration;
    /**
     * Enforce that getters and setters for the same property are adjacent in class and object definitions.
    See https://biomejs.dev/linter/rules/use-grouped-accessor-pairs
     */
    useGroupedAccessorPairs?: UseGroupedAccessorPairsConfiguration;
    /**
     * Promotes the use of import type for types.
    See https://biomejs.dev/linter/rules/use-import-type
     */
    useImportType?: UseImportTypeConfiguration;
    /**
     * Require mutation argument to be always called "input".
    See https://biomejs.dev/linter/rules/use-input-name
     */
    useInputName?: UseInputNameConfiguration;
    /**
     * Require all enum members to be literal values.
    See https://biomejs.dev/linter/rules/use-literal-enum-members
     */
    useLiteralEnumMembers?: UseLiteralEnumMembersConfiguration;
    /**
     * Require queries, mutations, subscriptions or fragments each to be located in separate files.
    See https://biomejs.dev/linter/rules/use-lone-executable-definition
     */
    useLoneExecutableDefinition?: UseLoneExecutableDefinitionConfiguration;
    /**
     * Enforce naming conventions for everything across a codebase.
    See https://biomejs.dev/linter/rules/use-naming-convention
     */
    useNamingConvention?: UseNamingConventionConfiguration;
    /**
     * Promotes the usage of node:assert/strict over node:assert.
    See https://biomejs.dev/linter/rules/use-node-assert-strict
     */
    useNodeAssertStrict?: UseNodeAssertStrictConfiguration;
    /**
     * Enforces using the node: protocol for Node.js builtin modules.
    See https://biomejs.dev/linter/rules/use-nodejs-import-protocol
     */
    useNodejsImportProtocol?: UseNodejsImportProtocolConfiguration;
    /**
     * Use the Number properties instead of global ones.
    See https://biomejs.dev/linter/rules/use-number-namespace
     */
    useNumberNamespace?: UseNumberNamespaceConfiguration;
    /**
     * Enforce the use of numeric separators in numeric literals.
    See https://biomejs.dev/linter/rules/use-numeric-separators
     */
    useNumericSeparators?: UseNumericSeparatorsConfiguration;
    /**
     * Prefer object spread over Object.assign() when constructing new objects.
    See https://biomejs.dev/linter/rules/use-object-spread
     */
    useObjectSpread?: UseObjectSpreadConfiguration;
    /**
     * Enforce that components are defined as functions and never as classes.
    See https://biomejs.dev/linter/rules/use-react-function-components
     */
    useReactFunctionComponents?: UseReactFunctionComponentsConfiguration;
    /**
     * Enforce marking members as readonly if they are never modified outside the constructor.
    See https://biomejs.dev/linter/rules/use-readonly-class-properties
     */
    useReadonlyClassProperties?: UseReadonlyClassPropertiesConfiguration;
    /**
     * Prevent extra closing tags for components without children.
    See https://biomejs.dev/linter/rules/use-self-closing-elements
     */
    useSelfClosingElements?: UseSelfClosingElementsConfiguration;
    /**
     * Require assignment operator shorthand where possible.
    See https://biomejs.dev/linter/rules/use-shorthand-assign
     */
    useShorthandAssign?: UseShorthandAssignConfiguration;
    /**
     * Enforce using function types instead of object type with call signatures.
    See https://biomejs.dev/linter/rules/use-shorthand-function-type
     */
    useShorthandFunctionType?: UseShorthandFunctionTypeConfiguration;
    /**
     * Disallow multiple variable declarations in the same variable statement.
    See https://biomejs.dev/linter/rules/use-single-var-declarator
     */
    useSingleVarDeclarator?: UseSingleVarDeclaratorConfiguration;
    /**
     * Enforce the use of the spread operator over .apply().
    See https://biomejs.dev/linter/rules/use-spread-over-apply
     */
    useSpreadOverApply?: UseSpreadOverApplyConfiguration;
    /**
     * Require a description parameter for the Symbol().
    See https://biomejs.dev/linter/rules/use-symbol-description
     */
    useSymbolDescription?: UseSymbolDescriptionConfiguration;
    /**
     * Prefer template literals over string concatenation.
    See https://biomejs.dev/linter/rules/use-template
     */
    useTemplate?: UseTemplateConfiguration;
    /**
     * Require new when throwing an error.
    See https://biomejs.dev/linter/rules/use-throw-new-error
     */
    useThrowNewError?: UseThrowNewErrorConfiguration;
    /**
     * Disallow throwing non-Error values.
    See https://biomejs.dev/linter/rules/use-throw-only-error
     */
    useThrowOnlyError?: UseThrowOnlyErrorConfiguration;
    /**
     * Enforce the use of String.trimStart() and String.trimEnd() over String.trimLeft() and String.trimRight().
    See https://biomejs.dev/linter/rules/use-trim-start-end
     */
    useTrimStartEnd?: UseTrimStartEndConfiguration;
    /**
     * Disallow overload signatures that can be unified into a single signature.
    See https://biomejs.dev/linter/rules/use-unified-type-signatures
     */
    useUnifiedTypeSignatures?: UseUnifiedTypeSignaturesConfiguration;
    /**
     * Enforce a consistent style for v-bind in Vue templates.
    See https://biomejs.dev/linter/rules/use-vue-consistent-v-bind-style
     */
    useVueConsistentVBindStyle?: UseVueConsistentVBindStyleConfiguration;
    /**
     * Enforce a consistent style for v-on in Vue templates.
    See https://biomejs.dev/linter/rules/use-vue-consistent-v-on-style
     */
    useVueConsistentVOnStyle?: UseVueConsistentVOnStyleConfiguration;
    /**
     * Enforce specific order of Vue compiler macros.
    See https://biomejs.dev/linter/rules/use-vue-define-macros-order
     */
    useVueDefineMacrosOrder?: UseVueDefineMacrosOrderConfiguration;
    /**
     * Enforce hyphenated (kebab-case) attribute names in Vue templates.
    See https://biomejs.dev/linter/rules/use-vue-hyphenated-attributes
     */
    useVueHyphenatedAttributes?: UseVueHyphenatedAttributesConfiguration;
    /**
     * Enforce multi-word component names in Vue components.
    See https://biomejs.dev/linter/rules/use-vue-multi-word-component-names
     */
    useVueMultiWordComponentNames?: UseVueMultiWordComponentNamesConfiguration;
}
interface Suspicious {
    /**
     * Disallow the use of alert, confirm, and prompt.
    See https://biomejs.dev/linter/rules/no-alert
     */
    noAlert?: NoAlertConfiguration;
    /**
     * Use standard constants instead of approximated literals.
    See https://biomejs.dev/linter/rules/no-approximative-numeric-constant
     */
    noApproximativeNumericConstant?: NoApproximativeNumericConstantConfiguration;
    /**
     * Discourage the usage of Array index in keys.
    See https://biomejs.dev/linter/rules/no-array-index-key
     */
    noArrayIndexKey?: NoArrayIndexKeyConfiguration;
    /**
     * Disallow assignments in expressions.
    See https://biomejs.dev/linter/rules/no-assign-in-expressions
     */
    noAssignInExpressions?: NoAssignInExpressionsConfiguration;
    /**
     * Disallows using an async function as a Promise executor.
    See https://biomejs.dev/linter/rules/no-async-promise-executor
     */
    noAsyncPromiseExecutor?: NoAsyncPromiseExecutorConfiguration;
    /**
     * Prevents the misuse of glob patterns inside the files.includes field.
    See https://biomejs.dev/linter/rules/no-biome-first-exception
     */
    noBiomeFirstException?: NoBiomeFirstExceptionConfiguration;
    /**
     * Disallow bitwise operators.
    See https://biomejs.dev/linter/rules/no-bitwise-operators
     */
    noBitwiseOperators?: NoBitwiseOperatorsConfiguration;
    /**
     * Disallow reassigning exceptions in catch clauses.
    See https://biomejs.dev/linter/rules/no-catch-assign
     */
    noCatchAssign?: NoCatchAssignConfiguration;
    /**
     * Disallow reassigning class members.
    See https://biomejs.dev/linter/rules/no-class-assign
     */
    noClassAssign?: NoClassAssignConfiguration;
    /**
     * Prevent comments from being inserted as text nodes.
    See https://biomejs.dev/linter/rules/no-comment-text
     */
    noCommentText?: NoCommentTextConfiguration;
    /**
     * Disallow comparing against -0.
    See https://biomejs.dev/linter/rules/no-compare-neg-zero
     */
    noCompareNegZero?: NoCompareNegZeroConfiguration;
    /**
     * Disallow labeled statements that are not loops.
    See https://biomejs.dev/linter/rules/no-confusing-labels
     */
    noConfusingLabels?: NoConfusingLabelsConfiguration;
    /**
     * Disallow void type outside of generic or return types.
    See https://biomejs.dev/linter/rules/no-confusing-void-type
     */
    noConfusingVoidType?: NoConfusingVoidTypeConfiguration;
    /**
     * Disallow the use of console.
    See https://biomejs.dev/linter/rules/no-console
     */
    noConsole?: NoConsoleConfiguration;
    /**
     * Disallow TypeScript const enum.
    See https://biomejs.dev/linter/rules/no-const-enum
     */
    noConstEnum?: NoConstEnumConfiguration;
    /**
     * Disallow expressions where the operation doesn't affect the value.
    See https://biomejs.dev/linter/rules/no-constant-binary-expressions
     */
    noConstantBinaryExpressions?: NoConstantBinaryExpressionsConfiguration;
    /**
     * Prevents from having control characters and some escape sequences that match control characters in regular expression literals.
    See https://biomejs.dev/linter/rules/no-control-characters-in-regex
     */
    noControlCharactersInRegex?: NoControlCharactersInRegexConfiguration;
    /**
     * Disallow the use of debugger.
    See https://biomejs.dev/linter/rules/no-debugger
     */
    noDebugger?: NoDebuggerConfiguration;
    /**
     * Restrict imports of deprecated exports.
    See https://biomejs.dev/linter/rules/no-deprecated-imports
     */
    noDeprecatedImports?: NoDeprecatedImportsConfiguration;
    /**
     * Disallow deprecated media types.
    See https://biomejs.dev/linter/rules/no-deprecated-media-type
     */
    noDeprecatedMediaType?: NoDeprecatedMediaTypeConfiguration;
    /**
     * Disallow direct assignments to document.cookie.
    See https://biomejs.dev/linter/rules/no-document-cookie
     */
    noDocumentCookie?: NoDocumentCookieConfiguration;
    /**
     * Prevents importing next/document outside of pages/_document.jsx in Next.js projects.
    See https://biomejs.dev/linter/rules/no-document-import-in-page
     */
    noDocumentImportInPage?: NoDocumentImportInPageConfiguration;
    /**
     * Require the use of === and !==.
    See https://biomejs.dev/linter/rules/no-double-equals
     */
    noDoubleEquals?: NoDoubleEqualsConfiguration;
    /**
     * Disallow duplicate @import rules.
    See https://biomejs.dev/linter/rules/no-duplicate-at-import-rules
     */
    noDuplicateAtImportRules?: NoDuplicateAtImportRulesConfiguration;
    /**
     * Disallow duplicate case labels.
    See https://biomejs.dev/linter/rules/no-duplicate-case
     */
    noDuplicateCase?: NoDuplicateCaseConfiguration;
    /**
     * Disallow duplicate class members.
    See https://biomejs.dev/linter/rules/no-duplicate-class-members
     */
    noDuplicateClassMembers?: NoDuplicateClassMembersConfiguration;
    /**
     * Disallow duplicate custom properties within declaration blocks.
    See https://biomejs.dev/linter/rules/no-duplicate-custom-properties
     */
    noDuplicateCustomProperties?: NoDuplicateCustomPropertiesConfiguration;
    /**
     * Prevent the listing of duplicate dependencies. The rule supports the following dependency groups: "bundledDependencies", "bundleDependencies", "dependencies", "devDependencies", "overrides", "optionalDependencies", and "peerDependencies".
    See https://biomejs.dev/linter/rules/no-duplicate-dependencies
     */
    noDuplicateDependencies?: NoDuplicateDependenciesConfiguration;
    /**
     * Disallow duplicate conditions in if-else-if chains.
    See https://biomejs.dev/linter/rules/no-duplicate-else-if
     */
    noDuplicateElseIf?: NoDuplicateElseIfConfiguration;
    /**
     * Disallow duplicate enum member values.
    See https://biomejs.dev/linter/rules/no-duplicate-enum-values
     */
    noDuplicateEnumValues?: NoDuplicateEnumValuesConfiguration;
    /**
     * No duplicated fields in GraphQL operations.
    See https://biomejs.dev/linter/rules/no-duplicate-fields
     */
    noDuplicateFields?: NoDuplicateFieldsConfiguration;
    /**
     * Disallow duplicate names within font families.
    See https://biomejs.dev/linter/rules/no-duplicate-font-names
     */
    noDuplicateFontNames?: NoDuplicateFontNamesConfiguration;
    /**
     * Enforce unique operation names across a GraphQL document.
    See https://biomejs.dev/linter/rules/no-duplicate-graphql-operation-name
     */
    noDuplicateGraphqlOperationName?: NoDuplicateGraphqlOperationNameConfiguration;
    /**
     * Prevents JSX properties to be assigned multiple times.
    See https://biomejs.dev/linter/rules/no-duplicate-jsx-props
     */
    noDuplicateJsxProps?: NoDuplicateJsxPropsConfiguration;
    /**
     * Disallow two keys with the same name inside objects.
    See https://biomejs.dev/linter/rules/no-duplicate-object-keys
     */
    noDuplicateObjectKeys?: NoDuplicateObjectKeysConfiguration;
    /**
     * Disallow duplicate function parameter name.
    See https://biomejs.dev/linter/rules/no-duplicate-parameters
     */
    noDuplicateParameters?: NoDuplicateParametersConfiguration;
    /**
     * Disallow duplicate properties within declaration blocks.
    See https://biomejs.dev/linter/rules/no-duplicate-properties
     */
    noDuplicateProperties?: NoDuplicatePropertiesConfiguration;
    /**
     * Disallow duplicate selectors within keyframe blocks.
    See https://biomejs.dev/linter/rules/no-duplicate-selectors-keyframe-block
     */
    noDuplicateSelectorsKeyframeBlock?: NoDuplicateSelectorsKeyframeBlockConfiguration;
    /**
     * A describe block should not contain duplicate hooks.
    See https://biomejs.dev/linter/rules/no-duplicate-test-hooks
     */
    noDuplicateTestHooks?: NoDuplicateTestHooksConfiguration;
    /**
     * Disallow JSX prop spreading the same identifier multiple times.
    See https://biomejs.dev/linter/rules/no-duplicated-spread-props
     */
    noDuplicatedSpreadProps?: NoDuplicatedSpreadPropsConfiguration;
    /**
     * Disallow CSS empty blocks.
    See https://biomejs.dev/linter/rules/no-empty-block
     */
    noEmptyBlock?: NoEmptyBlockConfiguration;
    /**
     * Disallow empty block statements and static blocks.
    See https://biomejs.dev/linter/rules/no-empty-block-statements
     */
    noEmptyBlockStatements?: NoEmptyBlockStatementsConfiguration;
    /**
     * Disallow the declaration of empty interfaces.
    See https://biomejs.dev/linter/rules/no-empty-interface
     */
    noEmptyInterface?: NoEmptyInterfaceConfiguration;
    /**
     * Disallow empty sources.
    See https://biomejs.dev/linter/rules/no-empty-source
     */
    noEmptySource?: NoEmptySourceConfiguration;
    /**
     * Require the use of === or !== for comparison with null.
    See https://biomejs.dev/linter/rules/no-equals-to-null
     */
    noEqualsToNull?: NoEqualsToNullConfiguration;
    /**
     * Disallow variables from evolving into any type through reassignments.
    See https://biomejs.dev/linter/rules/no-evolving-types
     */
    noEvolvingTypes?: NoEvolvingTypesConfiguration;
    /**
     * Disallow the any type usage.
    See https://biomejs.dev/linter/rules/no-explicit-any
     */
    noExplicitAny?: NoExplicitAnyConfiguration;
    /**
     * Disallow using export or module.exports in files containing tests.
    See https://biomejs.dev/linter/rules/no-exports-in-test
     */
    noExportsInTest?: NoExportsInTestConfiguration;
    /**
     * Prevents the wrong usage of the non-null assertion operator (!) in TypeScript files.
    See https://biomejs.dev/linter/rules/no-extra-non-null-assertion
     */
    noExtraNonNullAssertion?: NoExtraNonNullAssertionConfiguration;
    /**
     * Disallow fallthrough of switch clauses.
    See https://biomejs.dev/linter/rules/no-fallthrough-switch-clause
     */
    noFallthroughSwitchClause?: NoFallthroughSwitchClauseConfiguration;
    /**
     * Disallow focused tests.
    See https://biomejs.dev/linter/rules/no-focused-tests
     */
    noFocusedTests?: NoFocusedTestsConfiguration;
    /**
     * Disallow iterating using a for-in loop.
    See https://biomejs.dev/linter/rules/no-for-in
     */
    noForIn?: NoForInConfiguration;
    /**
     * Disallow reassigning function declarations.
    See https://biomejs.dev/linter/rules/no-function-assign
     */
    noFunctionAssign?: NoFunctionAssignConfiguration;
    /**
     * Disallow assignments to native objects and read-only global variables.
    See https://biomejs.dev/linter/rules/no-global-assign
     */
    noGlobalAssign?: NoGlobalAssignConfiguration;
    /**
     * Use Number.isFinite instead of global isFinite.
    See https://biomejs.dev/linter/rules/no-global-is-finite
     */
    noGlobalIsFinite?: NoGlobalIsFiniteConfiguration;
    /**
     * Use Number.isNaN instead of global isNaN.
    See https://biomejs.dev/linter/rules/no-global-is-nan
     */
    noGlobalIsNan?: NoGlobalIsNanConfiguration;
    /**
     * Prevent using the next/head module in pages/_document.js on Next.js projects.
    See https://biomejs.dev/linter/rules/no-head-import-in-document
     */
    noHeadImportInDocument?: NoHeadImportInDocumentConfiguration;
    /**
     * Disallow use of implicit any type on variable declarations.
    See https://biomejs.dev/linter/rules/no-implicit-any-let
     */
    noImplicitAnyLet?: NoImplicitAnyLetConfiguration;
    /**
     * Disallow assigning to imported bindings.
    See https://biomejs.dev/linter/rules/no-import-assign
     */
    noImportAssign?: NoImportAssignConfiguration;
    /**
     * Prevent import cycles.
    See https://biomejs.dev/linter/rules/no-import-cycles
     */
    noImportCycles?: NoImportCyclesConfiguration;
    /**
     * Disallow invalid !important within keyframe declarations.
    See https://biomejs.dev/linter/rules/no-important-in-keyframe
     */
    noImportantInKeyframe?: NoImportantInKeyframeConfiguration;
    /**
     * Disallows the use of irregular whitespace characters.
    See https://biomejs.dev/linter/rules/no-irregular-whitespace
     */
    noIrregularWhitespace?: NoIrregularWhitespaceConfiguration;
    /**
     * Disallow labels that share a name with a variable.
    See https://biomejs.dev/linter/rules/no-label-var
     */
    noLabelVar?: NoLabelVarConfiguration;
    /**
     * Prevent problematic leaked values from being rendered.
    See https://biomejs.dev/linter/rules/no-leaked-render
     */
    noLeakedRender?: NoLeakedRenderConfiguration;
    /**
     * Disallow characters made with multiple code points in character class syntax.
    See https://biomejs.dev/linter/rules/no-misleading-character-class
     */
    noMisleadingCharacterClass?: NoMisleadingCharacterClassConfiguration;
    /**
     * Enforce proper usage of new and constructor.
    See https://biomejs.dev/linter/rules/no-misleading-instantiator
     */
    noMisleadingInstantiator?: NoMisleadingInstantiatorConfiguration;
    /**
     * Checks that the assertion function, for example expect, is placed inside an it() function call.
    See https://biomejs.dev/linter/rules/no-misplaced-assertion
     */
    noMisplacedAssertion?: NoMisplacedAssertionConfiguration;
    /**
     * Disallow shorthand assign when variable appears on both sides.
    See https://biomejs.dev/linter/rules/no-misrefactored-shorthand-assign
     */
    noMisrefactoredShorthandAssign?: NoMisrefactoredShorthandAssignConfiguration;
    /**
     * Disallow nested .then() or .catch() promise calls.
    See https://biomejs.dev/linter/rules/no-nested-promises
     */
    noNestedPromises?: NoNestedPromisesConfiguration;
    /**
     * Disallow non-null assertions after optional chaining expressions.
    See https://biomejs.dev/linter/rules/no-non-null-asserted-optional-chain
     */
    noNonNullAssertedOptionalChain?: NoNonNullAssertedOptionalChainConfiguration;
    /**
     * Disallow octal escape sequences in string literals.
    See https://biomejs.dev/linter/rules/no-octal-escape
     */
    noOctalEscape?: NoOctalEscapeConfiguration;
    /**
     * Disallow function parameters that are only used in recursive calls.
    See https://biomejs.dev/linter/rules/no-parameters-only-used-in-recursion
     */
    noParametersOnlyUsedInRecursion?: NoParametersOnlyUsedInRecursionConfiguration;
    /**
     * Disallow the use of the deprecated __proto__ object property.
    See https://biomejs.dev/linter/rules/no-proto
     */
    noProto?: NoProtoConfiguration;
    /**
     * Disallow direct use of Object.prototype builtins.
    See https://biomejs.dev/linter/rules/no-prototype-builtins
     */
    noPrototypeBuiltins?: NoPrototypeBuiltinsConfiguration;
    /**
     * Disallow the use if quickfix.biome inside editor settings file.
    See https://biomejs.dev/linter/rules/no-quickfix-biome
     */
    noQuickfixBiome?: NoQuickfixBiomeConfiguration;
    /**
     * Replaces usages of forwardRef with passing ref as a prop.
    See https://biomejs.dev/linter/rules/no-react-forward-ref
     */
    noReactForwardRef?: NoReactForwardRefConfiguration;
    /**
     * Prevents React-specific JSX properties from being used.
    See https://biomejs.dev/linter/rules/no-react-specific-props
     */
    noReactSpecificProps?: NoReactSpecificPropsConfiguration;
    /**
     * Disallow variable, function, class, and type redeclarations in the same scope.
    See https://biomejs.dev/linter/rules/no-redeclare
     */
    noRedeclare?: NoRedeclareConfiguration;
    /**
     * Prevents from having redundant "use strict".
    See https://biomejs.dev/linter/rules/no-redundant-use-strict
     */
    noRedundantUseStrict?: NoRedundantUseStrictConfiguration;
    /**
     * Disallow assignments in return statements.
    See https://biomejs.dev/linter/rules/no-return-assign
     */
    noReturnAssign?: NoReturnAssignConfiguration;
    /**
     * Disallow comparisons where both sides are exactly the same.
    See https://biomejs.dev/linter/rules/no-self-compare
     */
    noSelfCompare?: NoSelfCompareConfiguration;
    /**
     * Disallow variable declarations from shadowing variables declared in the outer scope.
    See https://biomejs.dev/linter/rules/no-shadow
     */
    noShadow?: NoShadowConfiguration;
    /**
     * Disallow identifiers from shadowing restricted names.
    See https://biomejs.dev/linter/rules/no-shadow-restricted-names
     */
    noShadowRestrictedNames?: NoShadowRestrictedNamesConfiguration;
    /**
     * Disallow shorthand properties that override related longhand properties.
    See https://biomejs.dev/linter/rules/no-shorthand-property-overrides
     */
    noShorthandPropertyOverrides?: NoShorthandPropertyOverridesConfiguration;
    /**
     * Disallow disabled tests.
    See https://biomejs.dev/linter/rules/no-skipped-tests
     */
    noSkippedTests?: NoSkippedTestsConfiguration;
    /**
     * Prevents the use of sparse arrays (arrays with holes).
    See https://biomejs.dev/linter/rules/no-sparse-array
     */
    noSparseArray?: NoSparseArrayConfiguration;
    /**
     * It detects possible "wrong" semicolons inside JSX elements.
    See https://biomejs.dev/linter/rules/no-suspicious-semicolon-in-jsx
     */
    noSuspiciousSemicolonInJsx?: NoSuspiciousSemicolonInJsxConfiguration;
    /**
     * Disallow template literal placeholder syntax in regular strings.
    See https://biomejs.dev/linter/rules/no-template-curly-in-string
     */
    noTemplateCurlyInString?: NoTemplateCurlyInStringConfiguration;
    /**
     * Disallow then property.
    See https://biomejs.dev/linter/rules/no-then-property
     */
    noThenProperty?: NoThenPropertyConfiguration;
    /**
     * Prevents the use of the TypeScript directive @ts-ignore.
    See https://biomejs.dev/linter/rules/no-ts-ignore
     */
    noTsIgnore?: NoTsIgnoreConfiguration;
    /**
     * Disallow let or var variables that are read but never assigned.
    See https://biomejs.dev/linter/rules/no-unassigned-variables
     */
    noUnassignedVariables?: NoUnassignedVariablesConfiguration;
    /**
     * Disallow the use of undeclared environment variables.
    See https://biomejs.dev/linter/rules/no-undeclared-env-vars
     */
    noUndeclaredEnvVars?: NoUndeclaredEnvVarsConfiguration;
    /**
     * Disallow unknown at-rules.
    See https://biomejs.dev/linter/rules/no-unknown-at-rules
     */
    noUnknownAtRules?: NoUnknownAtRulesConfiguration;
    /**
     * Disallow unknown DOM properties.
    See https://biomejs.dev/linter/rules/no-unknown-attribute
     */
    noUnknownAttribute?: NoUnknownAttributeConfiguration;
    /**
     * Disallow conditions that always evaluate to the same value.
    See https://biomejs.dev/linter/rules/no-unnecessary-conditions
     */
    noUnnecessaryConditions?: NoUnnecessaryConditionsConfiguration;
    /**
     * Disallow unsafe declaration merging between interfaces and classes.
    See https://biomejs.dev/linter/rules/no-unsafe-declaration-merging
     */
    noUnsafeDeclarationMerging?: NoUnsafeDeclarationMergingConfiguration;
    /**
     * Disallow using unsafe negation.
    See https://biomejs.dev/linter/rules/no-unsafe-negation
     */
    noUnsafeNegation?: NoUnsafeNegationConfiguration;
    /**
     * Disallow expression statements that are neither a function call nor an assignment.
    See https://biomejs.dev/linter/rules/no-unused-expressions
     */
    noUnusedExpressions?: NoUnusedExpressionsConfiguration;
    /**
     * Disallow unnecessary escapes in string literals.
    See https://biomejs.dev/linter/rules/no-useless-escape-in-string
     */
    noUselessEscapeInString?: NoUselessEscapeInStringConfiguration;
    /**
     * Disallow useless backreferences in regular expression literals that always match an empty string.
    See https://biomejs.dev/linter/rules/no-useless-regex-backrefs
     */
    noUselessRegexBackrefs?: NoUselessRegexBackrefsConfiguration;
    /**
     * Disallow the use of var.
    See https://biomejs.dev/linter/rules/no-var
     */
    noVar?: NoVarConfiguration;
    /**
     * Disallows using arrow functions when defining a watcher.
    See https://biomejs.dev/linter/rules/no-vue-arrow-func-in-watch
     */
    noVueArrowFuncInWatch?: NoVueArrowFuncInWatchConfiguration;
    /**
     * Disallow with statements in non-strict contexts.
    See https://biomejs.dev/linter/rules/no-with
     */
    noWith?: NoWithConfiguration;
    /**
     * Enables a particular rule preset
     */
    preset?: PresetConfig;
    /**
     * Enables the recommended rules for this group
     */
    recommended?: boolean;
    /**
     * Disallow the use of overload signatures that are not next to each other.
    See https://biomejs.dev/linter/rules/use-adjacent-overload-signatures
     */
    useAdjacentOverloadSignatures?: UseAdjacentOverloadSignaturesConfiguration;
    /**
     * Require Array#sort and Array#toSorted calls to always provide a compareFunction.
    See https://biomejs.dev/linter/rules/use-array-sort-compare
     */
    useArraySortCompare?: UseArraySortCompareConfiguration;
    /**
     * Ensure async functions utilize await.
    See https://biomejs.dev/linter/rules/use-await
     */
    useAwait?: UseAwaitConfiguration;
    /**
     * Promotes the correct usage for ignoring folders in the configuration file.
    See https://biomejs.dev/linter/rules/use-biome-ignore-folder
     */
    useBiomeIgnoreFolder?: UseBiomeIgnoreFolderConfiguration;
    /**
     * Enforce default clauses in switch statements to be last.
    See https://biomejs.dev/linter/rules/use-default-switch-clause-last
     */
    useDefaultSwitchClauseLast?: UseDefaultSwitchClauseLastConfiguration;
    /**
     * Require the @deprecated directive to specify a deletion date.
    See https://biomejs.dev/linter/rules/use-deprecated-date
     */
    useDeprecatedDate?: UseDeprecatedDateConfiguration;
    /**
     * Enforce passing a message value when creating a built-in error.
    See https://biomejs.dev/linter/rules/use-error-message
     */
    useErrorMessage?: UseErrorMessageConfiguration;
    /**
     * Enforce get methods to always return a value.
    See https://biomejs.dev/linter/rules/use-getter-return
     */
    useGetterReturn?: UseGetterReturnConfiguration;
    /**
     * Enforces the use of a recommended display strategy with Google Fonts.
    See https://biomejs.dev/linter/rules/use-google-font-display
     */
    useGoogleFontDisplay?: UseGoogleFontDisplayConfiguration;
    /**
     * Require for-in loops to include an if statement.
    See https://biomejs.dev/linter/rules/use-guard-for-in
     */
    useGuardForIn?: UseGuardForInConfiguration;
    /**
     * Use Array.isArray() instead of instanceof Array.
    See https://biomejs.dev/linter/rules/use-is-array
     */
    useIsArray?: UseIsArrayConfiguration;
    /**
     * Enforce consistent return values in iterable callbacks.
    See https://biomejs.dev/linter/rules/use-iterable-callback-return
     */
    useIterableCallbackReturn?: UseIterableCallbackReturnConfiguration;
    /**
     * Require using the namespace keyword over the module keyword to declare TypeScript namespaces.
    See https://biomejs.dev/linter/rules/use-namespace-keyword
     */
    useNamespaceKeyword?: UseNamespaceKeywordConfiguration;
    /**
     * Enforce using the digits argument with Number#toFixed().
    See https://biomejs.dev/linter/rules/use-number-to-fixed-digits-argument
     */
    useNumberToFixedDigitsArgument?: UseNumberToFixedDigitsArgumentConfiguration;
    /**
     * Enforce the presence of required scripts in package.json.
    See https://biomejs.dev/linter/rules/use-required-scripts
     */
    useRequiredScripts?: UseRequiredScriptsConfiguration;
    /**
     * Use static Response methods instead of new Response() constructor when possible.
    See https://biomejs.dev/linter/rules/use-static-response-methods
     */
    useStaticResponseMethods?: UseStaticResponseMethodsConfiguration;
    /**
     * Enforce the use of the directive "use strict" in script files.
    See https://biomejs.dev/linter/rules/use-strict-mode
     */
    useStrictMode?: UseStrictModeConfiguration;
}
type Glob = string;
type RuleAssistPlainConfiguration = "off" | "on";
interface RuleAssistWithNoDuplicateClassesOptions {
    level: RuleAssistPlainConfiguration;
    options: NoDuplicateClassesOptions;
}
interface RuleAssistWithOrganizeImportsOptions {
    level: RuleAssistPlainConfiguration;
    options: OrganizeImportsOptions;
}
interface RuleAssistWithUseSortedAttributesOptions {
    level: RuleAssistPlainConfiguration;
    options: UseSortedAttributesOptions;
}
interface RuleAssistWithUseSortedEnumMembersOptions {
    level: RuleAssistPlainConfiguration;
    options: UseSortedEnumMembersOptions;
}
interface RuleAssistWithUseSortedInterfaceMembersOptions {
    level: RuleAssistPlainConfiguration;
    options: UseSortedInterfaceMembersOptions;
}
interface RuleAssistWithUseSortedKeysOptions {
    level: RuleAssistPlainConfiguration;
    options: UseSortedKeysOptions;
}
interface RuleAssistWithUseSortedPackageJsonOptions {
    level: RuleAssistPlainConfiguration;
    options: UseSortedPackageJsonOptions;
}
interface RuleAssistWithUseSortedPropertiesOptions {
    level: RuleAssistPlainConfiguration;
    options: UseSortedPropertiesOptions;
}
interface RuleAssistWithUseSortedSelectionSetOptions {
    level: RuleAssistPlainConfiguration;
    options: UseSortedSelectionSetOptions;
}
interface RuleAssistWithUseSortedTypeFieldsOptions {
    level: RuleAssistPlainConfiguration;
    options: UseSortedTypeFieldsOptions;
}
type NoAccessKeyConfiguration =
| RulePlainConfiguration
| RuleWithNoAccessKeyOptions;
type NoAmbiguousAnchorTextConfiguration =
| RulePlainConfiguration
| RuleWithNoAmbiguousAnchorTextOptions;
type NoAriaHiddenOnFocusableConfiguration =
| RulePlainConfiguration
| RuleWithNoAriaHiddenOnFocusableOptions;
type NoAriaUnsupportedElementsConfiguration =
| RulePlainConfiguration
| RuleWithNoAriaUnsupportedElementsOptions;
type NoAutofocusConfiguration =
| RulePlainConfiguration
| RuleWithNoAutofocusOptions;
type NoDistractingElementsConfiguration =
| RulePlainConfiguration
| RuleWithNoDistractingElementsOptions;
type NoHeaderScopeConfiguration =
| RulePlainConfiguration
| RuleWithNoHeaderScopeOptions;
type NoInteractiveElementToNoninteractiveRoleConfiguration =
| RulePlainConfiguration
| RuleWithNoInteractiveElementToNoninteractiveRoleOptions;
type NoLabelWithoutControlConfiguration =
| RulePlainConfiguration
| RuleWithNoLabelWithoutControlOptions;
type NoNoninteractiveElementInteractionsConfiguration =
| RulePlainConfiguration
| RuleWithNoNoninteractiveElementInteractionsOptions;
type NoNoninteractiveElementToInteractiveRoleConfiguration =
| RulePlainConfiguration
| RuleWithNoNoninteractiveElementToInteractiveRoleOptions;
type NoNoninteractiveTabindexConfiguration =
| RulePlainConfiguration
| RuleWithNoNoninteractiveTabindexOptions;
type NoPositiveTabindexConfiguration =
| RulePlainConfiguration
| RuleWithNoPositiveTabindexOptions;
type NoRedundantAltConfiguration =
| RulePlainConfiguration
| RuleWithNoRedundantAltOptions;
type NoRedundantRolesConfiguration =
| RulePlainConfiguration
| RuleWithNoRedundantRolesOptions;
type NoStaticElementInteractionsConfiguration =
| RulePlainConfiguration
| RuleWithNoStaticElementInteractionsOptions;
type NoSvgWithoutTitleConfiguration =
| RulePlainConfiguration
| RuleWithNoSvgWithoutTitleOptions;
type UseAltTextConfiguration =
| RulePlainConfiguration
| RuleWithUseAltTextOptions;
type UseAnchorContentConfiguration =
| RulePlainConfiguration
| RuleWithUseAnchorContentOptions;
type UseAriaActivedescendantWithTabindexConfiguration =
| RulePlainConfiguration
| RuleWithUseAriaActivedescendantWithTabindexOptions;
type UseAriaPropsForRoleConfiguration =
| RulePlainConfiguration
| RuleWithUseAriaPropsForRoleOptions;
type UseAriaPropsSupportedByRoleConfiguration =
| RulePlainConfiguration
| RuleWithUseAriaPropsSupportedByRoleOptions;
type UseButtonTypeConfiguration =
| RulePlainConfiguration
| RuleWithUseButtonTypeOptions;
type UseFocusableInteractiveConfiguration =
| RulePlainConfiguration
| RuleWithUseFocusableInteractiveOptions;
type UseGenericFontNamesConfiguration =
| RulePlainConfiguration
| RuleWithUseGenericFontNamesOptions;
type UseHeadingContentConfiguration =
| RulePlainConfiguration
| RuleWithUseHeadingContentOptions;
type UseHtmlLangConfiguration =
| RulePlainConfiguration
| RuleWithUseHtmlLangOptions;
type UseIframeTitleConfiguration =
| RulePlainConfiguration
| RuleWithUseIframeTitleOptions;
type UseKeyWithClickEventsConfiguration =
| RulePlainConfiguration
| RuleWithUseKeyWithClickEventsOptions;
type UseKeyWithMouseEventsConfiguration =
| RulePlainConfiguration
| RuleWithUseKeyWithMouseEventsOptions;
type UseMediaCaptionConfiguration =
| RulePlainConfiguration
| RuleWithUseMediaCaptionOptions;
type UseSemanticElementsConfiguration =
| RulePlainConfiguration
| RuleWithUseSemanticElementsOptions;
type UseValidAnchorConfiguration =
| RulePlainConfiguration
| RuleWithUseValidAnchorOptions;
type UseValidAriaPropsConfiguration =
| RulePlainConfiguration
| RuleWithUseValidAriaPropsOptions;
type UseValidAriaRoleConfiguration =
| RulePlainConfiguration
| RuleWithUseValidAriaRoleOptions;
type UseValidAriaValuesConfiguration =
| RulePlainConfiguration
| RuleWithUseValidAriaValuesOptions;
type UseValidAutocompleteConfiguration =
| RulePlainConfiguration
| RuleWithUseValidAutocompleteOptions;
type UseValidLangConfiguration =
| RulePlainConfiguration
| RuleWithUseValidLangOptions;
type NoAdjacentSpacesInRegexConfiguration =
| RulePlainConfiguration
| RuleWithNoAdjacentSpacesInRegexOptions;
type NoArgumentsConfiguration =
| RulePlainConfiguration
| RuleWithNoArgumentsOptions;
type NoBannedTypesConfiguration =
| RulePlainConfiguration
| RuleWithNoBannedTypesOptions;
type NoCommaOperatorConfiguration =
| RulePlainConfiguration
| RuleWithNoCommaOperatorOptions;
type NoDivRegexConfiguration =
| RulePlainConfiguration
| RuleWithNoDivRegexOptions;
type NoEmptyTypeParametersConfiguration =
| RulePlainConfiguration
| RuleWithNoEmptyTypeParametersOptions;
type NoExcessiveCognitiveComplexityConfiguration =
| RulePlainConfiguration
| RuleWithNoExcessiveCognitiveComplexityOptions;
type NoExcessiveLinesPerFunctionConfiguration =
| RulePlainConfiguration
| RuleWithNoExcessiveLinesPerFunctionOptions;
type NoExcessiveNestedTestSuitesConfiguration =
| RulePlainConfiguration
| RuleWithNoExcessiveNestedTestSuitesOptions;
type NoExtraBooleanCastConfiguration =
| RulePlainConfiguration
| RuleWithNoExtraBooleanCastOptions;
type NoFlatMapIdentityConfiguration =
| RulePlainConfiguration
| RuleWithNoFlatMapIdentityOptions;
type NoForEachConfiguration = RulePlainConfiguration | RuleWithNoForEachOptions;
type NoImplicitCoercionsConfiguration =
| RulePlainConfiguration
| RuleWithNoImplicitCoercionsOptions;
type NoImportantStylesConfiguration =
| RulePlainConfiguration
| RuleWithNoImportantStylesOptions;
type NoRedundantDefaultExportConfiguration =
| RulePlainConfiguration
| RuleWithNoRedundantDefaultExportOptions;
type NoStaticOnlyClassConfiguration =
| RulePlainConfiguration
| RuleWithNoStaticOnlyClassOptions;
type NoThisInStaticConfiguration =
| RulePlainConfiguration
| RuleWithNoThisInStaticOptions;
type NoUselessCatchConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessCatchOptions;
type NoUselessCatchBindingConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessCatchBindingOptions;
type NoUselessConstructorConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessConstructorOptions;
type NoUselessContinueConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessContinueOptions;
type NoUselessEmptyExportConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessEmptyExportOptions;
type NoUselessEscapeInRegexConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessEscapeInRegexOptions;
type NoUselessFragmentsConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessFragmentsOptions;
type NoUselessLabelConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessLabelOptions;
type NoUselessLoneBlockStatementsConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessLoneBlockStatementsOptions;
type NoUselessRenameConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessRenameOptions;
type NoUselessReturnConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessReturnOptions;
type NoUselessStringConcatConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessStringConcatOptions;
type NoUselessStringRawConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessStringRawOptions;
type NoUselessSwitchCaseConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessSwitchCaseOptions;
type NoUselessTernaryConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessTernaryOptions;
type NoUselessThisAliasConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessThisAliasOptions;
type NoUselessTypeConstraintConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessTypeConstraintOptions;
type NoUselessUndefinedConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessUndefinedOptions;
type NoUselessUndefinedInitializationConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessUndefinedInitializationOptions;
type NoVoidConfiguration = RulePlainConfiguration | RuleWithNoVoidOptions;
type UseArrayFindConfiguration =
| RulePlainConfiguration
| RuleWithUseArrayFindOptions;
type UseArrowFunctionConfiguration =
| RulePlainConfiguration
| RuleWithUseArrowFunctionOptions;
type UseDateNowConfiguration =
| RulePlainConfiguration
| RuleWithUseDateNowOptions;
type UseFlatMapConfiguration =
| RulePlainConfiguration
| RuleWithUseFlatMapOptions;
type UseIndexOfConfiguration =
| RulePlainConfiguration
| RuleWithUseIndexOfOptions;
type UseLiteralKeysConfiguration =
| RulePlainConfiguration
| RuleWithUseLiteralKeysOptions;
type UseMaxParamsConfiguration =
| RulePlainConfiguration
| RuleWithUseMaxParamsOptions;
type UseNumericLiteralsConfiguration =
| RulePlainConfiguration
| RuleWithUseNumericLiteralsOptions;
type UseOptionalChainConfiguration =
| RulePlainConfiguration
| RuleWithUseOptionalChainOptions;
type UseRegexLiteralsConfiguration =
| RulePlainConfiguration
| RuleWithUseRegexLiteralsOptions;
type UseSimpleNumberKeysConfiguration =
| RulePlainConfiguration
| RuleWithUseSimpleNumberKeysOptions;
type UseSimplifiedLogicExpressionConfiguration =
| RulePlainConfiguration
| RuleWithUseSimplifiedLogicExpressionOptions;
type UseWhileConfiguration = RulePlainConfiguration | RuleWithUseWhileOptions;
type NoBeforeInteractiveScriptOutsideDocumentConfiguration =
| RulePlainConfiguration
| RuleWithNoBeforeInteractiveScriptOutsideDocumentOptions;
type NoChildrenPropConfiguration =
| RulePlainConfiguration
| RuleWithNoChildrenPropOptions;
type NoConstAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoConstAssignOptions;
type NoConstantConditionConfiguration =
| RulePlainConfiguration
| RuleWithNoConstantConditionOptions;
type NoConstantMathMinMaxClampConfiguration =
| RulePlainConfiguration
| RuleWithNoConstantMathMinMaxClampOptions;
type NoConstructorReturnConfiguration =
| RulePlainConfiguration
| RuleWithNoConstructorReturnOptions;
type NoDuplicateArgumentNamesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateArgumentNamesOptions;
type NoDuplicateAttributesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateAttributesOptions;
type NoDuplicateEnumValueNamesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateEnumValueNamesOptions;
type NoDuplicateInputFieldNamesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateInputFieldNamesOptions;
type NoDuplicateVariableNamesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateVariableNamesOptions;
type NoEmptyCharacterClassInRegexConfiguration =
| RulePlainConfiguration
| RuleWithNoEmptyCharacterClassInRegexOptions;
type NoEmptyPatternConfiguration =
| RulePlainConfiguration
| RuleWithNoEmptyPatternOptions;
type NoGlobalDirnameFilenameConfiguration =
| RulePlainConfiguration
| RuleWithNoGlobalDirnameFilenameOptions;
type NoGlobalObjectCallsConfiguration =
| RulePlainConfiguration
| RuleWithNoGlobalObjectCallsOptions;
type NoInnerDeclarationsConfiguration =
| RulePlainConfiguration
| RuleWithNoInnerDeclarationsOptions;
type NoInvalidBuiltinInstantiationConfiguration =
| RulePlainConfiguration
| RuleWithNoInvalidBuiltinInstantiationOptions;
type NoInvalidConstructorSuperConfiguration =
| RulePlainConfiguration
| RuleWithNoInvalidConstructorSuperOptions;
type NoInvalidDirectionInLinearGradientConfiguration =
| RulePlainConfiguration
| RuleWithNoInvalidDirectionInLinearGradientOptions;
type NoInvalidGridAreasConfiguration =
| RulePlainConfiguration
| RuleWithNoInvalidGridAreasOptions;
type NoInvalidPositionAtImportRuleConfiguration =
| RulePlainConfiguration
| RuleWithNoInvalidPositionAtImportRuleOptions;
type NoInvalidUseBeforeDeclarationConfiguration =
| RulePlainConfiguration
| RuleWithNoInvalidUseBeforeDeclarationOptions;
type NoMissingVarFunctionConfiguration =
| RulePlainConfiguration
| RuleWithNoMissingVarFunctionOptions;
type NoNestedComponentDefinitionsConfiguration =
| RulePlainConfiguration
| RuleWithNoNestedComponentDefinitionsOptions;
type NoNextAsyncClientComponentConfiguration =
| RulePlainConfiguration
| RuleWithNoNextAsyncClientComponentOptions;
type NoNodejsModulesConfiguration =
| RulePlainConfiguration
| RuleWithNoNodejsModulesOptions;
type NoNonoctalDecimalEscapeConfiguration =
| RulePlainConfiguration
| RuleWithNoNonoctalDecimalEscapeOptions;
type NoPrecisionLossConfiguration =
| RulePlainConfiguration
| RuleWithNoPrecisionLossOptions;
type NoPrivateImportsConfiguration =
| RulePlainConfiguration
| RuleWithNoPrivateImportsOptions;
type NoProcessGlobalConfiguration =
| RulePlainConfiguration
| RuleWithNoProcessGlobalOptions;
type NoQwikUseVisibleTaskConfiguration =
| RulePlainConfiguration
| RuleWithNoQwikUseVisibleTaskOptions;
type NoReactPropAssignmentsConfiguration =
| RulePlainConfiguration
| RuleWithNoReactPropAssignmentsOptions;
type NoRenderReturnValueConfiguration =
| RulePlainConfiguration
| RuleWithNoRenderReturnValueOptions;
type NoRestrictedElementsConfiguration =
| RulePlainConfiguration
| RuleWithNoRestrictedElementsOptions;
type NoSelfAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoSelfAssignOptions;
type NoSetterReturnConfiguration =
| RulePlainConfiguration
| RuleWithNoSetterReturnOptions;
type NoSolidDestructuredPropsConfiguration =
| RulePlainConfiguration
| RuleWithNoSolidDestructuredPropsOptions;
type NoStringCaseMismatchConfiguration =
| RulePlainConfiguration
| RuleWithNoStringCaseMismatchOptions;
type NoSwitchDeclarationsConfiguration =
| RulePlainConfiguration
| RuleWithNoSwitchDeclarationsOptions;
type NoUndeclaredDependenciesConfiguration =
| RulePlainConfiguration
| RuleWithNoUndeclaredDependenciesOptions;
type NoUndeclaredVariablesConfiguration =
| RulePlainConfiguration
| RuleWithNoUndeclaredVariablesOptions;
type NoUnknownFunctionConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownFunctionOptions;
type NoUnknownMediaFeatureNameConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownMediaFeatureNameOptions;
type NoUnknownPropertyConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownPropertyOptions;
type NoUnknownPseudoClassConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownPseudoClassOptions;
type NoUnknownPseudoElementConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownPseudoElementOptions;
type NoUnknownTypeSelectorConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownTypeSelectorOptions;
type NoUnknownUnitConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownUnitOptions;
type NoUnmatchableAnbSelectorConfiguration =
| RulePlainConfiguration
| RuleWithNoUnmatchableAnbSelectorOptions;
type NoUnreachableConfiguration =
| RulePlainConfiguration
| RuleWithNoUnreachableOptions;
type NoUnreachableSuperConfiguration =
| RulePlainConfiguration
| RuleWithNoUnreachableSuperOptions;
type NoUnresolvedImportsConfiguration =
| RulePlainConfiguration
| RuleWithNoUnresolvedImportsOptions;
type NoUnsafeFinallyConfiguration =
| RulePlainConfiguration
| RuleWithNoUnsafeFinallyOptions;
type NoUnsafeOptionalChainingConfiguration =
| RulePlainConfiguration
| RuleWithNoUnsafeOptionalChainingOptions;
type NoUnusedFunctionParametersConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedFunctionParametersOptions;
type NoUnusedImportsConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedImportsOptions;
type NoUnusedInstantiationConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedInstantiationOptions;
type NoUnusedLabelsConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedLabelsOptions;
type NoUnusedPrivateClassMembersConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedPrivateClassMembersOptions;
type NoUnusedVariablesConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedVariablesOptions;
type NoVoidElementsWithChildrenConfiguration =
| RulePlainConfiguration
| RuleWithNoVoidElementsWithChildrenOptions;
type NoVoidTypeReturnConfiguration =
| RulePlainConfiguration
| RuleWithNoVoidTypeReturnOptions;
type NoVueDataObjectDeclarationConfiguration =
| RulePlainConfiguration
| RuleWithNoVueDataObjectDeclarationOptions;
type NoVueDuplicateKeysConfiguration =
| RulePlainConfiguration
| RuleWithNoVueDuplicateKeysOptions;
type NoVueReservedKeysConfiguration =
| RulePlainConfiguration
| RuleWithNoVueReservedKeysOptions;
type NoVueReservedPropsConfiguration =
| RulePlainConfiguration
| RuleWithNoVueReservedPropsOptions;
type NoVueSetupPropsReactivityLossConfiguration =
| RulePlainConfiguration
| RuleWithNoVueSetupPropsReactivityLossOptions;
type NoVueVIfWithVForConfiguration =
| RulePlainConfiguration
| RuleWithNoVueVIfWithVForOptions;
type UseExhaustiveDependenciesConfiguration =
| RulePlainConfiguration
| RuleWithUseExhaustiveDependenciesOptions;
type UseGraphqlNamedOperationsConfiguration =
| RulePlainConfiguration
| RuleWithUseGraphqlNamedOperationsOptions;
type UseHookAtTopLevelConfiguration =
| RulePlainConfiguration
| RuleWithUseHookAtTopLevelOptions;
type UseImageSizeConfiguration =
| RulePlainConfiguration
| RuleWithUseImageSizeOptions;
type UseImportExtensionsConfiguration =
| RulePlainConfiguration
| RuleWithUseImportExtensionsOptions;
type UseInlineScriptIdConfiguration =
| RulePlainConfiguration
| RuleWithUseInlineScriptIdOptions;
type UseIsNanConfiguration = RulePlainConfiguration | RuleWithUseIsNanOptions;
type UseJsonImportAttributesConfiguration =
| RulePlainConfiguration
| RuleWithUseJsonImportAttributesOptions;
type UseJsxKeyInIterableConfiguration =
| RulePlainConfiguration
| RuleWithUseJsxKeyInIterableOptions;
type UseLoneAnonymousOperationConfiguration =
| RulePlainConfiguration
| RuleWithUseLoneAnonymousOperationOptions;
type UseParseIntRadixConfiguration =
| RulePlainConfiguration
| RuleWithUseParseIntRadixOptions;
type UseQwikClasslistConfiguration =
| RulePlainConfiguration
| RuleWithUseQwikClasslistOptions;
type UseQwikMethodUsageConfiguration =
| RulePlainConfiguration
| RuleWithUseQwikMethodUsageOptions;
type UseQwikValidLexicalScopeConfiguration =
| RulePlainConfiguration
| RuleWithUseQwikValidLexicalScopeOptions;
type UseSingleJsDocAsteriskConfiguration =
| RulePlainConfiguration
| RuleWithUseSingleJsDocAsteriskOptions;
type UseUniqueElementIdsConfiguration =
| RulePlainConfiguration
| RuleWithUseUniqueElementIdsOptions;
type UseValidForDirectionConfiguration =
| RulePlainConfiguration
| RuleWithUseValidForDirectionOptions;
type UseValidTypeofConfiguration =
| RulePlainConfiguration
| RuleWithUseValidTypeofOptions;
type UseVueVForKeyConfiguration =
| RulePlainConfiguration
| RuleWithUseVueVForKeyOptions;
type UseVueValidTemplateRootConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidTemplateRootOptions;
type UseVueValidVBindConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVBindOptions;
type UseVueValidVCloakConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVCloakOptions;
type UseVueValidVElseConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVElseOptions;
type UseVueValidVElseIfConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVElseIfOptions;
type UseVueValidVHtmlConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVHtmlOptions;
type UseVueValidVIfConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVIfOptions;
type UseVueValidVOnConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVOnOptions;
type UseVueValidVOnceConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVOnceOptions;
type UseVueValidVPreConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVPreOptions;
type UseVueValidVTextConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVTextOptions;
type UseYieldConfiguration = RulePlainConfiguration | RuleWithUseYieldOptions;
type NoBaseToStringConfiguration =
| RulePlainConfiguration
| RuleWithNoBaseToStringOptions;
type NoComponentHookFactoriesConfiguration =
| RulePlainConfiguration
| RuleWithNoComponentHookFactoriesOptions;
type NoConditionalExpectConfiguration =
| RulePlainConfiguration
| RuleWithNoConditionalExpectOptions;
type NoDrizzleDeleteWithoutWhereConfiguration =
| RulePlainConfiguration
| RuleWithNoDrizzleDeleteWithoutWhereOptions;
type NoDrizzleUpdateWithoutWhereConfiguration =
| RulePlainConfiguration
| RuleWithNoDrizzleUpdateWithoutWhereOptions;
type NoDuplicateFieldDefinitionNamesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateFieldDefinitionNamesOptions;
type NoDuplicateSelectorsConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateSelectorsOptions;
type NoEmptyObjectKeysConfiguration =
| RulePlainConfiguration
| RuleWithNoEmptyObjectKeysOptions;
type NoExcessiveNestedCallbacksConfiguration =
| RulePlainConfiguration
| RuleWithNoExcessiveNestedCallbacksOptions;
type NoExcessiveSelectorClassesConfiguration =
| RulePlainConfiguration
| RuleWithNoExcessiveSelectorClassesOptions;
type NoFloatingPromisesConfiguration =
| RulePlainConfiguration
| RuleWithNoFloatingPromisesOptions;
type NoIdenticalTestTitleConfiguration =
| RulePlainConfiguration
| RuleWithNoIdenticalTestTitleOptions;
type NoImpliedEvalConfiguration =
| RulePlainConfiguration
| RuleWithNoImpliedEvalOptions;
type NoInlineStylesConfiguration =
| RulePlainConfiguration
| RuleWithNoInlineStylesOptions;
type NoJsxLeakedDollarConfiguration =
| RulePlainConfiguration
| RuleWithNoJsxLeakedDollarOptions;
type NoJsxNamespaceConfiguration =
| RulePlainConfiguration
| RuleWithNoJsxNamespaceOptions;
type NoLoopFuncConfiguration =
| RulePlainConfiguration
| RuleWithNoLoopFuncOptions;
type NoMisleadingReturnTypeConfiguration =
| RulePlainConfiguration
| RuleWithNoMisleadingReturnTypeOptions;
type NoMisusedPromisesConfiguration =
| RulePlainConfiguration
| RuleWithNoMisusedPromisesOptions;
type NoNegationInEqualityCheckConfiguration =
| RulePlainConfiguration
| RuleWithNoNegationInEqualityCheckOptions;
type NoPlaywrightElementHandleConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightElementHandleOptions;
type NoPlaywrightEvalConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightEvalOptions;
type NoPlaywrightForceOptionConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightForceOptionOptions;
type NoPlaywrightMissingAwaitConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightMissingAwaitOptions;
type NoPlaywrightNetworkidleConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightNetworkidleOptions;
type NoPlaywrightPagePauseConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightPagePauseOptions;
type NoPlaywrightUselessAwaitConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightUselessAwaitOptions;
type NoPlaywrightWaitForNavigationConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightWaitForNavigationOptions;
type NoPlaywrightWaitForSelectorConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightWaitForSelectorOptions;
type NoPlaywrightWaitForTimeoutConfiguration =
| RulePlainConfiguration
| RuleWithNoPlaywrightWaitForTimeoutOptions;
type NoReactNativeDeepImportsConfiguration =
| RulePlainConfiguration
| RuleWithNoReactNativeDeepImportsOptions;
type NoReactNativeLiteralColorsConfiguration =
| RulePlainConfiguration
| RuleWithNoReactNativeLiteralColorsOptions;
type NoReactNativeRawTextConfiguration =
| RulePlainConfiguration
| RuleWithNoReactNativeRawTextOptions;
type NoReactStringRefsConfiguration =
| RulePlainConfiguration
| RuleWithNoReactStringRefsOptions;
type NoRestrictedDependenciesConfiguration =
| RulePlainConfiguration
| RuleWithNoRestrictedDependenciesOptions;
type NoSvelteUnnecessaryStateWrapConfiguration =
| RulePlainConfiguration
| RuleWithNoSvelteUnnecessaryStateWrapOptions;
type NoTopLevelLiteralsConfiguration =
| RulePlainConfiguration
| RuleWithNoTopLevelLiteralsOptions;
type NoUndeclaredClassesConfiguration =
| RulePlainConfiguration
| RuleWithNoUndeclaredClassesOptions;
type NoUnnecessaryTemplateExpressionConfiguration =
| RulePlainConfiguration
| RuleWithNoUnnecessaryTemplateExpressionOptions;
type NoUnsafePlusOperandsConfiguration =
| RulePlainConfiguration
| RuleWithNoUnsafePlusOperandsOptions;
type NoUntrustedLicensesConfiguration =
| RulePlainConfiguration
| RuleWithNoUntrustedLicensesOptions;
type NoUnusedClassesConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedClassesOptions;
type NoUselessTypeConversionConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessTypeConversionOptions;
type NoVueImportCompilerMacrosConfiguration =
| RulePlainConfiguration
| RuleWithNoVueImportCompilerMacrosOptions;
type NoVueRefAsOperandConfiguration =
| RulePlainConfiguration
| RuleWithNoVueRefAsOperandOptions;
type NoVueVOnNumberValuesConfiguration =
| RulePlainConfiguration
| RuleWithNoVueVOnNumberValuesOptions;
type UseArraySomeConfiguration =
| RulePlainConfiguration
| RuleWithUseArraySomeOptions;
type UseAwaitThenableConfiguration =
| RulePlainConfiguration
| RuleWithUseAwaitThenableOptions;
type UseBaselineConfiguration =
| RulePlainConfiguration
| RuleWithUseBaselineOptions;
type UseConsistentTestItConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentTestItOptions;
type UseDisposablesConfiguration =
| RulePlainConfiguration
| RuleWithUseDisposablesOptions;
type UseDomNodeTextContentConfiguration =
| RulePlainConfiguration
| RuleWithUseDomNodeTextContentOptions;
type UseDomQuerySelectorConfiguration =
| RulePlainConfiguration
| RuleWithUseDomQuerySelectorOptions;
type UseExhaustiveSwitchCasesConfiguration =
| RulePlainConfiguration
| RuleWithUseExhaustiveSwitchCasesOptions;
type UseExpectConfiguration = RulePlainConfiguration | RuleWithUseExpectOptions;
type UseExplicitReturnTypeConfiguration =
| RulePlainConfiguration
| RuleWithUseExplicitReturnTypeOptions;
type UseExplicitTypeConfiguration =
| RulePlainConfiguration
| RuleWithUseExplicitTypeOptions;
type UseIframeSandboxConfiguration =
| RulePlainConfiguration
| RuleWithUseIframeSandboxOptions;
type UseImportsFirstConfiguration =
| RulePlainConfiguration
| RuleWithUseImportsFirstOptions;
type UseIncludesConfiguration =
| RulePlainConfiguration
| RuleWithUseIncludesOptions;
type UseMathMinMaxConfiguration =
| RulePlainConfiguration
| RuleWithUseMathMinMaxOptions;
type UseNamedCaptureGroupConfiguration =
| RulePlainConfiguration
| RuleWithUseNamedCaptureGroupOptions;
type UseNullishCoalescingConfiguration =
| RulePlainConfiguration
| RuleWithUseNullishCoalescingOptions;
type UsePlaywrightValidDescribeCallbackConfiguration =
| RulePlainConfiguration
| RuleWithUsePlaywrightValidDescribeCallbackOptions;
type UseQwikLoaderLocationConfiguration =
| RulePlainConfiguration
| RuleWithUseQwikLoaderLocationOptions;
type UseReactAsyncServerFunctionConfiguration =
| RulePlainConfiguration
| RuleWithUseReactAsyncServerFunctionOptions;
type UseReactFunctionComponentDefinitionConfiguration =
| RulePlainConfiguration
| RuleWithUseReactFunctionComponentDefinitionOptions;
type UseReactNativePlatformComponentsConfiguration =
| RulePlainConfiguration
| RuleWithUseReactNativePlatformComponentsOptions;
type UseReduceTypeParameterConfiguration =
| RulePlainConfiguration
| RuleWithUseReduceTypeParameterOptions;
type UseRegexpExecConfiguration =
| RulePlainConfiguration
| RuleWithUseRegexpExecOptions;
type UseRegexpTestConfiguration =
| RulePlainConfiguration
| RuleWithUseRegexpTestOptions;
type UseScopedStylesConfiguration =
| RulePlainConfiguration
| RuleWithUseScopedStylesOptions;
type UseSortedClassesConfiguration =
| RulePlainConfiguration
| RuleWithUseSortedClassesOptions;
type UseStringStartsEndsWithConfiguration =
| RulePlainConfiguration
| RuleWithUseStringStartsEndsWithOptions;
type UseSvelteRequireEachKeyConfiguration =
| RulePlainConfiguration
| RuleWithUseSvelteRequireEachKeyOptions;
type UseTestHooksInOrderConfiguration =
| RulePlainConfiguration
| RuleWithUseTestHooksInOrderOptions;
type UseTestHooksOnTopConfiguration =
| RulePlainConfiguration
| RuleWithUseTestHooksOnTopOptions;
type UseThisInClassMethodsConfiguration =
| RulePlainConfiguration
| RuleWithUseThisInClassMethodsOptions;
type UseUnicodeRegexConfiguration =
| RulePlainConfiguration
| RuleWithUseUnicodeRegexOptions;
type UseVarsOnTopConfiguration =
| RulePlainConfiguration
| RuleWithUseVarsOnTopOptions;
type UseVueConsistentDefinePropsDeclarationConfiguration =
| RulePlainConfiguration
| RuleWithUseVueConsistentDefinePropsDeclarationOptions;
type UseVueNextTickPromiseConfiguration =
| RulePlainConfiguration
| RuleWithUseVueNextTickPromiseOptions;
type UseVueValidVForConfiguration =
| RulePlainConfiguration
| RuleWithUseVueValidVForOptions;
type NoAccumulatingSpreadConfiguration =
| RulePlainConfiguration
| RuleWithNoAccumulatingSpreadOptions;
type NoAwaitInLoopsConfiguration =
| RulePlainConfiguration
| RuleWithNoAwaitInLoopsOptions;
type NoBarrelFileConfiguration =
| RulePlainConfiguration
| RuleWithNoBarrelFileOptions;
type NoDeleteConfiguration = RulePlainConfiguration | RuleWithNoDeleteOptions;
type NoDynamicNamespaceImportAccessConfiguration =
| RulePlainConfiguration
| RuleWithNoDynamicNamespaceImportAccessOptions;
type NoImgElementConfiguration =
| RulePlainConfiguration
| RuleWithNoImgElementOptions;
type NoJsxPropsBindConfiguration =
| RulePlainConfiguration
| RuleWithNoJsxPropsBindOptions;
type NoNamespaceImportConfiguration =
| RulePlainConfiguration
| RuleWithNoNamespaceImportOptions;
type NoReExportAllConfiguration =
| RulePlainConfiguration
| RuleWithNoReExportAllOptions;
type NoSyncScriptsConfiguration =
| RulePlainConfiguration
| RuleWithNoSyncScriptsOptions;
type NoUnwantedPolyfillioConfiguration =
| RulePlainConfiguration
| RuleWithNoUnwantedPolyfillioOptions;
type UseGoogleFontPreconnectConfiguration =
| RulePlainConfiguration
| RuleWithUseGoogleFontPreconnectOptions;
type UseSolidForComponentConfiguration =
| RulePlainConfiguration
| RuleWithUseSolidForComponentOptions;
type UseTopLevelRegexConfiguration =
| RulePlainConfiguration
| RuleWithUseTopLevelRegexOptions;
type UseVueVaporConfiguration =
| RulePlainConfiguration
| RuleWithUseVueVaporOptions;
type NoBlankTargetConfiguration =
| RulePlainConfiguration
| RuleWithNoBlankTargetOptions;
type NoDangerouslySetInnerHtmlConfiguration =
| RulePlainConfiguration
| RuleWithNoDangerouslySetInnerHtmlOptions;
type NoDangerouslySetInnerHtmlWithChildrenConfiguration =
| RulePlainConfiguration
| RuleWithNoDangerouslySetInnerHtmlWithChildrenOptions;
type NoGlobalEvalConfiguration =
| RulePlainConfiguration
| RuleWithNoGlobalEvalOptions;
type NoScriptUrlConfiguration =
| RulePlainConfiguration
| RuleWithNoScriptUrlOptions;
type NoSecretsConfiguration = RulePlainConfiguration | RuleWithNoSecretsOptions;
type NoCommonJsConfiguration =
| RulePlainConfiguration
| RuleWithNoCommonJsOptions;
type NoContinueConfiguration =
| RulePlainConfiguration
| RuleWithNoContinueOptions;
type NoDefaultExportConfiguration =
| RulePlainConfiguration
| RuleWithNoDefaultExportOptions;
type NoDescendingSpecificityConfiguration =
| RulePlainConfiguration
| RuleWithNoDescendingSpecificityOptions;
type NoDoneCallbackConfiguration =
| RulePlainConfiguration
| RuleWithNoDoneCallbackOptions;
type NoEnumConfiguration = RulePlainConfiguration | RuleWithNoEnumOptions;
type NoExcessiveClassesPerFileConfiguration =
| RulePlainConfiguration
| RuleWithNoExcessiveClassesPerFileOptions;
type NoExcessiveLinesPerFileConfiguration =
| RulePlainConfiguration
| RuleWithNoExcessiveLinesPerFileOptions;
type NoExportedImportsConfiguration =
| RulePlainConfiguration
| RuleWithNoExportedImportsOptions;
type NoHeadElementConfiguration =
| RulePlainConfiguration
| RuleWithNoHeadElementOptions;
type NoHexColorsConfiguration =
| RulePlainConfiguration
| RuleWithNoHexColorsOptions;
type NoImplicitBooleanConfiguration =
| RulePlainConfiguration
| RuleWithNoImplicitBooleanOptions;
type NoIncrementDecrementConfiguration =
| RulePlainConfiguration
| RuleWithNoIncrementDecrementOptions;
type NoInferrableTypesConfiguration =
| RulePlainConfiguration
| RuleWithNoInferrableTypesOptions;
type NoJsxLiteralsConfiguration =
| RulePlainConfiguration
| RuleWithNoJsxLiteralsOptions;
type NoMagicNumbersConfiguration =
| RulePlainConfiguration
| RuleWithNoMagicNumbersOptions;
type NoMultiAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoMultiAssignOptions;
type NoMultilineStringConfiguration =
| RulePlainConfiguration
| RuleWithNoMultilineStringOptions;
type NoNamespaceConfiguration =
| RulePlainConfiguration
| RuleWithNoNamespaceOptions;
type NoNegationElseConfiguration =
| RulePlainConfiguration
| RuleWithNoNegationElseOptions;
type NoNestedTernaryConfiguration =
| RulePlainConfiguration
| RuleWithNoNestedTernaryOptions;
type NoNonNullAssertionConfiguration =
| RulePlainConfiguration
| RuleWithNoNonNullAssertionOptions;
type NoParameterAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoParameterAssignOptions;
type NoParameterPropertiesConfiguration =
| RulePlainConfiguration
| RuleWithNoParameterPropertiesOptions;
type NoProcessEnvConfiguration =
| RulePlainConfiguration
| RuleWithNoProcessEnvOptions;
type NoRestrictedGlobalsConfiguration =
| RulePlainConfiguration
| RuleWithNoRestrictedGlobalsOptions;
type NoRestrictedImportsConfiguration =
| RulePlainConfiguration
| RuleWithNoRestrictedImportsOptions;
type NoRestrictedTypesConfiguration =
| RulePlainConfiguration
| RuleWithNoRestrictedTypesOptions;
type NoRootTypeConfiguration =
| RulePlainConfiguration
| RuleWithNoRootTypeOptions;
type NoShoutyConstantsConfiguration =
| RulePlainConfiguration
| RuleWithNoShoutyConstantsOptions;
type NoSubstrConfiguration = RulePlainConfiguration | RuleWithNoSubstrOptions;
type NoTernaryConfiguration = RulePlainConfiguration | RuleWithNoTernaryOptions;
type NoUnusedTemplateLiteralConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedTemplateLiteralOptions;
type NoUselessElseConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessElseOptions;
type NoValueAtRuleConfiguration =
| RulePlainConfiguration
| RuleWithNoValueAtRuleOptions;
type NoVueOptionsApiConfiguration =
| RulePlainConfiguration
| RuleWithNoVueOptionsApiOptions;
type NoYodaExpressionConfiguration =
| RulePlainConfiguration
| RuleWithNoYodaExpressionOptions;
type UseArrayLiteralsConfiguration =
| RulePlainConfiguration
| RuleWithUseArrayLiteralsOptions;
type UseAsConstAssertionConfiguration =
| RulePlainConfiguration
| RuleWithUseAsConstAssertionOptions;
type UseAtIndexConfiguration =
| RulePlainConfiguration
| RuleWithUseAtIndexOptions;
type UseBlockStatementsConfiguration =
| RulePlainConfiguration
| RuleWithUseBlockStatementsOptions;
type UseCollapsedElseIfConfiguration =
| RulePlainConfiguration
| RuleWithUseCollapsedElseIfOptions;
type UseCollapsedIfConfiguration =
| RulePlainConfiguration
| RuleWithUseCollapsedIfOptions;
type UseComponentExportOnlyModulesConfiguration =
| RulePlainConfiguration
| RuleWithUseComponentExportOnlyModulesOptions;
type UseConsistentArrayTypeConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentArrayTypeOptions;
type UseConsistentArrowReturnConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentArrowReturnOptions;
type UseConsistentBuiltinInstantiationConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentBuiltinInstantiationOptions;
type UseConsistentCurlyBracesConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentCurlyBracesOptions;
type UseConsistentEnumValueTypeConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentEnumValueTypeOptions;
type UseConsistentGraphqlDescriptionsConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentGraphqlDescriptionsOptions;
type UseConsistentMemberAccessibilityConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentMemberAccessibilityOptions;
type UseConsistentMethodSignaturesConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentMethodSignaturesOptions;
type UseConsistentObjectDefinitionsConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentObjectDefinitionsOptions;
type UseConsistentTypeDefinitionsConfiguration =
| RulePlainConfiguration
| RuleWithUseConsistentTypeDefinitionsOptions;
type UseConstConfiguration = RulePlainConfiguration | RuleWithUseConstOptions;
type UseDefaultParameterLastConfiguration =
| RulePlainConfiguration
| RuleWithUseDefaultParameterLastOptions;
type UseDefaultSwitchClauseConfiguration =
| RulePlainConfiguration
| RuleWithUseDefaultSwitchClauseOptions;
type UseDeprecatedReasonConfiguration =
| RulePlainConfiguration
| RuleWithUseDeprecatedReasonOptions;
type UseDestructuringConfiguration =
| RulePlainConfiguration
| RuleWithUseDestructuringOptions;
type UseEnumInitializersConfiguration =
| RulePlainConfiguration
| RuleWithUseEnumInitializersOptions;
type UseErrorCauseConfiguration =
| RulePlainConfiguration
| RuleWithUseErrorCauseOptions;
type UseExplicitLengthCheckConfiguration =
| RulePlainConfiguration
| RuleWithUseExplicitLengthCheckOptions;
type UseExponentiationOperatorConfiguration =
| RulePlainConfiguration
| RuleWithUseExponentiationOperatorOptions;
type UseExportTypeConfiguration =
| RulePlainConfiguration
| RuleWithUseExportTypeOptions;
type UseExportsLastConfiguration =
| RulePlainConfiguration
| RuleWithUseExportsLastOptions;
type UseFilenamingConventionConfiguration =
| RulePlainConfiguration
| RuleWithUseFilenamingConventionOptions;
type UseForOfConfiguration = RulePlainConfiguration | RuleWithUseForOfOptions;
type UseFragmentSyntaxConfiguration =
| RulePlainConfiguration
| RuleWithUseFragmentSyntaxOptions;
type UseGlobalThisConfiguration =
| RulePlainConfiguration
| RuleWithUseGlobalThisOptions;
type UseGraphqlNamingConventionConfiguration =
| RulePlainConfiguration
| RuleWithUseGraphqlNamingConventionOptions;
type UseGroupedAccessorPairsConfiguration =
| RulePlainConfiguration
| RuleWithUseGroupedAccessorPairsOptions;
type UseImportTypeConfiguration =
| RulePlainConfiguration
| RuleWithUseImportTypeOptions;
type UseInputNameConfiguration =
| RulePlainConfiguration
| RuleWithUseInputNameOptions;
type UseLiteralEnumMembersConfiguration =
| RulePlainConfiguration
| RuleWithUseLiteralEnumMembersOptions;
type UseLoneExecutableDefinitionConfiguration =
| RulePlainConfiguration
| RuleWithUseLoneExecutableDefinitionOptions;
type UseNamingConventionConfiguration =
| RulePlainConfiguration
| RuleWithUseNamingConventionOptions;
type UseNodeAssertStrictConfiguration =
| RulePlainConfiguration
| RuleWithUseNodeAssertStrictOptions;
type UseNodejsImportProtocolConfiguration =
| RulePlainConfiguration
| RuleWithUseNodejsImportProtocolOptions;
type UseNumberNamespaceConfiguration =
| RulePlainConfiguration
| RuleWithUseNumberNamespaceOptions;
type UseNumericSeparatorsConfiguration =
| RulePlainConfiguration
| RuleWithUseNumericSeparatorsOptions;
type UseObjectSpreadConfiguration =
| RulePlainConfiguration
| RuleWithUseObjectSpreadOptions;
type UseReactFunctionComponentsConfiguration =
| RulePlainConfiguration
| RuleWithUseReactFunctionComponentsOptions;
type UseReadonlyClassPropertiesConfiguration =
| RulePlainConfiguration
| RuleWithUseReadonlyClassPropertiesOptions;
type UseSelfClosingElementsConfiguration =
| RulePlainConfiguration
| RuleWithUseSelfClosingElementsOptions;
type UseShorthandAssignConfiguration =
| RulePlainConfiguration
| RuleWithUseShorthandAssignOptions;
type UseShorthandFunctionTypeConfiguration =
| RulePlainConfiguration
| RuleWithUseShorthandFunctionTypeOptions;
type UseSingleVarDeclaratorConfiguration =
| RulePlainConfiguration
| RuleWithUseSingleVarDeclaratorOptions;
type UseSpreadOverApplyConfiguration =
| RulePlainConfiguration
| RuleWithUseSpreadOverApplyOptions;
type UseSymbolDescriptionConfiguration =
| RulePlainConfiguration
| RuleWithUseSymbolDescriptionOptions;
type UseTemplateConfiguration =
| RulePlainConfiguration
| RuleWithUseTemplateOptions;
type UseThrowNewErrorConfiguration =
| RulePlainConfiguration
| RuleWithUseThrowNewErrorOptions;
type UseThrowOnlyErrorConfiguration =
| RulePlainConfiguration
| RuleWithUseThrowOnlyErrorOptions;
type UseTrimStartEndConfiguration =
| RulePlainConfiguration
| RuleWithUseTrimStartEndOptions;
type UseUnifiedTypeSignaturesConfiguration =
| RulePlainConfiguration
| RuleWithUseUnifiedTypeSignaturesOptions;
type UseVueConsistentVBindStyleConfiguration =
| RulePlainConfiguration
| RuleWithUseVueConsistentVBindStyleOptions;
type UseVueConsistentVOnStyleConfiguration =
| RulePlainConfiguration
| RuleWithUseVueConsistentVOnStyleOptions;
type UseVueDefineMacrosOrderConfiguration =
| RulePlainConfiguration
| RuleWithUseVueDefineMacrosOrderOptions;
type UseVueHyphenatedAttributesConfiguration =
| RulePlainConfiguration
| RuleWithUseVueHyphenatedAttributesOptions;
type UseVueMultiWordComponentNamesConfiguration =
| RulePlainConfiguration
| RuleWithUseVueMultiWordComponentNamesOptions;
type NoAlertConfiguration = RulePlainConfiguration | RuleWithNoAlertOptions;
type NoApproximativeNumericConstantConfiguration =
| RulePlainConfiguration
| RuleWithNoApproximativeNumericConstantOptions;
type NoArrayIndexKeyConfiguration =
| RulePlainConfiguration
| RuleWithNoArrayIndexKeyOptions;
type NoAssignInExpressionsConfiguration =
| RulePlainConfiguration
| RuleWithNoAssignInExpressionsOptions;
type NoAsyncPromiseExecutorConfiguration =
| RulePlainConfiguration
| RuleWithNoAsyncPromiseExecutorOptions;
type NoBiomeFirstExceptionConfiguration =
| RulePlainConfiguration
| RuleWithNoBiomeFirstExceptionOptions;
type NoBitwiseOperatorsConfiguration =
| RulePlainConfiguration
| RuleWithNoBitwiseOperatorsOptions;
type NoCatchAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoCatchAssignOptions;
type NoClassAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoClassAssignOptions;
type NoCommentTextConfiguration =
| RulePlainConfiguration
| RuleWithNoCommentTextOptions;
type NoCompareNegZeroConfiguration =
| RulePlainConfiguration
| RuleWithNoCompareNegZeroOptions;
type NoConfusingLabelsConfiguration =
| RulePlainConfiguration
| RuleWithNoConfusingLabelsOptions;
type NoConfusingVoidTypeConfiguration =
| RulePlainConfiguration
| RuleWithNoConfusingVoidTypeOptions;
type NoConsoleConfiguration = RulePlainConfiguration | RuleWithNoConsoleOptions;
type NoConstEnumConfiguration =
| RulePlainConfiguration
| RuleWithNoConstEnumOptions;
type NoConstantBinaryExpressionsConfiguration =
| RulePlainConfiguration
| RuleWithNoConstantBinaryExpressionsOptions;
type NoControlCharactersInRegexConfiguration =
| RulePlainConfiguration
| RuleWithNoControlCharactersInRegexOptions;
type NoDebuggerConfiguration =
| RulePlainConfiguration
| RuleWithNoDebuggerOptions;
type NoDeprecatedImportsConfiguration =
| RulePlainConfiguration
| RuleWithNoDeprecatedImportsOptions;
type NoDeprecatedMediaTypeConfiguration =
| RulePlainConfiguration
| RuleWithNoDeprecatedMediaTypeOptions;
type NoDocumentCookieConfiguration =
| RulePlainConfiguration
| RuleWithNoDocumentCookieOptions;
type NoDocumentImportInPageConfiguration =
| RulePlainConfiguration
| RuleWithNoDocumentImportInPageOptions;
type NoDoubleEqualsConfiguration =
| RulePlainConfiguration
| RuleWithNoDoubleEqualsOptions;
type NoDuplicateAtImportRulesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateAtImportRulesOptions;
type NoDuplicateCaseConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateCaseOptions;
type NoDuplicateClassMembersConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateClassMembersOptions;
type NoDuplicateCustomPropertiesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateCustomPropertiesOptions;
type NoDuplicateDependenciesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateDependenciesOptions;
type NoDuplicateElseIfConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateElseIfOptions;
type NoDuplicateEnumValuesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateEnumValuesOptions;
type NoDuplicateFieldsConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateFieldsOptions;
type NoDuplicateFontNamesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateFontNamesOptions;
type NoDuplicateGraphqlOperationNameConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateGraphqlOperationNameOptions;
type NoDuplicateJsxPropsConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateJsxPropsOptions;
type NoDuplicateObjectKeysConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateObjectKeysOptions;
type NoDuplicateParametersConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateParametersOptions;
type NoDuplicatePropertiesConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicatePropertiesOptions;
type NoDuplicateSelectorsKeyframeBlockConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateSelectorsKeyframeBlockOptions;
type NoDuplicateTestHooksConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicateTestHooksOptions;
type NoDuplicatedSpreadPropsConfiguration =
| RulePlainConfiguration
| RuleWithNoDuplicatedSpreadPropsOptions;
type NoEmptyBlockConfiguration =
| RulePlainConfiguration
| RuleWithNoEmptyBlockOptions;
type NoEmptyBlockStatementsConfiguration =
| RulePlainConfiguration
| RuleWithNoEmptyBlockStatementsOptions;
type NoEmptyInterfaceConfiguration =
| RulePlainConfiguration
| RuleWithNoEmptyInterfaceOptions;
type NoEmptySourceConfiguration =
| RulePlainConfiguration
| RuleWithNoEmptySourceOptions;
type NoEqualsToNullConfiguration =
| RulePlainConfiguration
| RuleWithNoEqualsToNullOptions;
type NoEvolvingTypesConfiguration =
| RulePlainConfiguration
| RuleWithNoEvolvingTypesOptions;
type NoExplicitAnyConfiguration =
| RulePlainConfiguration
| RuleWithNoExplicitAnyOptions;
type NoExportsInTestConfiguration =
| RulePlainConfiguration
| RuleWithNoExportsInTestOptions;
type NoExtraNonNullAssertionConfiguration =
| RulePlainConfiguration
| RuleWithNoExtraNonNullAssertionOptions;
type NoFallthroughSwitchClauseConfiguration =
| RulePlainConfiguration
| RuleWithNoFallthroughSwitchClauseOptions;
type NoFocusedTestsConfiguration =
| RulePlainConfiguration
| RuleWithNoFocusedTestsOptions;
type NoForInConfiguration = RulePlainConfiguration | RuleWithNoForInOptions;
type NoFunctionAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoFunctionAssignOptions;
type NoGlobalAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoGlobalAssignOptions;
type NoGlobalIsFiniteConfiguration =
| RulePlainConfiguration
| RuleWithNoGlobalIsFiniteOptions;
type NoGlobalIsNanConfiguration =
| RulePlainConfiguration
| RuleWithNoGlobalIsNanOptions;
type NoHeadImportInDocumentConfiguration =
| RulePlainConfiguration
| RuleWithNoHeadImportInDocumentOptions;
type NoImplicitAnyLetConfiguration =
| RulePlainConfiguration
| RuleWithNoImplicitAnyLetOptions;
type NoImportAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoImportAssignOptions;
type NoImportCyclesConfiguration =
| RulePlainConfiguration
| RuleWithNoImportCyclesOptions;
type NoImportantInKeyframeConfiguration =
| RulePlainConfiguration
| RuleWithNoImportantInKeyframeOptions;
type NoIrregularWhitespaceConfiguration =
| RulePlainConfiguration
| RuleWithNoIrregularWhitespaceOptions;
type NoLabelVarConfiguration =
| RulePlainConfiguration
| RuleWithNoLabelVarOptions;
type NoLeakedRenderConfiguration =
| RulePlainConfiguration
| RuleWithNoLeakedRenderOptions;
type NoMisleadingCharacterClassConfiguration =
| RulePlainConfiguration
| RuleWithNoMisleadingCharacterClassOptions;
type NoMisleadingInstantiatorConfiguration =
| RulePlainConfiguration
| RuleWithNoMisleadingInstantiatorOptions;
type NoMisplacedAssertionConfiguration =
| RulePlainConfiguration
| RuleWithNoMisplacedAssertionOptions;
type NoMisrefactoredShorthandAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoMisrefactoredShorthandAssignOptions;
type NoNestedPromisesConfiguration =
| RulePlainConfiguration
| RuleWithNoNestedPromisesOptions;
type NoNonNullAssertedOptionalChainConfiguration =
| RulePlainConfiguration
| RuleWithNoNonNullAssertedOptionalChainOptions;
type NoOctalEscapeConfiguration =
| RulePlainConfiguration
| RuleWithNoOctalEscapeOptions;
type NoParametersOnlyUsedInRecursionConfiguration =
| RulePlainConfiguration
| RuleWithNoParametersOnlyUsedInRecursionOptions;
type NoProtoConfiguration = RulePlainConfiguration | RuleWithNoProtoOptions;
type NoPrototypeBuiltinsConfiguration =
| RulePlainConfiguration
| RuleWithNoPrototypeBuiltinsOptions;
type NoQuickfixBiomeConfiguration =
| RulePlainConfiguration
| RuleWithNoQuickfixBiomeOptions;
type NoReactForwardRefConfiguration =
| RulePlainConfiguration
| RuleWithNoReactForwardRefOptions;
type NoReactSpecificPropsConfiguration =
| RulePlainConfiguration
| RuleWithNoReactSpecificPropsOptions;
type NoRedeclareConfiguration =
| RulePlainConfiguration
| RuleWithNoRedeclareOptions;
type NoRedundantUseStrictConfiguration =
| RulePlainConfiguration
| RuleWithNoRedundantUseStrictOptions;
type NoReturnAssignConfiguration =
| RulePlainConfiguration
| RuleWithNoReturnAssignOptions;
type NoSelfCompareConfiguration =
| RulePlainConfiguration
| RuleWithNoSelfCompareOptions;
type NoShadowConfiguration = RulePlainConfiguration | RuleWithNoShadowOptions;
type NoShadowRestrictedNamesConfiguration =
| RulePlainConfiguration
| RuleWithNoShadowRestrictedNamesOptions;
type NoShorthandPropertyOverridesConfiguration =
| RulePlainConfiguration
| RuleWithNoShorthandPropertyOverridesOptions;
type NoSkippedTestsConfiguration =
| RulePlainConfiguration
| RuleWithNoSkippedTestsOptions;
type NoSparseArrayConfiguration =
| RulePlainConfiguration
| RuleWithNoSparseArrayOptions;
type NoSuspiciousSemicolonInJsxConfiguration =
| RulePlainConfiguration
| RuleWithNoSuspiciousSemicolonInJsxOptions;
type NoTemplateCurlyInStringConfiguration =
| RulePlainConfiguration
| RuleWithNoTemplateCurlyInStringOptions;
type NoThenPropertyConfiguration =
| RulePlainConfiguration
| RuleWithNoThenPropertyOptions;
type NoTsIgnoreConfiguration =
| RulePlainConfiguration
| RuleWithNoTsIgnoreOptions;
type NoUnassignedVariablesConfiguration =
| RulePlainConfiguration
| RuleWithNoUnassignedVariablesOptions;
type NoUndeclaredEnvVarsConfiguration =
| RulePlainConfiguration
| RuleWithNoUndeclaredEnvVarsOptions;
type NoUnknownAtRulesConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownAtRulesOptions;
type NoUnknownAttributeConfiguration =
| RulePlainConfiguration
| RuleWithNoUnknownAttributeOptions;
type NoUnnecessaryConditionsConfiguration =
| RulePlainConfiguration
| RuleWithNoUnnecessaryConditionsOptions;
type NoUnsafeDeclarationMergingConfiguration =
| RulePlainConfiguration
| RuleWithNoUnsafeDeclarationMergingOptions;
type NoUnsafeNegationConfiguration =
| RulePlainConfiguration
| RuleWithNoUnsafeNegationOptions;
type NoUnusedExpressionsConfiguration =
| RulePlainConfiguration
| RuleWithNoUnusedExpressionsOptions;
type NoUselessEscapeInStringConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessEscapeInStringOptions;
type NoUselessRegexBackrefsConfiguration =
| RulePlainConfiguration
| RuleWithNoUselessRegexBackrefsOptions;
type NoVarConfiguration = RulePlainConfiguration | RuleWithNoVarOptions;
type NoVueArrowFuncInWatchConfiguration =
| RulePlainConfiguration
| RuleWithNoVueArrowFuncInWatchOptions;
type NoWithConfiguration = RulePlainConfiguration | RuleWithNoWithOptions;
type UseAdjacentOverloadSignaturesConfiguration =
| RulePlainConfiguration
| RuleWithUseAdjacentOverloadSignaturesOptions;
type UseArraySortCompareConfiguration =
| RulePlainConfiguration
| RuleWithUseArraySortCompareOptions;
type UseAwaitConfiguration = RulePlainConfiguration | RuleWithUseAwaitOptions;
type UseBiomeIgnoreFolderConfiguration =
| RulePlainConfiguration
| RuleWithUseBiomeIgnoreFolderOptions;
type UseDefaultSwitchClauseLastConfiguration =
| RulePlainConfiguration
| RuleWithUseDefaultSwitchClauseLastOptions;
type UseDeprecatedDateConfiguration =
| RulePlainConfiguration
| RuleWithUseDeprecatedDateOptions;
type UseErrorMessageConfiguration =
| RulePlainConfiguration
| RuleWithUseErrorMessageOptions;
type UseGetterReturnConfiguration =
| RulePlainConfiguration
| RuleWithUseGetterReturnOptions;
type UseGoogleFontDisplayConfiguration =
| RulePlainConfiguration
| RuleWithUseGoogleFontDisplayOptions;
type UseGuardForInConfiguration =
| RulePlainConfiguration
| RuleWithUseGuardForInOptions;
type UseIsArrayConfiguration =
| RulePlainConfiguration
| RuleWithUseIsArrayOptions;
type UseIterableCallbackReturnConfiguration =
| RulePlainConfiguration
| RuleWithUseIterableCallbackReturnOptions;
type UseNamespaceKeywordConfiguration =
| RulePlainConfiguration
| RuleWithUseNamespaceKeywordOptions;
type UseNumberToFixedDigitsArgumentConfiguration =
| RulePlainConfiguration
| RuleWithUseNumberToFixedDigitsArgumentOptions;
type UseRequiredScriptsConfiguration =
| RulePlainConfiguration
| RuleWithUseRequiredScriptsOptions;
type UseStaticResponseMethodsConfiguration =
| RulePlainConfiguration
| RuleWithUseStaticResponseMethodsOptions;
type UseStrictModeConfiguration =
| RulePlainConfiguration
| RuleWithUseStrictModeOptions;
interface NoDuplicateClassesOptions {
    /**
     * Additional attributes that will be sorted.
     */
    attributes?: string[];
    /**
     * Names of the functions or tagged templates that will be sorted.
     */
    functions?: string[];
}
interface OrganizeImportsOptions {
    /**
     * Groups to change how imports and exports are sorted.
     */
    groups?: ImportGroups;
    /**
     * Order used for sorting identifiers within imports and exports.

    Default: `natural`.
     */
    identifierOrder?: SortOrder;
    /**
     * If `true`, bare imports such as `import "module"` are sorted with other imports.
     */
    sortBareImports?: boolean;
}
interface UseSortedAttributesOptions {
    sortOrder?: SortOrder;
}
type UseSortedEnumMembersOptions = {};
type UseSortedInterfaceMembersOptions = {};
interface UseSortedKeysOptions {
    /**
     * When enabled, groups object keys by their value's nesting depth before sorting.
    Simple values (primitives, single-line arrays, single-line objects) are sorted first,
    followed by nested values (multi-line objects, multi-line arrays).
     */
    groupByNesting?: boolean;
    sortOrder?: SortOrder;
}
type UseSortedPackageJsonOptions = {};
type UseSortedPropertiesOptions = {};
type UseSortedSelectionSetOptions = {};
type UseSortedTypeFieldsOptions = {};
type RulePlainConfiguration = "off" | "on" | "info" | "warn" | "error";
interface RuleWithNoAccessKeyOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoAccessKeyOptions;
}
interface RuleWithNoAmbiguousAnchorTextOptions {
    level: RulePlainConfiguration;
    options?: NoAmbiguousAnchorTextOptions;
}
interface RuleWithNoAriaHiddenOnFocusableOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoAriaHiddenOnFocusableOptions;
}
interface RuleWithNoAriaUnsupportedElementsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoAriaUnsupportedElementsOptions;
}
interface RuleWithNoAutofocusOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoAutofocusOptions;
}
interface RuleWithNoDistractingElementsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoDistractingElementsOptions;
}
interface RuleWithNoHeaderScopeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoHeaderScopeOptions;
}
interface RuleWithNoInteractiveElementToNoninteractiveRoleOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoInteractiveElementToNoninteractiveRoleOptions;
}
interface RuleWithNoLabelWithoutControlOptions {
    level: RulePlainConfiguration;
    options?: NoLabelWithoutControlOptions;
}
interface RuleWithNoNoninteractiveElementInteractionsOptions {
    level: RulePlainConfiguration;
    options?: NoNoninteractiveElementInteractionsOptions;
}
interface RuleWithNoNoninteractiveElementToInteractiveRoleOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoNoninteractiveElementToInteractiveRoleOptions;
}
interface RuleWithNoNoninteractiveTabindexOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoNoninteractiveTabindexOptions;
}
interface RuleWithNoPositiveTabindexOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoPositiveTabindexOptions;
}
interface RuleWithNoRedundantAltOptions {
    level: RulePlainConfiguration;
    options?: NoRedundantAltOptions;
}
interface RuleWithNoRedundantRolesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoRedundantRolesOptions;
}
interface RuleWithNoStaticElementInteractionsOptions {
    level: RulePlainConfiguration;
    options?: NoStaticElementInteractionsOptions;
}
interface RuleWithNoSvgWithoutTitleOptions {
    level: RulePlainConfiguration;
    options?: NoSvgWithoutTitleOptions;
}
interface RuleWithUseAltTextOptions {
    level: RulePlainConfiguration;
    options?: UseAltTextOptions;
}
interface RuleWithUseAnchorContentOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseAnchorContentOptions;
}
interface RuleWithUseAriaActivedescendantWithTabindexOptions {
    level: RulePlainConfiguration;
    options?: UseAriaActivedescendantWithTabindexOptions;
}
interface RuleWithUseAriaPropsForRoleOptions {
    level: RulePlainConfiguration;
    options?: UseAriaPropsForRoleOptions;
}
interface RuleWithUseAriaPropsSupportedByRoleOptions {
    level: RulePlainConfiguration;
    options?: UseAriaPropsSupportedByRoleOptions;
}
interface RuleWithUseButtonTypeOptions {
    level: RulePlainConfiguration;
    options?: UseButtonTypeOptions;
}
interface RuleWithUseFocusableInteractiveOptions {
    level: RulePlainConfiguration;
    options?: UseFocusableInteractiveOptions;
}
interface RuleWithUseGenericFontNamesOptions {
    level: RulePlainConfiguration;
    options?: UseGenericFontNamesOptions;
}
interface RuleWithUseHeadingContentOptions {
    level: RulePlainConfiguration;
    options?: UseHeadingContentOptions;
}
interface RuleWithUseHtmlLangOptions {
    level: RulePlainConfiguration;
    options?: UseHtmlLangOptions;
}
interface RuleWithUseIframeTitleOptions {
    level: RulePlainConfiguration;
    options?: UseIframeTitleOptions;
}
interface RuleWithUseKeyWithClickEventsOptions {
    level: RulePlainConfiguration;
    options?: UseKeyWithClickEventsOptions;
}
interface RuleWithUseKeyWithMouseEventsOptions {
    level: RulePlainConfiguration;
    options?: UseKeyWithMouseEventsOptions;
}
interface RuleWithUseMediaCaptionOptions {
    level: RulePlainConfiguration;
    options?: UseMediaCaptionOptions;
}
interface RuleWithUseSemanticElementsOptions {
    level: RulePlainConfiguration;
    options?: UseSemanticElementsOptions;
}
interface RuleWithUseValidAnchorOptions {
    level: RulePlainConfiguration;
    options?: UseValidAnchorOptions;
}
interface RuleWithUseValidAriaPropsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseValidAriaPropsOptions;
}
interface RuleWithUseValidAriaRoleOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseValidAriaRoleOptions;
}
interface RuleWithUseValidAriaValuesOptions {
    level: RulePlainConfiguration;
    options?: UseValidAriaValuesOptions;
}
interface RuleWithUseValidAutocompleteOptions {
    level: RulePlainConfiguration;
    options?: UseValidAutocompleteOptions;
}
interface RuleWithUseValidLangOptions {
    level: RulePlainConfiguration;
    options?: UseValidLangOptions;
}
interface RuleWithNoAdjacentSpacesInRegexOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoAdjacentSpacesInRegexOptions;
}
interface RuleWithNoArgumentsOptions {
    level: RulePlainConfiguration;
    options?: NoArgumentsOptions;
}
interface RuleWithNoBannedTypesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoBannedTypesOptions;
}
interface RuleWithNoCommaOperatorOptions {
    level: RulePlainConfiguration;
    options?: NoCommaOperatorOptions;
}
interface RuleWithNoDivRegexOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoDivRegexOptions;
}
interface RuleWithNoEmptyTypeParametersOptions {
    level: RulePlainConfiguration;
    options?: NoEmptyTypeParametersOptions;
}
interface RuleWithNoExcessiveCognitiveComplexityOptions {
    level: RulePlainConfiguration;
    options?: NoExcessiveCognitiveComplexityOptions;
}
interface RuleWithNoExcessiveLinesPerFunctionOptions {
    level: RulePlainConfiguration;
    options?: NoExcessiveLinesPerFunctionOptions;
}
interface RuleWithNoExcessiveNestedTestSuitesOptions {
    level: RulePlainConfiguration;
    options?: NoExcessiveNestedTestSuitesOptions;
}
interface RuleWithNoExtraBooleanCastOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoExtraBooleanCastOptions;
}
interface RuleWithNoFlatMapIdentityOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoFlatMapIdentityOptions;
}
interface RuleWithNoForEachOptions {
    level: RulePlainConfiguration;
    options?: NoForEachOptions;
}
interface RuleWithNoImplicitCoercionsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoImplicitCoercionsOptions;
}
interface RuleWithNoImportantStylesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoImportantStylesOptions;
}
interface RuleWithNoRedundantDefaultExportOptions {
    level: RulePlainConfiguration;
    options?: NoRedundantDefaultExportOptions;
}
interface RuleWithNoStaticOnlyClassOptions {
    level: RulePlainConfiguration;
    options?: NoStaticOnlyClassOptions;
}
interface RuleWithNoThisInStaticOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoThisInStaticOptions;
}
interface RuleWithNoUselessCatchOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessCatchOptions;
}
interface RuleWithNoUselessCatchBindingOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessCatchBindingOptions;
}
interface RuleWithNoUselessConstructorOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessConstructorOptions;
}
interface RuleWithNoUselessContinueOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessContinueOptions;
}
interface RuleWithNoUselessEmptyExportOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessEmptyExportOptions;
}
interface RuleWithNoUselessEscapeInRegexOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessEscapeInRegexOptions;
}
interface RuleWithNoUselessFragmentsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessFragmentsOptions;
}
interface RuleWithNoUselessLabelOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessLabelOptions;
}
interface RuleWithNoUselessLoneBlockStatementsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessLoneBlockStatementsOptions;
}
interface RuleWithNoUselessRenameOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessRenameOptions;
}
interface RuleWithNoUselessReturnOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessReturnOptions;
}
interface RuleWithNoUselessStringConcatOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessStringConcatOptions;
}
interface RuleWithNoUselessStringRawOptions {
    level: RulePlainConfiguration;
    options?: NoUselessStringRawOptions;
}
interface RuleWithNoUselessSwitchCaseOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessSwitchCaseOptions;
}
interface RuleWithNoUselessTernaryOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessTernaryOptions;
}
interface RuleWithNoUselessThisAliasOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessThisAliasOptions;
}
interface RuleWithNoUselessTypeConstraintOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessTypeConstraintOptions;
}
interface RuleWithNoUselessUndefinedOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessUndefinedOptions;
}
interface RuleWithNoUselessUndefinedInitializationOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessUndefinedInitializationOptions;
}
interface RuleWithNoVoidOptions {
    level: RulePlainConfiguration;
    options?: NoVoidOptions;
}
interface RuleWithUseArrayFindOptions {
    level: RulePlainConfiguration;
    options?: UseArrayFindOptions;
}
interface RuleWithUseArrowFunctionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseArrowFunctionOptions;
}
interface RuleWithUseDateNowOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseDateNowOptions;
}
interface RuleWithUseFlatMapOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseFlatMapOptions;
}
interface RuleWithUseIndexOfOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseIndexOfOptions;
}
interface RuleWithUseLiteralKeysOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseLiteralKeysOptions;
}
interface RuleWithUseMaxParamsOptions {
    level: RulePlainConfiguration;
    options?: UseMaxParamsOptions;
}
interface RuleWithUseNumericLiteralsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNumericLiteralsOptions;
}
interface RuleWithUseOptionalChainOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseOptionalChainOptions;
}
interface RuleWithUseRegexLiteralsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseRegexLiteralsOptions;
}
interface RuleWithUseSimpleNumberKeysOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseSimpleNumberKeysOptions;
}
interface RuleWithUseSimplifiedLogicExpressionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseSimplifiedLogicExpressionOptions;
}
interface RuleWithUseWhileOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseWhileOptions;
}
interface RuleWithNoBeforeInteractiveScriptOutsideDocumentOptions {
    level: RulePlainConfiguration;
    options?: NoBeforeInteractiveScriptOutsideDocumentOptions;
}
interface RuleWithNoChildrenPropOptions {
    level: RulePlainConfiguration;
    options?: NoChildrenPropOptions;
}
interface RuleWithNoConstAssignOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoConstAssignOptions;
}
interface RuleWithNoConstantConditionOptions {
    level: RulePlainConfiguration;
    options?: NoConstantConditionOptions;
}
interface RuleWithNoConstantMathMinMaxClampOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoConstantMathMinMaxClampOptions;
}
interface RuleWithNoConstructorReturnOptions {
    level: RulePlainConfiguration;
    options?: NoConstructorReturnOptions;
}
interface RuleWithNoDuplicateArgumentNamesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateArgumentNamesOptions;
}
interface RuleWithNoDuplicateAttributesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateAttributesOptions;
}
interface RuleWithNoDuplicateEnumValueNamesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateEnumValueNamesOptions;
}
interface RuleWithNoDuplicateInputFieldNamesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateInputFieldNamesOptions;
}
interface RuleWithNoDuplicateVariableNamesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateVariableNamesOptions;
}
interface RuleWithNoEmptyCharacterClassInRegexOptions {
    level: RulePlainConfiguration;
    options?: NoEmptyCharacterClassInRegexOptions;
}
interface RuleWithNoEmptyPatternOptions {
    level: RulePlainConfiguration;
    options?: NoEmptyPatternOptions;
}
interface RuleWithNoGlobalDirnameFilenameOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoGlobalDirnameFilenameOptions;
}
interface RuleWithNoGlobalObjectCallsOptions {
    level: RulePlainConfiguration;
    options?: NoGlobalObjectCallsOptions;
}
interface RuleWithNoInnerDeclarationsOptions {
    level: RulePlainConfiguration;
    options?: NoInnerDeclarationsOptions;
}
interface RuleWithNoInvalidBuiltinInstantiationOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoInvalidBuiltinInstantiationOptions;
}
interface RuleWithNoInvalidConstructorSuperOptions {
    level: RulePlainConfiguration;
    options?: NoInvalidConstructorSuperOptions;
}
interface RuleWithNoInvalidDirectionInLinearGradientOptions {
    level: RulePlainConfiguration;
    options?: NoInvalidDirectionInLinearGradientOptions;
}
interface RuleWithNoInvalidGridAreasOptions {
    level: RulePlainConfiguration;
    options?: NoInvalidGridAreasOptions;
}
interface RuleWithNoInvalidPositionAtImportRuleOptions {
    level: RulePlainConfiguration;
    options?: NoInvalidPositionAtImportRuleOptions;
}
interface RuleWithNoInvalidUseBeforeDeclarationOptions {
    level: RulePlainConfiguration;
    options?: NoInvalidUseBeforeDeclarationOptions;
}
interface RuleWithNoMissingVarFunctionOptions {
    level: RulePlainConfiguration;
    options?: NoMissingVarFunctionOptions;
}
interface RuleWithNoNestedComponentDefinitionsOptions {
    level: RulePlainConfiguration;
    options?: NoNestedComponentDefinitionsOptions;
}
interface RuleWithNoNextAsyncClientComponentOptions {
    level: RulePlainConfiguration;
    options?: NoNextAsyncClientComponentOptions;
}
interface RuleWithNoNodejsModulesOptions {
    level: RulePlainConfiguration;
    options?: NoNodejsModulesOptions;
}
interface RuleWithNoNonoctalDecimalEscapeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoNonoctalDecimalEscapeOptions;
}
interface RuleWithNoPrecisionLossOptions {
    level: RulePlainConfiguration;
    options?: NoPrecisionLossOptions;
}
interface RuleWithNoPrivateImportsOptions {
    level: RulePlainConfiguration;
    options?: NoPrivateImportsOptions;
}
interface RuleWithNoProcessGlobalOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoProcessGlobalOptions;
}
interface RuleWithNoQwikUseVisibleTaskOptions {
    level: RulePlainConfiguration;
    options?: NoQwikUseVisibleTaskOptions;
}
interface RuleWithNoReactPropAssignmentsOptions {
    level: RulePlainConfiguration;
    options?: NoReactPropAssignmentsOptions;
}
interface RuleWithNoRenderReturnValueOptions {
    level: RulePlainConfiguration;
    options?: NoRenderReturnValueOptions;
}
interface RuleWithNoRestrictedElementsOptions {
    level: RulePlainConfiguration;
    options?: NoRestrictedElementsOptions;
}
interface RuleWithNoSelfAssignOptions {
    level: RulePlainConfiguration;
    options?: NoSelfAssignOptions;
}
interface RuleWithNoSetterReturnOptions {
    level: RulePlainConfiguration;
    options?: NoSetterReturnOptions;
}
interface RuleWithNoSolidDestructuredPropsOptions {
    level: RulePlainConfiguration;
    options?: NoSolidDestructuredPropsOptions;
}
interface RuleWithNoStringCaseMismatchOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoStringCaseMismatchOptions;
}
interface RuleWithNoSwitchDeclarationsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoSwitchDeclarationsOptions;
}
interface RuleWithNoUndeclaredDependenciesOptions {
    level: RulePlainConfiguration;
    options?: NoUndeclaredDependenciesOptions;
}
interface RuleWithNoUndeclaredVariablesOptions {
    level: RulePlainConfiguration;
    options?: NoUndeclaredVariablesOptions;
}
interface RuleWithNoUnknownFunctionOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownFunctionOptions;
}
interface RuleWithNoUnknownMediaFeatureNameOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownMediaFeatureNameOptions;
}
interface RuleWithNoUnknownPropertyOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownPropertyOptions;
}
interface RuleWithNoUnknownPseudoClassOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownPseudoClassOptions;
}
interface RuleWithNoUnknownPseudoElementOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownPseudoElementOptions;
}
interface RuleWithNoUnknownTypeSelectorOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownTypeSelectorOptions;
}
interface RuleWithNoUnknownUnitOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownUnitOptions;
}
interface RuleWithNoUnmatchableAnbSelectorOptions {
    level: RulePlainConfiguration;
    options?: NoUnmatchableAnbSelectorOptions;
}
interface RuleWithNoUnreachableOptions {
    level: RulePlainConfiguration;
    options?: NoUnreachableOptions;
}
interface RuleWithNoUnreachableSuperOptions {
    level: RulePlainConfiguration;
    options?: NoUnreachableSuperOptions;
}
interface RuleWithNoUnresolvedImportsOptions {
    level: RulePlainConfiguration;
    options?: NoUnresolvedImportsOptions;
}
interface RuleWithNoUnsafeFinallyOptions {
    level: RulePlainConfiguration;
    options?: NoUnsafeFinallyOptions;
}
interface RuleWithNoUnsafeOptionalChainingOptions {
    level: RulePlainConfiguration;
    options?: NoUnsafeOptionalChainingOptions;
}
interface RuleWithNoUnusedFunctionParametersOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUnusedFunctionParametersOptions;
}
interface RuleWithNoUnusedImportsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUnusedImportsOptions;
}
interface RuleWithNoUnusedInstantiationOptions {
    level: RulePlainConfiguration;
    options?: NoUnusedInstantiationOptions;
}
interface RuleWithNoUnusedLabelsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUnusedLabelsOptions;
}
interface RuleWithNoUnusedPrivateClassMembersOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUnusedPrivateClassMembersOptions;
}
interface RuleWithNoUnusedVariablesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUnusedVariablesOptions;
}
interface RuleWithNoVoidElementsWithChildrenOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoVoidElementsWithChildrenOptions;
}
interface RuleWithNoVoidTypeReturnOptions {
    level: RulePlainConfiguration;
    options?: NoVoidTypeReturnOptions;
}
interface RuleWithNoVueDataObjectDeclarationOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoVueDataObjectDeclarationOptions;
}
interface RuleWithNoVueDuplicateKeysOptions {
    level: RulePlainConfiguration;
    options?: NoVueDuplicateKeysOptions;
}
interface RuleWithNoVueReservedKeysOptions {
    level: RulePlainConfiguration;
    options?: NoVueReservedKeysOptions;
}
interface RuleWithNoVueReservedPropsOptions {
    level: RulePlainConfiguration;
    options?: NoVueReservedPropsOptions;
}
interface RuleWithNoVueSetupPropsReactivityLossOptions {
    level: RulePlainConfiguration;
    options?: NoVueSetupPropsReactivityLossOptions;
}
interface RuleWithNoVueVIfWithVForOptions {
    level: RulePlainConfiguration;
    options?: NoVueVIfWithVForOptions;
}
interface RuleWithUseExhaustiveDependenciesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseExhaustiveDependenciesOptions;
}
interface RuleWithUseGraphqlNamedOperationsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseGraphqlNamedOperationsOptions;
}
interface RuleWithUseHookAtTopLevelOptions {
    level: RulePlainConfiguration;
    options?: UseHookAtTopLevelOptions;
}
interface RuleWithUseImageSizeOptions {
    level: RulePlainConfiguration;
    options?: UseImageSizeOptions;
}
interface RuleWithUseImportExtensionsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseImportExtensionsOptions;
}
interface RuleWithUseInlineScriptIdOptions {
    level: RulePlainConfiguration;
    options?: UseInlineScriptIdOptions;
}
interface RuleWithUseIsNanOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseIsNanOptions;
}
interface RuleWithUseJsonImportAttributesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseJsonImportAttributesOptions;
}
interface RuleWithUseJsxKeyInIterableOptions {
    level: RulePlainConfiguration;
    options?: UseJsxKeyInIterableOptions;
}
interface RuleWithUseLoneAnonymousOperationOptions {
    level: RulePlainConfiguration;
    options?: UseLoneAnonymousOperationOptions;
}
interface RuleWithUseParseIntRadixOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseParseIntRadixOptions;
}
interface RuleWithUseQwikClasslistOptions {
    level: RulePlainConfiguration;
    options?: UseQwikClasslistOptions;
}
interface RuleWithUseQwikMethodUsageOptions {
    level: RulePlainConfiguration;
    options?: UseQwikMethodUsageOptions;
}
interface RuleWithUseQwikValidLexicalScopeOptions {
    level: RulePlainConfiguration;
    options?: UseQwikValidLexicalScopeOptions;
}
interface RuleWithUseSingleJsDocAsteriskOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseSingleJsDocAsteriskOptions;
}
interface RuleWithUseUniqueElementIdsOptions {
    level: RulePlainConfiguration;
    options?: UseUniqueElementIdsOptions;
}
interface RuleWithUseValidForDirectionOptions {
    level: RulePlainConfiguration;
    options?: UseValidForDirectionOptions;
}
interface RuleWithUseValidTypeofOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseValidTypeofOptions;
}
interface RuleWithUseVueVForKeyOptions {
    level: RulePlainConfiguration;
    options?: UseVueVForKeyOptions;
}
interface RuleWithUseVueValidTemplateRootOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueValidTemplateRootOptions;
}
interface RuleWithUseVueValidVBindOptions {
    level: RulePlainConfiguration;
    options?: UseVueValidVBindOptions;
}
interface RuleWithUseVueValidVCloakOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueValidVCloakOptions;
}
interface RuleWithUseVueValidVElseOptions {
    level: RulePlainConfiguration;
    options?: UseVueValidVElseOptions;
}
interface RuleWithUseVueValidVElseIfOptions {
    level: RulePlainConfiguration;
    options?: UseVueValidVElseIfOptions;
}
interface RuleWithUseVueValidVHtmlOptions {
    level: RulePlainConfiguration;
    options?: UseVueValidVHtmlOptions;
}
interface RuleWithUseVueValidVIfOptions {
    level: RulePlainConfiguration;
    options?: UseVueValidVIfOptions;
}
interface RuleWithUseVueValidVOnOptions {
    level: RulePlainConfiguration;
    options?: UseVueValidVOnOptions;
}
interface RuleWithUseVueValidVOnceOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueValidVOnceOptions;
}
interface RuleWithUseVueValidVPreOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueValidVPreOptions;
}
interface RuleWithUseVueValidVTextOptions {
    level: RulePlainConfiguration;
    options?: UseVueValidVTextOptions;
}
interface RuleWithUseYieldOptions {
    level: RulePlainConfiguration;
    options?: UseYieldOptions;
}
interface RuleWithNoBaseToStringOptions {
    level: RulePlainConfiguration;
    options?: NoBaseToStringOptions;
}
interface RuleWithNoComponentHookFactoriesOptions {
    level: RulePlainConfiguration;
    options?: NoComponentHookFactoriesOptions;
}
interface RuleWithNoConditionalExpectOptions {
    level: RulePlainConfiguration;
    options?: NoConditionalExpectOptions;
}
interface RuleWithNoDrizzleDeleteWithoutWhereOptions {
    level: RulePlainConfiguration;
    options?: NoDrizzleDeleteWithoutWhereOptions;
}
interface RuleWithNoDrizzleUpdateWithoutWhereOptions {
    level: RulePlainConfiguration;
    options?: NoDrizzleUpdateWithoutWhereOptions;
}
interface RuleWithNoDuplicateFieldDefinitionNamesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateFieldDefinitionNamesOptions;
}
interface RuleWithNoDuplicateSelectorsOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateSelectorsOptions;
}
interface RuleWithNoEmptyObjectKeysOptions {
    level: RulePlainConfiguration;
    options?: NoEmptyObjectKeysOptions;
}
interface RuleWithNoExcessiveNestedCallbacksOptions {
    level: RulePlainConfiguration;
    options?: NoExcessiveNestedCallbacksOptions;
}
interface RuleWithNoExcessiveSelectorClassesOptions {
    level: RulePlainConfiguration;
    options?: NoExcessiveSelectorClassesOptions;
}
interface RuleWithNoFloatingPromisesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoFloatingPromisesOptions;
}
interface RuleWithNoIdenticalTestTitleOptions {
    level: RulePlainConfiguration;
    options?: NoIdenticalTestTitleOptions;
}
interface RuleWithNoImpliedEvalOptions {
    level: RulePlainConfiguration;
    options?: NoImpliedEvalOptions;
}
interface RuleWithNoInlineStylesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoInlineStylesOptions;
}
interface RuleWithNoJsxLeakedDollarOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoJsxLeakedDollarOptions;
}
interface RuleWithNoJsxNamespaceOptions {
    level: RulePlainConfiguration;
    options?: NoJsxNamespaceOptions;
}
interface RuleWithNoLoopFuncOptions {
    level: RulePlainConfiguration;
    options?: NoLoopFuncOptions;
}
interface RuleWithNoMisleadingReturnTypeOptions {
    level: RulePlainConfiguration;
    options?: NoMisleadingReturnTypeOptions;
}
interface RuleWithNoMisusedPromisesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoMisusedPromisesOptions;
}
interface RuleWithNoNegationInEqualityCheckOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoNegationInEqualityCheckOptions;
}
interface RuleWithNoPlaywrightElementHandleOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoPlaywrightElementHandleOptions;
}
interface RuleWithNoPlaywrightEvalOptions {
    level: RulePlainConfiguration;
    options?: NoPlaywrightEvalOptions;
}
interface RuleWithNoPlaywrightForceOptionOptions {
    level: RulePlainConfiguration;
    options?: NoPlaywrightForceOptionOptions;
}
interface RuleWithNoPlaywrightMissingAwaitOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoPlaywrightMissingAwaitOptions;
}
interface RuleWithNoPlaywrightNetworkidleOptions {
    level: RulePlainConfiguration;
    options?: NoPlaywrightNetworkidleOptions;
}
interface RuleWithNoPlaywrightPagePauseOptions {
    level: RulePlainConfiguration;
    options?: NoPlaywrightPagePauseOptions;
}
interface RuleWithNoPlaywrightUselessAwaitOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoPlaywrightUselessAwaitOptions;
}
interface RuleWithNoPlaywrightWaitForNavigationOptions {
    level: RulePlainConfiguration;
    options?: NoPlaywrightWaitForNavigationOptions;
}
interface RuleWithNoPlaywrightWaitForSelectorOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoPlaywrightWaitForSelectorOptions;
}
interface RuleWithNoPlaywrightWaitForTimeoutOptions {
    level: RulePlainConfiguration;
    options?: NoPlaywrightWaitForTimeoutOptions;
}
interface RuleWithNoReactNativeDeepImportsOptions {
    level: RulePlainConfiguration;
    options?: NoReactNativeDeepImportsOptions;
}
interface RuleWithNoReactNativeLiteralColorsOptions {
    level: RulePlainConfiguration;
    options?: NoReactNativeLiteralColorsOptions;
}
interface RuleWithNoReactNativeRawTextOptions {
    level: RulePlainConfiguration;
    options?: NoReactNativeRawTextOptions;
}
interface RuleWithNoReactStringRefsOptions {
    level: RulePlainConfiguration;
    options?: NoReactStringRefsOptions;
}
interface RuleWithNoRestrictedDependenciesOptions {
    level: RulePlainConfiguration;
    options?: NoRestrictedDependenciesOptions;
}
interface RuleWithNoSvelteUnnecessaryStateWrapOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoSvelteUnnecessaryStateWrapOptions;
}
interface RuleWithNoTopLevelLiteralsOptions {
    level: RulePlainConfiguration;
    options?: NoTopLevelLiteralsOptions;
}
interface RuleWithNoUndeclaredClassesOptions {
    level: RulePlainConfiguration;
    options?: NoUndeclaredClassesOptions;
}
interface RuleWithNoUnnecessaryTemplateExpressionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUnnecessaryTemplateExpressionOptions;
}
interface RuleWithNoUnsafePlusOperandsOptions {
    level: RulePlainConfiguration;
    options?: NoUnsafePlusOperandsOptions;
}
interface RuleWithNoUntrustedLicensesOptions {
    level: RulePlainConfiguration;
    options?: NoUntrustedLicensesOptions;
}
interface RuleWithNoUnusedClassesOptions {
    level: RulePlainConfiguration;
    options?: NoUnusedClassesOptions;
}
interface RuleWithNoUselessTypeConversionOptions {
    level: RulePlainConfiguration;
    options?: NoUselessTypeConversionOptions;
}
interface RuleWithNoVueImportCompilerMacrosOptions {
    level: RulePlainConfiguration;
    options?: NoVueImportCompilerMacrosOptions;
}
interface RuleWithNoVueRefAsOperandOptions {
    level: RulePlainConfiguration;
    options?: NoVueRefAsOperandOptions;
}
interface RuleWithNoVueVOnNumberValuesOptions {
    level: RulePlainConfiguration;
    options?: NoVueVOnNumberValuesOptions;
}
interface RuleWithUseArraySomeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseArraySomeOptions;
}
interface RuleWithUseAwaitThenableOptions {
    level: RulePlainConfiguration;
    options?: UseAwaitThenableOptions;
}
interface RuleWithUseBaselineOptions {
    level: RulePlainConfiguration;
    options?: UseBaselineOptions;
}
interface RuleWithUseConsistentTestItOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConsistentTestItOptions;
}
interface RuleWithUseDisposablesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseDisposablesOptions;
}
interface RuleWithUseDomNodeTextContentOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseDomNodeTextContentOptions;
}
interface RuleWithUseDomQuerySelectorOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseDomQuerySelectorOptions;
}
interface RuleWithUseExhaustiveSwitchCasesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseExhaustiveSwitchCasesOptions;
}
interface RuleWithUseExpectOptions {
    level: RulePlainConfiguration;
    options?: UseExpectOptions;
}
interface RuleWithUseExplicitReturnTypeOptions {
    level: RulePlainConfiguration;
    options?: UseExplicitReturnTypeOptions;
}
interface RuleWithUseExplicitTypeOptions {
    level: RulePlainConfiguration;
    options?: UseExplicitTypeOptions;
}
interface RuleWithUseIframeSandboxOptions {
    level: RulePlainConfiguration;
    options?: UseIframeSandboxOptions;
}
interface RuleWithUseImportsFirstOptions {
    level: RulePlainConfiguration;
    options?: UseImportsFirstOptions;
}
interface RuleWithUseIncludesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseIncludesOptions;
}
interface RuleWithUseMathMinMaxOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseMathMinMaxOptions;
}
interface RuleWithUseNamedCaptureGroupOptions {
    level: RulePlainConfiguration;
    options?: UseNamedCaptureGroupOptions;
}
interface RuleWithUseNullishCoalescingOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNullishCoalescingOptions;
}
interface RuleWithUsePlaywrightValidDescribeCallbackOptions {
    level: RulePlainConfiguration;
    options?: UsePlaywrightValidDescribeCallbackOptions;
}
interface RuleWithUseQwikLoaderLocationOptions {
    level: RulePlainConfiguration;
    options?: UseQwikLoaderLocationOptions;
}
interface RuleWithUseReactAsyncServerFunctionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseReactAsyncServerFunctionOptions;
}
interface RuleWithUseReactFunctionComponentDefinitionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseReactFunctionComponentDefinitionOptions;
}
interface RuleWithUseReactNativePlatformComponentsOptions {
    level: RulePlainConfiguration;
    options?: UseReactNativePlatformComponentsOptions;
}
interface RuleWithUseReduceTypeParameterOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseReduceTypeParameterOptions;
}
interface RuleWithUseRegexpExecOptions {
    level: RulePlainConfiguration;
    options?: UseRegexpExecOptions;
}
interface RuleWithUseRegexpTestOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseRegexpTestOptions;
}
interface RuleWithUseScopedStylesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseScopedStylesOptions;
}
interface RuleWithUseSortedClassesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseSortedClassesOptions;
}
interface RuleWithUseStringStartsEndsWithOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseStringStartsEndsWithOptions;
}
interface RuleWithUseSvelteRequireEachKeyOptions {
    level: RulePlainConfiguration;
    options?: UseSvelteRequireEachKeyOptions;
}
interface RuleWithUseTestHooksInOrderOptions {
    level: RulePlainConfiguration;
    options?: UseTestHooksInOrderOptions;
}
interface RuleWithUseTestHooksOnTopOptions {
    level: RulePlainConfiguration;
    options?: UseTestHooksOnTopOptions;
}
interface RuleWithUseThisInClassMethodsOptions {
    level: RulePlainConfiguration;
    options?: UseThisInClassMethodsOptions;
}
interface RuleWithUseUnicodeRegexOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseUnicodeRegexOptions;
}
interface RuleWithUseVarsOnTopOptions {
    level: RulePlainConfiguration;
    options?: UseVarsOnTopOptions;
}
interface RuleWithUseVueConsistentDefinePropsDeclarationOptions {
    level: RulePlainConfiguration;
    options?: UseVueConsistentDefinePropsDeclarationOptions;
}
interface RuleWithUseVueNextTickPromiseOptions {
    level: RulePlainConfiguration;
    options?: UseVueNextTickPromiseOptions;
}
interface RuleWithUseVueValidVForOptions {
    level: RulePlainConfiguration;
    options?: UseVueValidVForOptions;
}
interface RuleWithNoAccumulatingSpreadOptions {
    level: RulePlainConfiguration;
    options?: NoAccumulatingSpreadOptions;
}
interface RuleWithNoAwaitInLoopsOptions {
    level: RulePlainConfiguration;
    options?: NoAwaitInLoopsOptions;
}
interface RuleWithNoBarrelFileOptions {
    level: RulePlainConfiguration;
    options?: NoBarrelFileOptions;
}
interface RuleWithNoDeleteOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoDeleteOptions;
}
interface RuleWithNoDynamicNamespaceImportAccessOptions {
    level: RulePlainConfiguration;
    options?: NoDynamicNamespaceImportAccessOptions;
}
interface RuleWithNoImgElementOptions {
    level: RulePlainConfiguration;
    options?: NoImgElementOptions;
}
interface RuleWithNoJsxPropsBindOptions {
    level: RulePlainConfiguration;
    options?: NoJsxPropsBindOptions;
}
interface RuleWithNoNamespaceImportOptions {
    level: RulePlainConfiguration;
    options?: NoNamespaceImportOptions;
}
interface RuleWithNoReExportAllOptions {
    level: RulePlainConfiguration;
    options?: NoReExportAllOptions;
}
interface RuleWithNoSyncScriptsOptions {
    level: RulePlainConfiguration;
    options?: NoSyncScriptsOptions;
}
interface RuleWithNoUnwantedPolyfillioOptions {
    level: RulePlainConfiguration;
    options?: NoUnwantedPolyfillioOptions;
}
interface RuleWithUseGoogleFontPreconnectOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseGoogleFontPreconnectOptions;
}
interface RuleWithUseSolidForComponentOptions {
    level: RulePlainConfiguration;
    options?: UseSolidForComponentOptions;
}
interface RuleWithUseTopLevelRegexOptions {
    level: RulePlainConfiguration;
    options?: UseTopLevelRegexOptions;
}
interface RuleWithUseVueVaporOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueVaporOptions;
}
interface RuleWithNoBlankTargetOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoBlankTargetOptions;
}
interface RuleWithNoDangerouslySetInnerHtmlOptions {
    level: RulePlainConfiguration;
    options?: NoDangerouslySetInnerHtmlOptions;
}
interface RuleWithNoDangerouslySetInnerHtmlWithChildrenOptions {
    level: RulePlainConfiguration;
    options?: NoDangerouslySetInnerHtmlWithChildrenOptions;
}
interface RuleWithNoGlobalEvalOptions {
    level: RulePlainConfiguration;
    options?: NoGlobalEvalOptions;
}
interface RuleWithNoScriptUrlOptions {
    level: RulePlainConfiguration;
    options?: NoScriptUrlOptions;
}
interface RuleWithNoSecretsOptions {
    level: RulePlainConfiguration;
    options?: NoSecretsOptions;
}
interface RuleWithNoCommonJsOptions {
    level: RulePlainConfiguration;
    options?: NoCommonJsOptions;
}
interface RuleWithNoContinueOptions {
    level: RulePlainConfiguration;
    options?: NoContinueOptions;
}
interface RuleWithNoDefaultExportOptions {
    level: RulePlainConfiguration;
    options?: NoDefaultExportOptions;
}
interface RuleWithNoDescendingSpecificityOptions {
    level: RulePlainConfiguration;
    options?: NoDescendingSpecificityOptions;
}
interface RuleWithNoDoneCallbackOptions {
    level: RulePlainConfiguration;
    options?: NoDoneCallbackOptions;
}
interface RuleWithNoEnumOptions {
    level: RulePlainConfiguration;
    options?: NoEnumOptions;
}
interface RuleWithNoExcessiveClassesPerFileOptions {
    level: RulePlainConfiguration;
    options?: NoExcessiveClassesPerFileOptions;
}
interface RuleWithNoExcessiveLinesPerFileOptions {
    level: RulePlainConfiguration;
    options?: NoExcessiveLinesPerFileOptions;
}
interface RuleWithNoExportedImportsOptions {
    level: RulePlainConfiguration;
    options?: NoExportedImportsOptions;
}
interface RuleWithNoHeadElementOptions {
    level: RulePlainConfiguration;
    options?: NoHeadElementOptions;
}
interface RuleWithNoHexColorsOptions {
    level: RulePlainConfiguration;
    options?: NoHexColorsOptions;
}
interface RuleWithNoImplicitBooleanOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoImplicitBooleanOptions;
}
interface RuleWithNoIncrementDecrementOptions {
    level: RulePlainConfiguration;
    options?: NoIncrementDecrementOptions;
}
interface RuleWithNoInferrableTypesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoInferrableTypesOptions;
}
interface RuleWithNoJsxLiteralsOptions {
    level: RulePlainConfiguration;
    options?: NoJsxLiteralsOptions;
}
interface RuleWithNoMagicNumbersOptions {
    level: RulePlainConfiguration;
    options?: NoMagicNumbersOptions;
}
interface RuleWithNoMultiAssignOptions {
    level: RulePlainConfiguration;
    options?: NoMultiAssignOptions;
}
interface RuleWithNoMultilineStringOptions {
    level: RulePlainConfiguration;
    options?: NoMultilineStringOptions;
}
interface RuleWithNoNamespaceOptions {
    level: RulePlainConfiguration;
    options?: NoNamespaceOptions;
}
interface RuleWithNoNegationElseOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoNegationElseOptions;
}
interface RuleWithNoNestedTernaryOptions {
    level: RulePlainConfiguration;
    options?: NoNestedTernaryOptions;
}
interface RuleWithNoNonNullAssertionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoNonNullAssertionOptions;
}
interface RuleWithNoParameterAssignOptions {
    level: RulePlainConfiguration;
    options?: NoParameterAssignOptions;
}
interface RuleWithNoParameterPropertiesOptions {
    level: RulePlainConfiguration;
    options?: NoParameterPropertiesOptions;
}
interface RuleWithNoProcessEnvOptions {
    level: RulePlainConfiguration;
    options?: NoProcessEnvOptions;
}
interface RuleWithNoRestrictedGlobalsOptions {
    level: RulePlainConfiguration;
    options?: NoRestrictedGlobalsOptions;
}
interface RuleWithNoRestrictedImportsOptions {
    level: RulePlainConfiguration;
    options?: NoRestrictedImportsOptions;
}
interface RuleWithNoRestrictedTypesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoRestrictedTypesOptions;
}
interface RuleWithNoRootTypeOptions {
    level: RulePlainConfiguration;
    options?: NoRootTypeOptions;
}
interface RuleWithNoShoutyConstantsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoShoutyConstantsOptions;
}
interface RuleWithNoSubstrOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoSubstrOptions;
}
interface RuleWithNoTernaryOptions {
    level: RulePlainConfiguration;
    options?: NoTernaryOptions;
}
interface RuleWithNoUnusedTemplateLiteralOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUnusedTemplateLiteralOptions;
}
interface RuleWithNoUselessElseOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessElseOptions;
}
interface RuleWithNoValueAtRuleOptions {
    level: RulePlainConfiguration;
    options?: NoValueAtRuleOptions;
}
interface RuleWithNoVueOptionsApiOptions {
    level: RulePlainConfiguration;
    options?: NoVueOptionsApiOptions;
}
interface RuleWithNoYodaExpressionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoYodaExpressionOptions;
}
interface RuleWithUseArrayLiteralsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseArrayLiteralsOptions;
}
interface RuleWithUseAsConstAssertionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseAsConstAssertionOptions;
}
interface RuleWithUseAtIndexOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseAtIndexOptions;
}
interface RuleWithUseBlockStatementsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseBlockStatementsOptions;
}
interface RuleWithUseCollapsedElseIfOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseCollapsedElseIfOptions;
}
interface RuleWithUseCollapsedIfOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseCollapsedIfOptions;
}
interface RuleWithUseComponentExportOnlyModulesOptions {
    level: RulePlainConfiguration;
    options?: UseComponentExportOnlyModulesOptions;
}
interface RuleWithUseConsistentArrayTypeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConsistentArrayTypeOptions;
}
interface RuleWithUseConsistentArrowReturnOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConsistentArrowReturnOptions;
}
interface RuleWithUseConsistentBuiltinInstantiationOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConsistentBuiltinInstantiationOptions;
}
interface RuleWithUseConsistentCurlyBracesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConsistentCurlyBracesOptions;
}
interface RuleWithUseConsistentEnumValueTypeOptions {
    level: RulePlainConfiguration;
    options?: UseConsistentEnumValueTypeOptions;
}
interface RuleWithUseConsistentGraphqlDescriptionsOptions {
    level: RulePlainConfiguration;
    options?: UseConsistentGraphqlDescriptionsOptions;
}
interface RuleWithUseConsistentMemberAccessibilityOptions {
    level: RulePlainConfiguration;
    options?: UseConsistentMemberAccessibilityOptions;
}
interface RuleWithUseConsistentMethodSignaturesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConsistentMethodSignaturesOptions;
}
interface RuleWithUseConsistentObjectDefinitionsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConsistentObjectDefinitionsOptions;
}
interface RuleWithUseConsistentTypeDefinitionsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConsistentTypeDefinitionsOptions;
}
interface RuleWithUseConstOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseConstOptions;
}
interface RuleWithUseDefaultParameterLastOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseDefaultParameterLastOptions;
}
interface RuleWithUseDefaultSwitchClauseOptions {
    level: RulePlainConfiguration;
    options?: UseDefaultSwitchClauseOptions;
}
interface RuleWithUseDeprecatedReasonOptions {
    level: RulePlainConfiguration;
    options?: UseDeprecatedReasonOptions;
}
interface RuleWithUseDestructuringOptions {
    level: RulePlainConfiguration;
    options?: UseDestructuringOptions;
}
interface RuleWithUseEnumInitializersOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseEnumInitializersOptions;
}
interface RuleWithUseErrorCauseOptions {
    level: RulePlainConfiguration;
    options?: UseErrorCauseOptions;
}
interface RuleWithUseExplicitLengthCheckOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseExplicitLengthCheckOptions;
}
interface RuleWithUseExponentiationOperatorOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseExponentiationOperatorOptions;
}
interface RuleWithUseExportTypeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseExportTypeOptions;
}
interface RuleWithUseExportsLastOptions {
    level: RulePlainConfiguration;
    options?: UseExportsLastOptions;
}
interface RuleWithUseFilenamingConventionOptions {
    level: RulePlainConfiguration;
    options?: UseFilenamingConventionOptions;
}
interface RuleWithUseForOfOptions {
    level: RulePlainConfiguration;
    options?: UseForOfOptions;
}
interface RuleWithUseFragmentSyntaxOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseFragmentSyntaxOptions;
}
interface RuleWithUseGlobalThisOptions {
    level: RulePlainConfiguration;
    options?: UseGlobalThisOptions;
}
interface RuleWithUseGraphqlNamingConventionOptions {
    level: RulePlainConfiguration;
    options?: UseGraphqlNamingConventionOptions;
}
interface RuleWithUseGroupedAccessorPairsOptions {
    level: RulePlainConfiguration;
    options?: UseGroupedAccessorPairsOptions;
}
interface RuleWithUseImportTypeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseImportTypeOptions;
}
interface RuleWithUseInputNameOptions {
    level: RulePlainConfiguration;
    options?: UseInputNameOptions;
}
interface RuleWithUseLiteralEnumMembersOptions {
    level: RulePlainConfiguration;
    options?: UseLiteralEnumMembersOptions;
}
interface RuleWithUseLoneExecutableDefinitionOptions {
    level: RulePlainConfiguration;
    options?: UseLoneExecutableDefinitionOptions;
}
interface RuleWithUseNamingConventionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNamingConventionOptions;
}
interface RuleWithUseNodeAssertStrictOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNodeAssertStrictOptions;
}
interface RuleWithUseNodejsImportProtocolOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNodejsImportProtocolOptions;
}
interface RuleWithUseNumberNamespaceOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNumberNamespaceOptions;
}
interface RuleWithUseNumericSeparatorsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNumericSeparatorsOptions;
}
interface RuleWithUseObjectSpreadOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseObjectSpreadOptions;
}
interface RuleWithUseReactFunctionComponentsOptions {
    level: RulePlainConfiguration;
    options?: UseReactFunctionComponentsOptions;
}
interface RuleWithUseReadonlyClassPropertiesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseReadonlyClassPropertiesOptions;
}
interface RuleWithUseSelfClosingElementsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseSelfClosingElementsOptions;
}
interface RuleWithUseShorthandAssignOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseShorthandAssignOptions;
}
interface RuleWithUseShorthandFunctionTypeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseShorthandFunctionTypeOptions;
}
interface RuleWithUseSingleVarDeclaratorOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseSingleVarDeclaratorOptions;
}
interface RuleWithUseSpreadOverApplyOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseSpreadOverApplyOptions;
}
interface RuleWithUseSymbolDescriptionOptions {
    level: RulePlainConfiguration;
    options?: UseSymbolDescriptionOptions;
}
interface RuleWithUseTemplateOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseTemplateOptions;
}
interface RuleWithUseThrowNewErrorOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseThrowNewErrorOptions;
}
interface RuleWithUseThrowOnlyErrorOptions {
    level: RulePlainConfiguration;
    options?: UseThrowOnlyErrorOptions;
}
interface RuleWithUseTrimStartEndOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseTrimStartEndOptions;
}
interface RuleWithUseUnifiedTypeSignaturesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseUnifiedTypeSignaturesOptions;
}
interface RuleWithUseVueConsistentVBindStyleOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueConsistentVBindStyleOptions;
}
interface RuleWithUseVueConsistentVOnStyleOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueConsistentVOnStyleOptions;
}
interface RuleWithUseVueDefineMacrosOrderOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueDefineMacrosOrderOptions;
}
interface RuleWithUseVueHyphenatedAttributesOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseVueHyphenatedAttributesOptions;
}
interface RuleWithUseVueMultiWordComponentNamesOptions {
    level: RulePlainConfiguration;
    options?: UseVueMultiWordComponentNamesOptions;
}
interface RuleWithNoAlertOptions {
    level: RulePlainConfiguration;
    options?: NoAlertOptions;
}
interface RuleWithNoApproximativeNumericConstantOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoApproximativeNumericConstantOptions;
}
interface RuleWithNoArrayIndexKeyOptions {
    level: RulePlainConfiguration;
    options?: NoArrayIndexKeyOptions;
}
interface RuleWithNoAssignInExpressionsOptions {
    level: RulePlainConfiguration;
    options?: NoAssignInExpressionsOptions;
}
interface RuleWithNoAsyncPromiseExecutorOptions {
    level: RulePlainConfiguration;
    options?: NoAsyncPromiseExecutorOptions;
}
interface RuleWithNoBiomeFirstExceptionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoBiomeFirstExceptionOptions;
}
interface RuleWithNoBitwiseOperatorsOptions {
    level: RulePlainConfiguration;
    options?: NoBitwiseOperatorsOptions;
}
interface RuleWithNoCatchAssignOptions {
    level: RulePlainConfiguration;
    options?: NoCatchAssignOptions;
}
interface RuleWithNoClassAssignOptions {
    level: RulePlainConfiguration;
    options?: NoClassAssignOptions;
}
interface RuleWithNoCommentTextOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoCommentTextOptions;
}
interface RuleWithNoCompareNegZeroOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoCompareNegZeroOptions;
}
interface RuleWithNoConfusingLabelsOptions {
    level: RulePlainConfiguration;
    options?: NoConfusingLabelsOptions;
}
interface RuleWithNoConfusingVoidTypeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoConfusingVoidTypeOptions;
}
interface RuleWithNoConsoleOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoConsoleOptions;
}
interface RuleWithNoConstEnumOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoConstEnumOptions;
}
interface RuleWithNoConstantBinaryExpressionsOptions {
    level: RulePlainConfiguration;
    options?: NoConstantBinaryExpressionsOptions;
}
interface RuleWithNoControlCharactersInRegexOptions {
    level: RulePlainConfiguration;
    options?: NoControlCharactersInRegexOptions;
}
interface RuleWithNoDebuggerOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoDebuggerOptions;
}
interface RuleWithNoDeprecatedImportsOptions {
    level: RulePlainConfiguration;
    options?: NoDeprecatedImportsOptions;
}
interface RuleWithNoDeprecatedMediaTypeOptions {
    level: RulePlainConfiguration;
    options?: NoDeprecatedMediaTypeOptions;
}
interface RuleWithNoDocumentCookieOptions {
    level: RulePlainConfiguration;
    options?: NoDocumentCookieOptions;
}
interface RuleWithNoDocumentImportInPageOptions {
    level: RulePlainConfiguration;
    options?: NoDocumentImportInPageOptions;
}
interface RuleWithNoDoubleEqualsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoDoubleEqualsOptions;
}
interface RuleWithNoDuplicateAtImportRulesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateAtImportRulesOptions;
}
interface RuleWithNoDuplicateCaseOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateCaseOptions;
}
interface RuleWithNoDuplicateClassMembersOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateClassMembersOptions;
}
interface RuleWithNoDuplicateCustomPropertiesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateCustomPropertiesOptions;
}
interface RuleWithNoDuplicateDependenciesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateDependenciesOptions;
}
interface RuleWithNoDuplicateElseIfOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateElseIfOptions;
}
interface RuleWithNoDuplicateEnumValuesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateEnumValuesOptions;
}
interface RuleWithNoDuplicateFieldsOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateFieldsOptions;
}
interface RuleWithNoDuplicateFontNamesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateFontNamesOptions;
}
interface RuleWithNoDuplicateGraphqlOperationNameOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateGraphqlOperationNameOptions;
}
interface RuleWithNoDuplicateJsxPropsOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateJsxPropsOptions;
}
interface RuleWithNoDuplicateObjectKeysOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateObjectKeysOptions;
}
interface RuleWithNoDuplicateParametersOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateParametersOptions;
}
interface RuleWithNoDuplicatePropertiesOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicatePropertiesOptions;
}
interface RuleWithNoDuplicateSelectorsKeyframeBlockOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateSelectorsKeyframeBlockOptions;
}
interface RuleWithNoDuplicateTestHooksOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicateTestHooksOptions;
}
interface RuleWithNoDuplicatedSpreadPropsOptions {
    level: RulePlainConfiguration;
    options?: NoDuplicatedSpreadPropsOptions;
}
interface RuleWithNoEmptyBlockOptions {
    level: RulePlainConfiguration;
    options?: NoEmptyBlockOptions;
}
interface RuleWithNoEmptyBlockStatementsOptions {
    level: RulePlainConfiguration;
    options?: NoEmptyBlockStatementsOptions;
}
interface RuleWithNoEmptyInterfaceOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoEmptyInterfaceOptions;
}
interface RuleWithNoEmptySourceOptions {
    level: RulePlainConfiguration;
    options?: NoEmptySourceOptions;
}
interface RuleWithNoEqualsToNullOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoEqualsToNullOptions;
}
interface RuleWithNoEvolvingTypesOptions {
    level: RulePlainConfiguration;
    options?: NoEvolvingTypesOptions;
}
interface RuleWithNoExplicitAnyOptions {
    level: RulePlainConfiguration;
    options?: NoExplicitAnyOptions;
}
interface RuleWithNoExportsInTestOptions {
    level: RulePlainConfiguration;
    options?: NoExportsInTestOptions;
}
interface RuleWithNoExtraNonNullAssertionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoExtraNonNullAssertionOptions;
}
interface RuleWithNoFallthroughSwitchClauseOptions {
    level: RulePlainConfiguration;
    options?: NoFallthroughSwitchClauseOptions;
}
interface RuleWithNoFocusedTestsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoFocusedTestsOptions;
}
interface RuleWithNoForInOptions {
    level: RulePlainConfiguration;
    options?: NoForInOptions;
}
interface RuleWithNoFunctionAssignOptions {
    level: RulePlainConfiguration;
    options?: NoFunctionAssignOptions;
}
interface RuleWithNoGlobalAssignOptions {
    level: RulePlainConfiguration;
    options?: NoGlobalAssignOptions;
}
interface RuleWithNoGlobalIsFiniteOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoGlobalIsFiniteOptions;
}
interface RuleWithNoGlobalIsNanOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoGlobalIsNanOptions;
}
interface RuleWithNoHeadImportInDocumentOptions {
    level: RulePlainConfiguration;
    options?: NoHeadImportInDocumentOptions;
}
interface RuleWithNoImplicitAnyLetOptions {
    level: RulePlainConfiguration;
    options?: NoImplicitAnyLetOptions;
}
interface RuleWithNoImportAssignOptions {
    level: RulePlainConfiguration;
    options?: NoImportAssignOptions;
}
interface RuleWithNoImportCyclesOptions {
    level: RulePlainConfiguration;
    options?: NoImportCyclesOptions;
}
interface RuleWithNoImportantInKeyframeOptions {
    level: RulePlainConfiguration;
    options?: NoImportantInKeyframeOptions;
}
interface RuleWithNoIrregularWhitespaceOptions {
    level: RulePlainConfiguration;
    options?: NoIrregularWhitespaceOptions;
}
interface RuleWithNoLabelVarOptions {
    level: RulePlainConfiguration;
    options?: NoLabelVarOptions;
}
interface RuleWithNoLeakedRenderOptions {
    level: RulePlainConfiguration;
    options?: NoLeakedRenderOptions;
}
interface RuleWithNoMisleadingCharacterClassOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoMisleadingCharacterClassOptions;
}
interface RuleWithNoMisleadingInstantiatorOptions {
    level: RulePlainConfiguration;
    options?: NoMisleadingInstantiatorOptions;
}
interface RuleWithNoMisplacedAssertionOptions {
    level: RulePlainConfiguration;
    options?: NoMisplacedAssertionOptions;
}
interface RuleWithNoMisrefactoredShorthandAssignOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoMisrefactoredShorthandAssignOptions;
}
interface RuleWithNoNestedPromisesOptions {
    level: RulePlainConfiguration;
    options?: NoNestedPromisesOptions;
}
interface RuleWithNoNonNullAssertedOptionalChainOptions {
    level: RulePlainConfiguration;
    options?: NoNonNullAssertedOptionalChainOptions;
}
interface RuleWithNoOctalEscapeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoOctalEscapeOptions;
}
interface RuleWithNoParametersOnlyUsedInRecursionOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoParametersOnlyUsedInRecursionOptions;
}
interface RuleWithNoProtoOptions {
    level: RulePlainConfiguration;
    options?: NoProtoOptions;
}
interface RuleWithNoPrototypeBuiltinsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoPrototypeBuiltinsOptions;
}
interface RuleWithNoQuickfixBiomeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoQuickfixBiomeOptions;
}
interface RuleWithNoReactForwardRefOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoReactForwardRefOptions;
}
interface RuleWithNoReactSpecificPropsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoReactSpecificPropsOptions;
}
interface RuleWithNoRedeclareOptions {
    level: RulePlainConfiguration;
    options?: NoRedeclareOptions;
}
interface RuleWithNoRedundantUseStrictOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoRedundantUseStrictOptions;
}
interface RuleWithNoReturnAssignOptions {
    level: RulePlainConfiguration;
    options?: NoReturnAssignOptions;
}
interface RuleWithNoSelfCompareOptions {
    level: RulePlainConfiguration;
    options?: NoSelfCompareOptions;
}
interface RuleWithNoShadowOptions {
    level: RulePlainConfiguration;
    options?: NoShadowOptions;
}
interface RuleWithNoShadowRestrictedNamesOptions {
    level: RulePlainConfiguration;
    options?: NoShadowRestrictedNamesOptions;
}
interface RuleWithNoShorthandPropertyOverridesOptions {
    level: RulePlainConfiguration;
    options?: NoShorthandPropertyOverridesOptions;
}
interface RuleWithNoSkippedTestsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoSkippedTestsOptions;
}
interface RuleWithNoSparseArrayOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoSparseArrayOptions;
}
interface RuleWithNoSuspiciousSemicolonInJsxOptions {
    level: RulePlainConfiguration;
    options?: NoSuspiciousSemicolonInJsxOptions;
}
interface RuleWithNoTemplateCurlyInStringOptions {
    level: RulePlainConfiguration;
    options?: NoTemplateCurlyInStringOptions;
}
interface RuleWithNoThenPropertyOptions {
    level: RulePlainConfiguration;
    options?: NoThenPropertyOptions;
}
interface RuleWithNoTsIgnoreOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoTsIgnoreOptions;
}
interface RuleWithNoUnassignedVariablesOptions {
    level: RulePlainConfiguration;
    options?: NoUnassignedVariablesOptions;
}
interface RuleWithNoUndeclaredEnvVarsOptions {
    level: RulePlainConfiguration;
    options?: NoUndeclaredEnvVarsOptions;
}
interface RuleWithNoUnknownAtRulesOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownAtRulesOptions;
}
interface RuleWithNoUnknownAttributeOptions {
    level: RulePlainConfiguration;
    options?: NoUnknownAttributeOptions;
}
interface RuleWithNoUnnecessaryConditionsOptions {
    level: RulePlainConfiguration;
    options?: NoUnnecessaryConditionsOptions;
}
interface RuleWithNoUnsafeDeclarationMergingOptions {
    level: RulePlainConfiguration;
    options?: NoUnsafeDeclarationMergingOptions;
}
interface RuleWithNoUnsafeNegationOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUnsafeNegationOptions;
}
interface RuleWithNoUnusedExpressionsOptions {
    level: RulePlainConfiguration;
    options?: NoUnusedExpressionsOptions;
}
interface RuleWithNoUselessEscapeInStringOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoUselessEscapeInStringOptions;
}
interface RuleWithNoUselessRegexBackrefsOptions {
    level: RulePlainConfiguration;
    options?: NoUselessRegexBackrefsOptions;
}
interface RuleWithNoVarOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoVarOptions;
}
interface RuleWithNoVueArrowFuncInWatchOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: NoVueArrowFuncInWatchOptions;
}
interface RuleWithNoWithOptions {
    level: RulePlainConfiguration;
    options?: NoWithOptions;
}
interface RuleWithUseAdjacentOverloadSignaturesOptions {
    level: RulePlainConfiguration;
    options?: UseAdjacentOverloadSignaturesOptions;
}
interface RuleWithUseArraySortCompareOptions {
    level: RulePlainConfiguration;
    options?: UseArraySortCompareOptions;
}
interface RuleWithUseAwaitOptions {
    level: RulePlainConfiguration;
    options?: UseAwaitOptions;
}
interface RuleWithUseBiomeIgnoreFolderOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseBiomeIgnoreFolderOptions;
}
interface RuleWithUseDefaultSwitchClauseLastOptions {
    level: RulePlainConfiguration;
    options?: UseDefaultSwitchClauseLastOptions;
}
interface RuleWithUseDeprecatedDateOptions {
    level: RulePlainConfiguration;
    options?: UseDeprecatedDateOptions;
}
interface RuleWithUseErrorMessageOptions {
    level: RulePlainConfiguration;
    options?: UseErrorMessageOptions;
}
interface RuleWithUseGetterReturnOptions {
    level: RulePlainConfiguration;
    options?: UseGetterReturnOptions;
}
interface RuleWithUseGoogleFontDisplayOptions {
    level: RulePlainConfiguration;
    options?: UseGoogleFontDisplayOptions;
}
interface RuleWithUseGuardForInOptions {
    level: RulePlainConfiguration;
    options?: UseGuardForInOptions;
}
interface RuleWithUseIsArrayOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseIsArrayOptions;
}
interface RuleWithUseIterableCallbackReturnOptions {
    level: RulePlainConfiguration;
    options?: UseIterableCallbackReturnOptions;
}
interface RuleWithUseNamespaceKeywordOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNamespaceKeywordOptions;
}
interface RuleWithUseNumberToFixedDigitsArgumentOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseNumberToFixedDigitsArgumentOptions;
}
interface RuleWithUseRequiredScriptsOptions {
    level: RulePlainConfiguration;
    options?: UseRequiredScriptsOptions;
}
interface RuleWithUseStaticResponseMethodsOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseStaticResponseMethodsOptions;
}
interface RuleWithUseStrictModeOptions {
    fix?: FixKind;
    level: RulePlainConfiguration;
    options?: UseStrictModeOptions;
}
type ImportGroups = ImportGroup[];
type SortOrder = "natural" | "lexicographic";
type FixKind = "none" | "safe" | "unsafe";
type NoAccessKeyOptions = {};
interface NoAmbiguousAnchorTextOptions {
    /**
     * It allows users to modify the strings that can be checked for in the anchor text. Useful for specifying other words in other languages
     */
    words?: string[];
}
type NoAriaHiddenOnFocusableOptions = {};
type NoAriaUnsupportedElementsOptions = {};
type NoAutofocusOptions = {};
type NoDistractingElementsOptions = {};
type NoHeaderScopeOptions = {};
type NoInteractiveElementToNoninteractiveRoleOptions = {};
interface NoLabelWithoutControlOptions {
    /**
     * Array of component names that should be considered the same as an `input` element.
     */
    inputComponents?: string[];
    /**
     * Array of attributes that should be treated as the `label` accessible text content.
     */
    labelAttributes?: string[];
    /**
     * Array of component names that should be considered the same as a `label` element.
     */
    labelComponents?: string[];
}
type NoNoninteractiveElementInteractionsOptions = {};
type NoNoninteractiveElementToInteractiveRoleOptions = {};
type NoNoninteractiveTabindexOptions = {};
type NoPositiveTabindexOptions = {};
type NoRedundantAltOptions = {};
type NoRedundantRolesOptions = {};
type NoStaticElementInteractionsOptions = {};
type NoSvgWithoutTitleOptions = {};
type UseAltTextOptions = {};
type UseAnchorContentOptions = {};
type UseAriaActivedescendantWithTabindexOptions = {};
type UseAriaPropsForRoleOptions = {};
type UseAriaPropsSupportedByRoleOptions = {};
type UseButtonTypeOptions = {};
type UseFocusableInteractiveOptions = {};
type UseGenericFontNamesOptions = {};
type UseHeadingContentOptions = {};
type UseHtmlLangOptions = {};
type UseIframeTitleOptions = {};
type UseKeyWithClickEventsOptions = {};
type UseKeyWithMouseEventsOptions = {};
type UseMediaCaptionOptions = {};
type UseSemanticElementsOptions = {};
type UseValidAnchorOptions = {};
type UseValidAriaPropsOptions = {};
interface UseValidAriaRoleOptions {
    /**
     * It allows specifying a list of roles that might be invalid otherwise
     */
    allowInvalidRoles?: string[];
    /**
     * Use this option to ignore non-DOM elements, such as custom components
     */
    ignoreNonDom?: boolean;
}
type UseValidAriaValuesOptions = {};
interface UseValidAutocompleteOptions {
    /**
     * `input` like custom components that should be checked.
     */
    inputComponents?: string[];
}
type UseValidLangOptions = {};
type NoAdjacentSpacesInRegexOptions = {};
type NoArgumentsOptions = {};
type NoBannedTypesOptions = {};
type NoCommaOperatorOptions = {};
type NoDivRegexOptions = {};
type NoEmptyTypeParametersOptions = {};
interface NoExcessiveCognitiveComplexityOptions {
    /**
     * The maximum complexity score that we allow. Anything higher is considered excessive.
     */
    maxAllowedComplexity?: number;
}
interface NoExcessiveLinesPerFunctionOptions {
    /**
     * The maximum number of lines allowed in a function body.
     */
    maxLines?: number;
    /**
     * When this options is set to `true`, blank lines in the function body are not counted towards the maximum line limit.
     */
    skipBlankLines?: boolean;
    /**
     * When this option is set to `true`, Immediately Invoked Function Expressions (IIFEs) are not checked for the maximum line limit.
     */
    skipIifes?: boolean;
}
type NoExcessiveNestedTestSuitesOptions = {};
type NoExtraBooleanCastOptions = {};
type NoFlatMapIdentityOptions = {};
interface NoForEachOptions {
    /**
     * A list of variable names allowed for `forEach` calls.
     */
    allowedIdentifiers?: string[];
}
interface NoImplicitCoercionsOptions {
    /**
     * Whether to allow implicitly coercing values to booleans via `!!value`.
     */
    allowDoubleNegation?: boolean;
}
type NoImportantStylesOptions = {};
type NoRedundantDefaultExportOptions = {};
type NoStaticOnlyClassOptions = {};
type NoThisInStaticOptions = {};
type NoUselessCatchOptions = {};
type NoUselessCatchBindingOptions = {};
type NoUselessConstructorOptions = {};
type NoUselessContinueOptions = {};
type NoUselessEmptyExportOptions = {};
type NoUselessEscapeInRegexOptions = {};
type NoUselessFragmentsOptions = {};
type NoUselessLabelOptions = {};
type NoUselessLoneBlockStatementsOptions = {};
type NoUselessRenameOptions = {};
type NoUselessReturnOptions = {};
type NoUselessStringConcatOptions = {};
type NoUselessStringRawOptions = {};
type NoUselessSwitchCaseOptions = {};
type NoUselessTernaryOptions = {};
type NoUselessThisAliasOptions = {};
type NoUselessTypeConstraintOptions = {};
type NoUselessUndefinedOptions = {};
type NoUselessUndefinedInitializationOptions = {};
type NoVoidOptions = {};
type UseArrayFindOptions = {};
type UseArrowFunctionOptions = {};
type UseDateNowOptions = {};
type UseFlatMapOptions = {};
type UseIndexOfOptions = {};
type UseLiteralKeysOptions = {};
interface UseMaxParamsOptions {
    /**
     * Maximum number of parameters allowed (default: 4)
     */
    max?: number;
}
type UseNumericLiteralsOptions = {};
type UseOptionalChainOptions = {};
type UseRegexLiteralsOptions = {};
type UseSimpleNumberKeysOptions = {};
type UseSimplifiedLogicExpressionOptions = {};
type UseWhileOptions = {};
type NoBeforeInteractiveScriptOutsideDocumentOptions = {};
type NoChildrenPropOptions = {};
type NoConstAssignOptions = {};
type NoConstantConditionOptions = {};
type NoConstantMathMinMaxClampOptions = {};
type NoConstructorReturnOptions = {};
type NoDuplicateArgumentNamesOptions = {};
type NoDuplicateAttributesOptions = {};
type NoDuplicateEnumValueNamesOptions = {};
type NoDuplicateInputFieldNamesOptions = {};
type NoDuplicateVariableNamesOptions = {};
type NoEmptyCharacterClassInRegexOptions = {};
type NoEmptyPatternOptions = {};
type NoGlobalDirnameFilenameOptions = {};
type NoGlobalObjectCallsOptions = {};
type NoInnerDeclarationsOptions = {};
type NoInvalidBuiltinInstantiationOptions = {};
type NoInvalidConstructorSuperOptions = {};
type NoInvalidDirectionInLinearGradientOptions = {};
type NoInvalidGridAreasOptions = {};
type NoInvalidPositionAtImportRuleOptions = {};
type NoInvalidUseBeforeDeclarationOptions = {};
type NoMissingVarFunctionOptions = {};
type NoNestedComponentDefinitionsOptions = {};
type NoNextAsyncClientComponentOptions = {};
type NoNodejsModulesOptions = {};
type NoNonoctalDecimalEscapeOptions = {};
type NoPrecisionLossOptions = {};
interface NoPrivateImportsOptions {
    /**
     * The default visibility to assume for symbols without visibility tag.

    Default: **public**.
     */
    defaultVisibility?: Visibility;
}
type NoProcessGlobalOptions = {};
type NoQwikUseVisibleTaskOptions = {};
type NoReactPropAssignmentsOptions = {};
type NoRenderReturnValueOptions = {};
interface NoRestrictedElementsOptions {
    /**
     * Elements to restrict.
    Each key is the element name, and the value is the message to show when the element is used.
     */
    elements?: CustomRestrictedElements;
}
type NoSelfAssignOptions = {};
type NoSetterReturnOptions = {};
type NoSolidDestructuredPropsOptions = {};
type NoStringCaseMismatchOptions = {};
type NoSwitchDeclarationsOptions = {};
interface NoUndeclaredDependenciesOptions {
    /**
     * If set to `false`, then the rule will show an error when `bundleDependencies` are imported. Defaults to `true`.
     */
    bundleDependencies?: DependencyAvailability;
    /**
     * If set to `false`, then the rule will show an error when `devDependencies` are imported. Defaults to `true`.
     */
    devDependencies?: DependencyAvailability;
    /**
     * If set to `false`, then the rule will show an error when `optionalDependencies` are imported. Defaults to `true`.
     */
    optionalDependencies?: DependencyAvailability;
    /**
     * If set to `false`, then the rule will show an error when `peerDependencies` are imported. Defaults to `true`.
     */
    peerDependencies?: DependencyAvailability;
}
interface NoUndeclaredVariablesOptions {
    /**
     * Check undeclared types.
     */
    checkTypes?: boolean;
}
interface NoUnknownFunctionOptions {
    /**
     * A list of unknown function names to ignore (case-insensitive).
     */
    ignore?: string[];
}
type NoUnknownMediaFeatureNameOptions = {};
interface NoUnknownPropertyOptions {
    /**
     * A list of unknown property names to ignore (case-insensitive).
     */
    ignore?: string[];
}
interface NoUnknownPseudoClassOptions {
    /**
     * A list of unknown pseudo-class names to ignore (case-insensitive).
     */
    ignore?: string[];
}
interface NoUnknownPseudoElementOptions {
    /**
     * A list of unknown pseudo-element names to ignore (case-insensitive).
     */
    ignore?: string[];
}
type NoUnknownTypeSelectorOptions = {};
type NoUnknownUnitOptions = {};
type NoUnmatchableAnbSelectorOptions = {};
type NoUnreachableOptions = {};
type NoUnreachableSuperOptions = {};
type NoUnresolvedImportsOptions = {};
type NoUnsafeFinallyOptions = {};
type NoUnsafeOptionalChainingOptions = {};
interface NoUnusedFunctionParametersOptions {
    /**
     * Whether to ignore unused variables from an object destructuring with a spread.
     */
    ignoreRestSiblings?: boolean;
}
type NoUnusedImportsOptions = {};
type NoUnusedInstantiationOptions = {};
type NoUnusedLabelsOptions = {};
type NoUnusedPrivateClassMembersOptions = {};
interface NoUnusedVariablesOptions {
    /**
     * An object defining ignored identifiers for different language constructs.
     */
    ignore?: NoUnusedVariablesOptionsIgnore;
    /**
     * Whether to ignore unused variables from an object destructuring with a spread.
     */
    ignoreRestSiblings?: boolean;
}
type NoVoidElementsWithChildrenOptions = {};
type NoVoidTypeReturnOptions = {};
type NoVueDataObjectDeclarationOptions = {};
type NoVueDuplicateKeysOptions = {};
type NoVueReservedKeysOptions = {};
type NoVueReservedPropsOptions = {};
type NoVueSetupPropsReactivityLossOptions = {};
type NoVueVIfWithVForOptions = {};
interface UseExhaustiveDependenciesOptions {
    /**
     * List of hooks of which the dependencies should be validated.
     */
    hooks?: Hook[];
    /**
     * Whether to report an error when a hook has no dependencies array.
     */
    reportMissingDependenciesArray?: boolean;
    /**
     * Whether to report an error when a dependency is listed in the dependencies array but isn't used. Defaults to true.
     */
    reportUnnecessaryDependencies?: boolean;
}
type UseGraphqlNamedOperationsOptions = {};
interface UseHookAtTopLevelOptions {
    /**
     * List of function names that should not be treated as hooks.
    Functions in this list will be ignored by the rule even if they follow the `use*` naming convention.
     */
    ignore?: string[];
}
type UseImageSizeOptions = null;
interface UseImportExtensionsOptions {
    /**
     * A map of file extensions to their suggested replacements.
    For example, `{"ts": "js"}` would suggest `.js` extensions for TypeScript imports.
     */
    extensionMappings?: Record<string, string>;
    /**
     * If `true`, the suggested extension is always `.js` regardless of what
    extension the source file has in your project.
     */
    forceJsExtensions?: boolean;
}
type UseInlineScriptIdOptions = {};
type UseIsNanOptions = {};
type UseJsonImportAttributesOptions = {};
interface UseJsxKeyInIterableOptions {
    /**
     * Set to `true` to check shorthand fragments (`<></>`)
     */
    checkShorthandFragments?: boolean;
}
type UseLoneAnonymousOperationOptions = {};
type UseParseIntRadixOptions = {};
type UseQwikClasslistOptions = {};
type UseQwikMethodUsageOptions = {};
type UseQwikValidLexicalScopeOptions = {};
type UseSingleJsDocAsteriskOptions = {};
interface UseUniqueElementIdsOptions {
    /**
     * Component names that accept an `id` prop that does not translate
    to a DOM element id.
     */
    excludedComponents?: string[];
}
type UseValidForDirectionOptions = {};
type UseValidTypeofOptions = {};
type UseVueVForKeyOptions = {};
type UseVueValidTemplateRootOptions = {};
type UseVueValidVBindOptions = {};
type UseVueValidVCloakOptions = {};
type UseVueValidVElseOptions = {};
type UseVueValidVElseIfOptions = {};
type UseVueValidVHtmlOptions = {};
type UseVueValidVIfOptions = {};
interface UseVueValidVOnOptions {
    /**
     * Additional modifiers that should be considered valid
     */
    modifiers?: string[];
}
type UseVueValidVOnceOptions = {};
type UseVueValidVPreOptions = {};
type UseVueValidVTextOptions = {};
type UseYieldOptions = {};
interface NoBaseToStringOptions {
    ignoredTypeNames?: string[];
}
type NoComponentHookFactoriesOptions = {};
type NoConditionalExpectOptions = {};
interface NoDrizzleDeleteWithoutWhereOptions {
    /**
     * List of variable names to consider as Drizzle ORM instances.
     */
    drizzleObjectName?: string[];
}
interface NoDrizzleUpdateWithoutWhereOptions {
    /**
     * List of variable names to consider as Drizzle ORM instances.
     */
    drizzleObjectName?: string[];
}
type NoDuplicateFieldDefinitionNamesOptions = {};
type NoDuplicateSelectorsOptions = {};
type NoEmptyObjectKeysOptions = {};
interface NoExcessiveNestedCallbacksOptions {
    /**
     * Maximum callback nesting depth allowed (default: 5)
     */
    max?: number;
}
interface NoExcessiveSelectorClassesOptions {
    /**
     * The maximum number of class selectors allowed in a single selector.

    This option is required to enable the rule.
    Use `0` to disallow class selectors entirely.
     */
    maxClasses?: number;
}
type NoFloatingPromisesOptions = {};
type NoIdenticalTestTitleOptions = {};
type NoImpliedEvalOptions = {};
type NoInlineStylesOptions = {};
type NoJsxLeakedDollarOptions = {};
type NoJsxNamespaceOptions = {};
type NoLoopFuncOptions = {};
type NoMisleadingReturnTypeOptions = {};
type NoMisusedPromisesOptions = {};
type NoNegationInEqualityCheckOptions = {};
type NoPlaywrightElementHandleOptions = {};
type NoPlaywrightEvalOptions = {};
type NoPlaywrightForceOptionOptions = {};
type NoPlaywrightMissingAwaitOptions = {};
type NoPlaywrightNetworkidleOptions = {};
type NoPlaywrightPagePauseOptions = {};
type NoPlaywrightUselessAwaitOptions = {};
type NoPlaywrightWaitForNavigationOptions = {};
type NoPlaywrightWaitForSelectorOptions = {};
type NoPlaywrightWaitForTimeoutOptions = {};
type NoReactNativeDeepImportsOptions = {};
type NoReactNativeLiteralColorsOptions = {};
interface NoReactNativeRawTextOptions {
    /**
     * Names of additional components that are allowed to contain raw text.
     */
    skip?: string[];
}
type NoReactStringRefsOptions = {};
type NoRestrictedDependenciesOptions = {};
interface NoSvelteUnnecessaryStateWrapOptions {
    /**
     * Additional class names to treat as already reactive (beyond the built-in `svelte/reactivity` classes).
     */
    additionalReactiveClasses?: string[];
    /**
     * When `true`, allows `$state()` wrapping for variables that are reassigned after declaration.
     */
    allowReassign?: boolean;
}
type NoTopLevelLiteralsOptions = {};
type NoUndeclaredClassesOptions = {};
type NoUnnecessaryTemplateExpressionOptions = {};
type NoUnsafePlusOperandsOptions = {};
interface NoUntrustedLicensesOptions {
    /**
     * Additional license identifiers to trust, beyond valid SPDX identifiers.

    Useful for custom or proprietary licenses that are not part of the SPDX
    standard but are acceptable in your project.
     */
    allow?: string[];
    /**
     * License identifiers to explicitly deny, even if they are valid SPDX identifiers.

    Use this to block specific licenses that your project or organization can't use (e.g.,
    copyleft licenses in a proprietary project).
     */
    deny?: string[];
    /**
     * When `true`, deprecated SPDX license identifiers are accepted.
    When `false`, deprecated licenses are flagged as untrusted.
    Defaults to `false`.
     */
    ignoreDeprecated?: boolean;
    /**
     * When `true`, only licenses recognized as free/libre by the Free Software
    Foundation (FSF) are trusted. Licenses in the `allow` list bypass this check.
    Defaults to `false`.
     */
    requireFsfLibre?: boolean;
    /**
     * When `true`, only licenses approved by the Open Source Initiative (OSI)
    are trusted. Licenses in the `allow` list bypass this check.
    Defaults to `false`.
     */
    requireOsiApproved?: boolean;
}
type NoUnusedClassesOptions = {};
type NoUselessTypeConversionOptions = {};
type NoVueImportCompilerMacrosOptions = {};
type NoVueRefAsOperandOptions = {};
type NoVueVOnNumberValuesOptions = {};
type UseArraySomeOptions = {};
type UseAwaitThenableOptions = {};
interface UseBaselineOptions {
    /**
     * CSS at-rules to exclude from checking (without `@`, case-insensitive).
     */
    allowAtRules?: string[];
    /**
     * CSS value functions to exclude from checking (case-insensitive).
     */
    allowFunctions?: string[];
    /**
     * CSS media conditions to exclude from checking (case-insensitive).
     */
    allowMediaConditions?: string[];
    /**
     * CSS properties to exclude from checking (case-insensitive).
     */
    allowProperties?: string[];
    /**
     * CSS property values to exclude from checking (maps property name to allowed values, case-insensitive).
     */
    allowPropertyValues?: Record<string, string[]>;
    /**
     * CSS pseudo-selectors to exclude from checking (without `:` or `::`, case-insensitive).
     */
    allowSelectors?: string[];
    /**
     * The availability level to target. Defaults to `"widely"`.
     */
    available?: AvailabilityTarget;
}
interface UseConsistentTestItOptions {
    /**
     * The function to use for top-level tests (outside describe blocks).
    Default: `"it"`
     */
    function?: TestFunctionKind;
    /**
     * The function to use for tests inside describe blocks.
    Default: `"it"`
     */
    withinDescribe?: TestFunctionKind;
}
type UseDisposablesOptions = {};
type UseDomNodeTextContentOptions = {};
interface UseDomQuerySelectorOptions {
    /**
     * A list of receiver identifiers to ignore.

    In the expression `document.querySelector('div')`, the receiver is `document`.
     */
    ignore?: string[];
}
type UseExhaustiveSwitchCasesOptions = {};
type UseExpectOptions = {};
interface UseExplicitReturnTypeOptions {
    /**
     * Whether to ignore function expressions (functions that are not part of a declaration).
    When `true`, only declarations (function statements and class methods) are checked.
     */
    allowExpressions?: boolean;
    /**
     * Whether to allow IIFEs (Immediately Invoked Function Expressions) without explicit return types.
     */
    allowIifes?: boolean;
    /**
     * A list of function names that are allowed to not have explicit return types.
     */
    allowedNames?: string[];
}
type UseExplicitTypeOptions = {};
type UseIframeSandboxOptions = {};
type UseImportsFirstOptions = {};
type UseIncludesOptions = {};
type UseMathMinMaxOptions = {};
type UseNamedCaptureGroupOptions = {};
interface UseNullishCoalescingOptions {
    /**
     * Whether to ignore `||` and `||=` binary operations used inside a `Boolean()` call (default: `false`).
     */
    ignoreBooleanCoercion?: boolean;
    /**
     * Ignore `||` expressions in conditional test positions (default: `true`).
     */
    ignoreConditionalTests?: boolean;
    /**
     * Whether to ignore `||` and `||=` binary operations that are part of a mixed logical expression with `&&` (default: `false`).
     */
    ignoreMixedLogicalExpressions?: boolean;
    /**
     * Whether to ignore `||` and `||=` operations whose non-nullish operand types are all primitives of the configured kinds. Accepts `true` for every primitive, or an object selecting `string`, `number`, `boolean`, `bigint` (default: none).
     */
    ignorePrimitives?: IgnorePrimitives;
    /**
     * Ignore ternary expressions that check for `null` or `undefined` (default: `false`).
     */
    ignoreTernaryTests?: boolean;
}
type UsePlaywrightValidDescribeCallbackOptions = {};
type UseQwikLoaderLocationOptions = {};
type UseReactAsyncServerFunctionOptions = {};
interface UseReactFunctionComponentDefinitionOptions {
    /**
     * The function style to enforce for named React components.
     */
    namedComponents?: ComponentDefinitionStyle;
}
interface UseReactNativePlatformComponentsOptions {
    /**
     * A list of glob patterns to identify Android-specific files.
    Defaults to `["**\/*.android.{js,jsx,ts,tsx}"]`.
     */
    androidPathPatterns?: NormalizedGlob[];
    /**
     * A list of glob patterns to identify iOS-specific files.
    Defaults to `["**\/*.ios.{js,jsx,ts,tsx}"]`.
     */
    iosPathPatterns?: NormalizedGlob[];
}
type UseReduceTypeParameterOptions = {};
type UseRegexpExecOptions = {};
type UseRegexpTestOptions = {};
type UseScopedStylesOptions = {};
interface UseSortedClassesOptions {
    /**
     * Additional attributes that will be sorted.
     */
    attributes?: string[];
    /**
     * Names of the functions or tagged templates that will be sorted.
     */
    functions?: string[];
}
type UseStringStartsEndsWithOptions = {};
type UseSvelteRequireEachKeyOptions = {};
type UseTestHooksInOrderOptions = {};
type UseTestHooksOnTopOptions = {};
interface UseThisInClassMethodsOptions {
    /**
     * Whether members of classes with an `implements` clause should be ignored.

    Defaults to `"none"`, which means implemented classes are checked like any other class.
    Use `"all"` to ignore every eligible member in such classes, or `"public-fields"`
    to ignore only public members in them.
     */
    ignoreClassesWithImplements?: IgnoreClassesWithImplements;
    /**
     * Method names that should be ignored by the rule.

    Defaults to `[]`.
     */
    ignoreMethods?: string[];
    /**
     * Whether methods marked with `override` should be ignored.

    Defaults to `false`.
     */
    ignoreOverrideMethods?: boolean;
}
type UseUnicodeRegexOptions = {};
type UseVarsOnTopOptions = {};
interface UseVueConsistentDefinePropsDeclarationOptions {
    style?: DeclarationStyle;
}
type UseVueNextTickPromiseOptions = {};
type UseVueValidVForOptions = {};
type NoAccumulatingSpreadOptions = {};
type NoAwaitInLoopsOptions = {};
type NoBarrelFileOptions = {};
type NoDeleteOptions = {};
type NoDynamicNamespaceImportAccessOptions = {};
type NoImgElementOptions = {};
type NoJsxPropsBindOptions = {};
type NoNamespaceImportOptions = {};
type NoReExportAllOptions = {};
type NoSyncScriptsOptions = {};
type NoUnwantedPolyfillioOptions = {};
type UseGoogleFontPreconnectOptions = {};
type UseSolidForComponentOptions = {};
type UseTopLevelRegexOptions = {};
type UseVueVaporOptions = {};
interface NoBlankTargetOptions {
    /**
     * List of domains where `target="_blank"` is allowed without
    `rel="noopener"`.
     */
    allowDomains?: string[];
    /**
     * Whether `noreferrer` is allowed in addition to `noopener`.
     */
    allowNoReferrer?: boolean;
}
type NoDangerouslySetInnerHtmlOptions = {};
type NoDangerouslySetInnerHtmlWithChildrenOptions = {};
type NoGlobalEvalOptions = {};
type NoScriptUrlOptions = {};
interface NoSecretsOptions {
    /**
     * Set entropy threshold (default is 41).
     */
    entropyThreshold?: number;
}
type NoCommonJsOptions = {};
type NoContinueOptions = {};
type NoDefaultExportOptions = {};
type NoDescendingSpecificityOptions = {};
type NoDoneCallbackOptions = {};
type NoEnumOptions = {};
interface NoExcessiveClassesPerFileOptions {
    /**
     * The maximum number of classes allowed in a file.
     */
    maxClasses?: number;
}
interface NoExcessiveLinesPerFileOptions {
    /**
     * The maximum number of lines allowed in a file.
     */
    maxLines?: number;
    /**
     * When this option is set to `true`, blank lines are not counted towards the maximum line limit.
     */
    skipBlankLines?: boolean;
}
type NoExportedImportsOptions = {};
type NoHeadElementOptions = {};
type NoHexColorsOptions = {};
type NoImplicitBooleanOptions = {};
interface NoIncrementDecrementOptions {
    /**
     * Allows unary operators ++ and -- in the afterthought (final expression) of a for loop.
     */
    allowForLoopAfterthoughts?: boolean;
}
type NoInferrableTypesOptions = {};
interface NoJsxLiteralsOptions {
    /**
     * An array of strings that won't trigger the rule. Whitespaces are taken into consideration
     */
    allowedStrings?: string[];
    /**
     * When enabled, strings inside props are always ignored
     */
    ignoreProps?: boolean;
    /**
     * When enabled, also flag string literals inside JSX expressions and attributes
     */
    noStrings?: boolean;
}
type NoMagicNumbersOptions = {};
type NoMultiAssignOptions = {};
type NoMultilineStringOptions = {};
type NoNamespaceOptions = {};
type NoNegationElseOptions = {};
type NoNestedTernaryOptions = {};
type NoNonNullAssertionOptions = {};
interface NoParameterAssignOptions {
    /**
     * Whether to report an error when a dependency is listed in the dependencies array but isn't used. Defaults to `allow`.
     */
    propertyAssignment?: PropertyAssignmentMode;
}
type NoParameterPropertiesOptions = {};
type NoProcessEnvOptions = {};
interface NoRestrictedGlobalsOptions {
    /**
     * A list of names that should trigger the rule
     */
    deniedGlobals?: Record<string, string>;
}
interface NoRestrictedImportsOptions {
    /**
     * A list of import paths that should trigger the rule.
     */
    paths?: Record<string, Paths>;
    /**
     * gitignore-style patterns that should trigger the rule.
     */
    patterns?: Patterns[];
}
interface NoRestrictedTypesOptions {
    types?: Record<string, CustomRestrictedType>;
}
interface NoRootTypeOptions {
    /**
     * A list of disallowed root types (e.g. "mutation" and/or "subscription").
    The values of the list are case-insensitive.
     */
    disallow?: string[];
}
type NoShoutyConstantsOptions = {};
type NoSubstrOptions = {};
type NoTernaryOptions = {};
type NoUnusedTemplateLiteralOptions = {};
type NoUselessElseOptions = {};
type NoValueAtRuleOptions = {};
type NoVueOptionsApiOptions = {};
type NoYodaExpressionOptions = {};
type UseArrayLiteralsOptions = {};
type UseAsConstAssertionOptions = {};
type UseAtIndexOptions = {};
type UseBlockStatementsOptions = {};
type UseCollapsedElseIfOptions = {};
type UseCollapsedIfOptions = {};
interface UseComponentExportOnlyModulesOptions {
    /**
     * Allows the export of constants. This option is for environments that support it, such as [Vite](https://vitejs.dev/)
     */
    allowConstantExport?: boolean;
    /**
     * A list of names that can be additionally exported from the module This option is for exports that do not hinder [React Fast Refresh](https://github.com/facebook/react/tree/main/packages/react-refresh), such as [`meta` in Remix](https://remix.run/docs/en/main/route/meta)
     */
    allowExportNames?: string[];
}
interface UseConsistentArrayTypeOptions {
    syntax?: ConsistentArrayType;
}
interface UseConsistentArrowReturnOptions {
    /**
     * Determines whether the rule enforces a consistent style when the return value is an object literal.

    This option is only applicable when used in conjunction with the `asNeeded` option.
     */
    requireForObjectLiteral?: boolean;
    /**
     * The style to enforce for arrow function return statements.
     */
    style?: UseConsistentArrowReturnStyle;
}
type UseConsistentBuiltinInstantiationOptions = {};
type UseConsistentCurlyBracesOptions = {};
type UseConsistentEnumValueTypeOptions = {};
interface UseConsistentGraphqlDescriptionsOptions {
    /**
     * The description style to enforce. Defaults to "block"
     */
    style?: UseConsistentGraphqlDescriptionsStyle;
}
interface UseConsistentMemberAccessibilityOptions {
    /**
     * The kind of accessibility you want to enforce. Default to "noPublic"
     */
    accessibility?: Accessibility;
}
interface UseConsistentMethodSignaturesOptions {
    /**
     * The style of method signatures whose usage will be enforced.

    Default: "property"
     */
    style?: MethodSignatureStyle;
}
interface UseConsistentObjectDefinitionsOptions {
    /**
     * The preferred syntax to enforce.
     */
    syntax?: ObjectPropertySyntax;
}
interface UseConsistentTypeDefinitionsOptions {
    style?: ConsistentTypeDefinition;
}
type UseConstOptions = {};
type UseDefaultParameterLastOptions = {};
type UseDefaultSwitchClauseOptions = {};
type UseDeprecatedReasonOptions = {};
interface UseDestructuringOptions {
    assignmentExpression?: DestructuringConfig;
    variableDeclarator?: DestructuringConfig;
}
type UseEnumInitializersOptions = {};
interface UseErrorCauseOptions {
    /**
     * When set to `true`, the rule requires that `catch` clauses have a parameter.
     */
    requireCatchParameter?: boolean;
}
type UseExplicitLengthCheckOptions = {};
type UseExponentiationOperatorOptions = {};
interface UseExportTypeOptions {
    /**
     * The style to apply when exporting types. Default to "auto".
     */
    style?: UseExportTypeStyle;
}
type UseExportsLastOptions = {};
interface UseFilenamingConventionOptions {
    /**
     * Allowed cases for file names.
     */
    filenameCases?: FilenameCases;
    /**
     * Regular expression to enforce
     */
    match?: Regex;
    /**
     * If `false`, then non-ASCII characters are allowed.
     */
    requireAscii?: boolean;
    /**
     * If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases.
    This does not affect other [Case].
     */
    strictCase?: boolean;
}
type UseForOfOptions = {};
type UseFragmentSyntaxOptions = {};
type UseGlobalThisOptions = {};
type UseGraphqlNamingConventionOptions = {};
type UseGroupedAccessorPairsOptions = {};
interface UseImportTypeOptions {
    /**
     * The style to apply when importing types. Default to "auto".
     */
    style?: UseImportTypeStyle;
}
interface UseInputNameOptions {
    /**
     * Check that the input type name follows the convention <mutationName>Input
     */
    checkInputType?: CheckInputType;
}
type UseLiteralEnumMembersOptions = {};
type UseLoneExecutableDefinitionOptions = {};
interface UseNamingConventionOptions {
    /**
     * Custom conventions.
     */
    conventions?: Convention[];
    /**
     * If `false`, then non-ASCII characters are allowed.
     */
    requireAscii?: boolean;
    /**
     * If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases.
    This does not affect other [Case].
     */
    strictCase?: boolean;
}
type UseNodeAssertStrictOptions = {};
type UseNodejsImportProtocolOptions = {};
type UseNumberNamespaceOptions = {};
interface UseNumericSeparatorsOptions {
    /**
     * Options for binary literals (e.g., `0b1010_0001`).
     */
    binary?: NumericLiteralSeparatorOptions;
    /**
     * Options for decimal literals (e.g., `1_234_567`).
     */
    decimal?: NumericLiteralSeparatorOptions;
    /**
     * Options for hexadecimal literals (e.g., `0xAB_CD`).
     */
    hexadecimal?: NumericLiteralSeparatorOptions;
    /**
     * Options for octal literals (e.g., `0o1234_5670`).
     */
    octal?: NumericLiteralSeparatorOptions;
}
type UseObjectSpreadOptions = {};
type UseReactFunctionComponentsOptions = {};
interface UseReadonlyClassPropertiesOptions {
    /**
     * When `true`, the keywords `public`, `protected`, and `private` are analyzed by the rule.
     */
    checkAllProperties?: boolean;
}
interface UseSelfClosingElementsOptions {
    ignoreHtmlElements?: boolean;
}
type UseShorthandAssignOptions = {};
type UseShorthandFunctionTypeOptions = {};
type UseSingleVarDeclaratorOptions = {};
type UseSpreadOverApplyOptions = {};
type UseSymbolDescriptionOptions = {};
type UseTemplateOptions = {};
type UseThrowNewErrorOptions = {};
type UseThrowOnlyErrorOptions = {};
type UseTrimStartEndOptions = {};
interface UseUnifiedTypeSignaturesOptions {
    /**
     * Whether to ignore overloads with different JSDoc comments.
     */
    ignoreDifferentJsDoc?: boolean;
    /**
     * Whether to ignore overloads with differently named parameters.
     */
    ignoreDifferentlyNamedParameters?: boolean;
}
interface UseVueConsistentVBindStyleOptions {
    /**
     * Preferred style for `v-bind` usage: "shorthand" or "longhand".
    If omitted, shorthand is preferred.
     */
    style?: VueDirectiveStyle;
}
interface UseVueConsistentVOnStyleOptions {
    /**
     * Preferred style for `v-on` usage: "shorthand" or "longhand".
    If omitted, shorthand is preferred.
     */
    style?: VueDirectiveStyle2;
}
interface UseVueDefineMacrosOrderOptions {
    /**
     * The order of the Vue define macros.
     */
    order?: string[];
}
interface UseVueHyphenatedAttributesOptions {
    /**
     * List of attribute names to ignore when checking for hyphenated attributes.
     */
    ignore?: string[];
    /**
     * List of HTML tags to ignore when checking for hyphenated attributes.
     */
    ignoreTags?: string[];
}
interface UseVueMultiWordComponentNamesOptions {
    /**
     * Component names to ignore (allowed to be single-word).
     */
    ignores?: string[];
}
type NoAlertOptions = {};
type NoApproximativeNumericConstantOptions = {};
type NoArrayIndexKeyOptions = {};
type NoAssignInExpressionsOptions = {};
type NoAsyncPromiseExecutorOptions = {};
type NoBiomeFirstExceptionOptions = {};
interface NoBitwiseOperatorsOptions {
    /**
     * Allows a list of bitwise operators to be used as exceptions.
     */
    allow?: string[];
}
type NoCatchAssignOptions = {};
type NoClassAssignOptions = {};
type NoCommentTextOptions = {};
type NoCompareNegZeroOptions = {};
interface NoConfusingLabelsOptions {
    /**
     * A list of (non-confusing) labels that should be allowed
     */
    allowedLabels?: string[];
}
type NoConfusingVoidTypeOptions = {};
interface NoConsoleOptions {
    /**
     * Allowed calls on the console object.
     */
    allow?: string[];
}
type NoConstEnumOptions = {};
type NoConstantBinaryExpressionsOptions = {};
type NoControlCharactersInRegexOptions = {};
type NoDebuggerOptions = {};
type NoDeprecatedImportsOptions = {};
interface NoDeprecatedMediaTypeOptions {
    /**
     * Media types to allow (case-insensitive).
     */
    allow?: string[];
}
type NoDocumentCookieOptions = {};
type NoDocumentImportInPageOptions = {};
interface NoDoubleEqualsOptions {
    /**
     * If `true`, an exception is made when comparing with `null`, as it's often relied on to check
    both for `null` or `undefined`.

    If `false`, no such exception will be made.
     */
    ignoreNull?: boolean;
}
type NoDuplicateAtImportRulesOptions = {};
type NoDuplicateCaseOptions = {};
type NoDuplicateClassMembersOptions = {};
type NoDuplicateCustomPropertiesOptions = {};
type NoDuplicateDependenciesOptions = {};
type NoDuplicateElseIfOptions = {};
type NoDuplicateEnumValuesOptions = {};
type NoDuplicateFieldsOptions = {};
type NoDuplicateFontNamesOptions = {};
type NoDuplicateGraphqlOperationNameOptions = {};
type NoDuplicateJsxPropsOptions = {};
type NoDuplicateObjectKeysOptions = {};
type NoDuplicateParametersOptions = {};
type NoDuplicatePropertiesOptions = {};
type NoDuplicateSelectorsKeyframeBlockOptions = {};
type NoDuplicateTestHooksOptions = {};
type NoDuplicatedSpreadPropsOptions = {};
type NoEmptyBlockOptions = {};
type NoEmptyBlockStatementsOptions = {};
type NoEmptyInterfaceOptions = {};
interface NoEmptySourceOptions {
    /**
     * Whether comments are considered meaningful
     */
    allowComments?: boolean;
}
type NoEqualsToNullOptions = {};
type NoEvolvingTypesOptions = {};
type NoExplicitAnyOptions = {};
type NoExportsInTestOptions = {};
type NoExtraNonNullAssertionOptions = {};
type NoFallthroughSwitchClauseOptions = {};
type NoFocusedTestsOptions = {};
type NoForInOptions = {};
type NoFunctionAssignOptions = {};
type NoGlobalAssignOptions = {};
type NoGlobalIsFiniteOptions = {};
type NoGlobalIsNanOptions = {};
type NoHeadImportInDocumentOptions = {};
type NoImplicitAnyLetOptions = {};
type NoImportAssignOptions = {};
interface NoImportCyclesOptions {
    /**
     * Ignores type-only imports when finding an import cycle. A type-only import (`import type`)
    will be removed by the compiler, so it cuts an import cycle at runtime. Note that named type
    imports (`import { type Foo }`) aren't considered as type-only because it's not removed by
    the compiler if the `verbatimModuleSyntax` option is enabled. Enabled by default.
     */
    ignoreTypes?: boolean;
}
type NoImportantInKeyframeOptions = {};
type NoIrregularWhitespaceOptions = {};
type NoLabelVarOptions = {};
type NoLeakedRenderOptions = {};
type NoMisleadingCharacterClassOptions = {};
type NoMisleadingInstantiatorOptions = {};
type NoMisplacedAssertionOptions = {};
type NoMisrefactoredShorthandAssignOptions = {};
type NoNestedPromisesOptions = {};
type NoNonNullAssertedOptionalChainOptions = {};
type NoOctalEscapeOptions = {};
type NoParametersOnlyUsedInRecursionOptions = {};
type NoProtoOptions = {};
type NoPrototypeBuiltinsOptions = {};
interface NoQuickfixBiomeOptions {
    /**
     * A list of additional JSON files that should be checked.
     */
    additionalPaths?: string[];
}
type NoReactForwardRefOptions = {};
type NoReactSpecificPropsOptions = {};
type NoRedeclareOptions = {};
type NoRedundantUseStrictOptions = {};
type NoReturnAssignOptions = {};
type NoSelfCompareOptions = {};
interface NoShadowOptions {
    /**
     * Ignore parameter names in function type annotations.

    Function type parameters (e.g. `(x: string) => void`) only create
    bindings within the type scope and rarely cause confusion.

    Defaults to `true`.
     */
    ignoreFunctionTypeParameterNameValueShadow?: boolean;
    /**
     * Ignore cases where a type and a value share the same name.

    Types and values live in separate namespaces in TypeScript, so a
    variable named `Foo` and a `type Foo` cannot collide at runtime.

    Defaults to `true`.
     */
    ignoreTypeValueShadow?: boolean;
}
type NoShadowRestrictedNamesOptions = {};
type NoShorthandPropertyOverridesOptions = {};
type NoSkippedTestsOptions = {};
type NoSparseArrayOptions = {};
type NoSuspiciousSemicolonInJsxOptions = {};
type NoTemplateCurlyInStringOptions = {};
type NoThenPropertyOptions = {};
type NoTsIgnoreOptions = {};
type NoUnassignedVariablesOptions = {};
interface NoUndeclaredEnvVarsOptions {
    /**
     * Environment variables that should always be allowed.
    Use this to specify environment variables that are always available
    in your environment, even when not declared in turbo.json.
    Supports regular expressions, e.g. `["MY_ENV_.*"]`.
     */
    allowedEnvVars?: Regex[];
}
interface NoUnknownAtRulesOptions {
    /**
     * A list of unknown at-rule names to ignore (case-insensitive).
     */
    ignore?: string[];
}
interface NoUnknownAttributeOptions {
    ignore?: string[];
}
type NoUnnecessaryConditionsOptions = {};
type NoUnsafeDeclarationMergingOptions = {};
type NoUnsafeNegationOptions = {};
type NoUnusedExpressionsOptions = {};
type NoUselessEscapeInStringOptions = {};
type NoUselessRegexBackrefsOptions = {};
type NoVarOptions = {};
type NoVueArrowFuncInWatchOptions = {};
type NoWithOptions = {};
type UseAdjacentOverloadSignaturesOptions = {};
type UseArraySortCompareOptions = {};
type UseAwaitOptions = {};
type UseBiomeIgnoreFolderOptions = {};
type UseDefaultSwitchClauseLastOptions = {};
interface UseDeprecatedDateOptions {
    argumentName?: string;
}
type UseErrorMessageOptions = {};
type UseGetterReturnOptions = {};
type UseGoogleFontDisplayOptions = {};
type UseGuardForInOptions = {};
type UseIsArrayOptions = {};
interface UseIterableCallbackReturnOptions {
    /**
     * When `true`, allows callbacks in methods that require a return value
    (e.g. `map`, `filter`) to implicitly return `undefined` via `return;`.
     */
    allowImplicit?: boolean;
    /**
     * When `true`, the rule reports `forEach` callbacks that return a value (default behaviour).
    When `false` or unset, such callbacks are ignored.
     */
    checkForEach?: boolean;
}
type UseNamespaceKeywordOptions = {};
type UseNumberToFixedDigitsArgumentOptions = {};
interface UseRequiredScriptsOptions {
    /**
     * List of script names that must be present in package.json
     */
    requiredScripts?: string[];
}
type UseStaticResponseMethodsOptions = {};
type UseStrictModeOptions = {};
type ImportGroup = null | GroupMatcher | GroupMatcher[];
type Visibility = "public" | "package" | "private";
type CustomRestrictedElements = Record<string, string>;
type DependencyAvailability = boolean | string[];
interface NoUnusedVariablesOptionsIgnore {
    /**
     * An array of identifiers to ignore. Use "*" to ignore all identifiers.
     */
    "*"?: string[];
    /**
     * An array of class names to ignore. Use "*" to ignore all identifiers.
     */
    class?: string[];
    /**
     * An array of function names to ignore. Use "*" to ignore all identifiers.
     */
    function?: string[];
    /**
     * An array of interface names to ignore. Use "*" to ignore all identifiers.
     */
    interface?: string[];
    /**
     * An array of type aliases to ignore. Use "*" to ignore all identifiers.
     */
    typeAlias?: string[];
    /**
     * An array of type parameters to ignore. Use "*" to ignore all identifiers.
     */
    typeParameter?: string[];
    /**
     * An array of variable names to ignore. Use "*" to ignore all identifiers.
     */
    variable?: string[];
}
interface Hook {
    /**
     * The "position" of the closure function, starting from zero.

    For example, for React's `useEffect()` hook, the closure index is 0.
     */
    closureIndex?: number;
    /**
     * The "position" of the array of dependencies, starting from zero.

    For example, for React's `useEffect()` hook, the dependencies index is 1.
     */
    dependenciesIndex?: number;
    /**
     * The name of the hook.
     */
    name?: string;
    /**
     * Whether the result of the hook is stable.

    Set to `true` to mark the identity of the hook's return value as stable,
    or use a number/an array of numbers to mark the "positions" in the
    return array as stable.

    For example, for React's `useRef()` hook the value would be `true`,
    while for `useState()` it would be `[1]`.
     */
    stableResult?: StableHookResult;
}
type AvailabilityTarget = AvailabilityNamed | number;
type TestFunctionKind = "it" | "test";
type IgnorePrimitives =
| boolean
| { bigint?: boolean; boolean?: boolean; number?: boolean; string?: boolean };
type ComponentDefinitionStyle =
| "functionDeclaration"
| "functionExpression"
| "arrowFunction";
type IgnoreClassesWithImplements = "none" | "all" | "public-fields";
type DeclarationStyle = "type" | "runtime";
type PropertyAssignmentMode = "allow" | "deny";
type Paths = string | PathOptions;
type Patterns = PatternOptions;
type CustomRestrictedType = string | CustomRestrictedTypeOptions;
type ConsistentArrayType = "shorthand" | "generic";
type UseConsistentArrowReturnStyle = "asNeeded" | "always" | "never";
type UseConsistentGraphqlDescriptionsStyle = "block" | "inline";
type Accessibility = "noPublic" | "explicit" | "none";
type MethodSignatureStyle = "property" | "method";
type ObjectPropertySyntax = "explicit" | "shorthand";
type ConsistentTypeDefinition = "interface" | "type";
interface DestructuringConfig {
    array?: boolean;
    object?: boolean;
}
type UseExportTypeStyle = "auto" | "inlineType" | "separatedType";
type FilenameCases = FilenameCase[];
type Regex = string;
type UseImportTypeStyle = "auto" | "inlineType" | "separatedType";
type CheckInputType = "off" | "loose" | "strict";
interface Convention {
    /**
     * String cases to enforce
     */
    formats?: Formats;
    /**
     * Regular expression to enforce
     */
    match?: Regex;
    /**
     * Declarations concerned by this convention
     */
    selector?: Selector;
}
interface NumericLiteralSeparatorOptions {
    /**
     * Number of digits between separators.
     */
    groupLength?: number;
    /**
     * Minimum number of digits required before adding separators.
     */
    minimumDigits?: number;
}
type VueDirectiveStyle = "shorthand" | "longhand";
type VueDirectiveStyle2 = "shorthand" | "longhand";
type GroupMatcher = ImportMatcher | SourceMatcher;
type StableHookResult = boolean | number[] | string[];
type AvailabilityNamed = "widely" | "newly";
interface PathOptions {
    /**
     * Names of the exported members that allowed to be not be used.
     */
    allowImportNames?: string[];
    /**
     * Names of the exported members that should not be used.
     */
    importNames?: string[];
    /**
     * The message to display when this module is imported.
     */
    message?: string;
}
interface PatternOptions {
    /**
     * An array of gitignore-style patterns.
     */
    group?: SourcesMatcher;
    /**
     * A regex pattern for import names to forbid within the matched modules.
     */
    importNamePattern?: Regex;
    /**
     * If true, the matched patterns in the importNamePattern will be allowed. Defaults to `false`.
     */
    invertImportNamePattern?: boolean;
    /**
     * A custom message for diagnostics related to this pattern.
     */
    message?: string;
}
interface CustomRestrictedTypeOptions {
    message?: string;
    use?: string;
}
type FilenameCase =
| "camelCase"
| "export"
| "kebab-case"
| "PascalCase"
| "snake_case";
type Formats = Format[];
interface Selector {
    /**
     * Declaration kind
     */
    kind?: Kind;
    /**
     * Modifiers used on the declaration
     */
    modifiers?: Modifiers;
    /**
     * Scope of the declaration
     */
    scope?: Scope;
}
interface ImportMatcher {
    kind?: NegatableImportKindMatcher;
    source?: SourcesMatcher;
    type?: boolean;
}
type SourceMatcher = NegatablePredefinedSourceMatcher | ImportSourceGlob;
type SourcesMatcher = SourceMatcher | SourceMatcher[];
type Format = "camelCase" | "CONSTANT_CASE" | "PascalCase" | "snake_case";
type Kind =
| "class"
| "enum"
| "interface"
| "enumMember"
| "importNamespace"
| "exportNamespace"
| "variable"
| "const"
| "let"
| "using"
| "var"
| "catchParameter"
| "indexParameter"
| "exportAlias"
| "importAlias"
| "classGetter"
| "classSetter"
| "classMethod"
| "objectLiteralProperty"
| "objectLiteralGetter"
| "objectLiteralSetter"
| "objectLiteralMethod"
| "typeAlias"
| "any"
| "typeLike"
| "function"
| "namespaceLike"
| "namespace"
| "functionParameter"
| "typeParameter"
| "classMember"
| "classProperty"
| "objectLiteralMember"
| "typeMember"
| "typeGetter"
| "typeProperty"
| "typeSetter"
| "typeMethod";
type Modifiers = RestrictedModifier[];
type Scope = "any" | "global";
type NegatableImportKindMatcher = "bare" | "!bare";
type NegatablePredefinedSourceMatcher =
| ":ALIAS:"
| ":BUN:"
| ":NODE:"
| ":PACKAGE:"
| ":PACKAGE_WITH_PROTOCOL:"
| ":PATH:"
| ":STYLE:"
| ":URL:"
| "!:ALIAS:"
| "!:BUN:"
| "!:NODE:"
| "!:PACKAGE:"
| "!:PACKAGE_WITH_PROTOCOL:"
| "!:PATH:"
| "!:STYLE:"
| "!:URL:";
type ImportSourceGlob = Glob;
type RestrictedModifier =
| "abstract"
| "private"
| "protected"
| "readonly"
| "static";
interface FileFeaturesResult {
    featuresSupported: FeaturesSupported;
}
type FeaturesSupported = { [K in FeatureKind]?: SupportKind };
type SupportKind =
| "supported"
| "ignored"
| "protected"
| "featureNotEnabled"
| "fileNotSupported"
| "notRequested";
interface UpdateSettingsParams {
    configuration: Configuration;
    extendedConfigurations?: [BiomePath, Configuration][];
    moduleGraphResolutionKind?: ModuleGraphResolutionKind;
    projectKey: ProjectKey;
    workspaceDirectory?: BiomePath;
}
type ModuleGraphResolutionKind = "none" | "modules" | "modulesAndTypes";
interface UpdateSettingsResult {
    diagnostics: Diagnostic[];
}
interface Diagnostic {
    advices: Advices;
    category?: Category;
    description: string;
    location: Location;
    message: MarkupBuf;
    severity: Severity;
    source?: Diagnostic;
    tags: DiagnosticTags;
    verboseAdvices: Advices;
}
interface Advices {
    advices: Advice[];
}
type Category =
| "lint/a11y/noAccessKey"
| "lint/a11y/noAmbiguousAnchorText"
| "lint/a11y/noAriaHiddenOnFocusable"
| "lint/a11y/noAriaUnsupportedElements"
| "lint/a11y/noAutofocus"
| "lint/a11y/noDistractingElements"
| "lint/a11y/noHeaderScope"
| "lint/a11y/noInteractiveElementToNoninteractiveRole"
| "lint/a11y/noLabelWithoutControl"
| "lint/a11y/noNoninteractiveElementInteractions"
| "lint/a11y/noNoninteractiveElementToInteractiveRole"
| "lint/a11y/noNoninteractiveTabindex"
| "lint/a11y/noPositiveTabindex"
| "lint/a11y/noRedundantAlt"
| "lint/a11y/noRedundantRoles"
| "lint/a11y/noStaticElementInteractions"
| "lint/a11y/noSvgWithoutTitle"
| "lint/a11y/useAltText"
| "lint/a11y/useAnchorContent"
| "lint/a11y/useAriaActivedescendantWithTabindex"
| "lint/a11y/useAriaPropsForRole"
| "lint/a11y/useAriaPropsSupportedByRole"
| "lint/a11y/useButtonType"
| "lint/a11y/useFocusableInteractive"
| "lint/a11y/useGenericFontNames"
| "lint/a11y/useHeadingContent"
| "lint/a11y/useHtmlLang"
| "lint/a11y/useIframeTitle"
| "lint/a11y/useKeyWithClickEvents"
| "lint/a11y/useKeyWithMouseEvents"
| "lint/a11y/useMediaCaption"
| "lint/a11y/useSemanticElements"
| "lint/a11y/useValidAnchor"
| "lint/a11y/useValidAriaProps"
| "lint/a11y/useValidAriaRole"
| "lint/a11y/useValidAriaValues"
| "lint/a11y/useValidAutocomplete"
| "lint/a11y/useValidLang"
| "lint/complexity/noAdjacentSpacesInRegex"
| "lint/complexity/noArguments"
| "lint/complexity/noBannedTypes"
| "lint/complexity/noCommaOperator"
| "lint/complexity/noDivRegex"
| "lint/complexity/noEmptyTypeParameters"
| "lint/complexity/noExcessiveCognitiveComplexity"
| "lint/complexity/noExcessiveLinesPerFunction"
| "lint/complexity/noExcessiveNestedTestSuites"
| "lint/complexity/noExtraBooleanCast"
| "lint/complexity/noFlatMapIdentity"
| "lint/complexity/noForEach"
| "lint/complexity/noImplicitCoercions"
| "lint/complexity/noImportantStyles"
| "lint/complexity/noRedundantDefaultExport"
| "lint/complexity/noStaticOnlyClass"
| "lint/complexity/noThisInStatic"
| "lint/complexity/noUselessCatch"
| "lint/complexity/noUselessCatchBinding"
| "lint/complexity/noUselessConstructor"
| "lint/complexity/noUselessContinue"
| "lint/complexity/noUselessEmptyExport"
| "lint/complexity/noUselessEscapeInRegex"
| "lint/complexity/noUselessFragments"
| "lint/complexity/noUselessLabel"
| "lint/complexity/noUselessLoneBlockStatements"
| "lint/complexity/noUselessRename"
| "lint/complexity/noUselessReturn"
| "lint/complexity/noUselessStringConcat"
| "lint/complexity/noUselessStringRaw"
| "lint/complexity/noUselessSwitchCase"
| "lint/complexity/noUselessTernary"
| "lint/complexity/noUselessThisAlias"
| "lint/complexity/noUselessTypeConstraint"
| "lint/complexity/noUselessUndefined"
| "lint/complexity/noUselessUndefinedInitialization"
| "lint/complexity/noVoid"
| "lint/complexity/useArrayFind"
| "lint/complexity/useArrowFunction"
| "lint/complexity/useDateNow"
| "lint/complexity/useFlatMap"
| "lint/complexity/useIndexOf"
| "lint/complexity/useLiteralKeys"
| "lint/complexity/useMaxParams"
| "lint/complexity/useNumericLiterals"
| "lint/complexity/useOptionalChain"
| "lint/complexity/useRegexLiterals"
| "lint/complexity/useSimpleNumberKeys"
| "lint/complexity/useSimplifiedLogicExpression"
| "lint/complexity/useWhile"
| "lint/correctness/noBeforeInteractiveScriptOutsideDocument"
| "lint/correctness/noChildrenProp"
| "lint/correctness/noConstAssign"
| "lint/correctness/noConstantCondition"
| "lint/correctness/noConstantMathMinMaxClamp"
| "lint/correctness/noConstructorReturn"
| "lint/correctness/noDuplicateArgumentNames"
| "lint/correctness/noDuplicateAttributes"
| "lint/correctness/noDuplicateEnumValueNames"
| "lint/correctness/noDuplicateInputFieldNames"
| "lint/correctness/noDuplicateVariableNames"
| "lint/correctness/noEmptyCharacterClassInRegex"
| "lint/correctness/noEmptyPattern"
| "lint/correctness/noGlobalDirnameFilename"
| "lint/correctness/noGlobalObjectCalls"
| "lint/correctness/noInnerDeclarations"
| "lint/correctness/noInvalidBuiltinInstantiation"
| "lint/correctness/noInvalidConstructorSuper"
| "lint/correctness/noInvalidDirectionInLinearGradient"
| "lint/correctness/noInvalidGridAreas"
| "lint/correctness/noInvalidPositionAtImportRule"
| "lint/correctness/noInvalidUseBeforeDeclaration"
| "lint/correctness/noMissingVarFunction"
| "lint/correctness/noNestedComponentDefinitions"
| "lint/correctness/noNextAsyncClientComponent"
| "lint/correctness/noNodejsModules"
| "lint/correctness/noNonoctalDecimalEscape"
| "lint/correctness/noPrecisionLoss"
| "lint/correctness/noPrivateImports"
| "lint/correctness/noProcessGlobal"
| "lint/correctness/noQwikUseVisibleTask"
| "lint/correctness/noReactPropAssignments"
| "lint/correctness/noRenderReturnValue"
| "lint/correctness/noRestrictedElements"
| "lint/correctness/noSelfAssign"
| "lint/correctness/noSetterReturn"
| "lint/correctness/noSolidDestructuredProps"
| "lint/correctness/noStringCaseMismatch"
| "lint/correctness/noSwitchDeclarations"
| "lint/correctness/noUndeclaredDependencies"
| "lint/correctness/noUndeclaredVariables"
| "lint/correctness/noUnknownFunction"
| "lint/correctness/noUnknownMediaFeatureName"
| "lint/correctness/noUnknownProperty"
| "lint/correctness/noUnknownPseudoClass"
| "lint/correctness/noUnknownPseudoElement"
| "lint/correctness/noUnknownTypeSelector"
| "lint/correctness/noUnknownUnit"
| "lint/correctness/noUnmatchableAnbSelector"
| "lint/correctness/noUnreachable"
| "lint/correctness/noUnreachableSuper"
| "lint/correctness/noUnresolvedImports"
| "lint/correctness/noUnsafeFinally"
| "lint/correctness/noUnsafeOptionalChaining"
| "lint/correctness/noUnusedFunctionParameters"
| "lint/correctness/noUnusedImports"
| "lint/correctness/noUnusedInstantiation"
| "lint/correctness/noUnusedLabels"
| "lint/correctness/noUnusedPrivateClassMembers"
| "lint/correctness/noUnusedVariables"
| "lint/correctness/noVoidElementsWithChildren"
| "lint/correctness/noVoidTypeReturn"
| "lint/correctness/noVueDataObjectDeclaration"
| "lint/correctness/noVueDuplicateKeys"
| "lint/correctness/noVueReservedKeys"
| "lint/correctness/noVueReservedProps"
| "lint/correctness/noVueSetupPropsReactivityLoss"
| "lint/correctness/noVueVIfWithVFor"
| "lint/correctness/useExhaustiveDependencies"
| "lint/correctness/useGraphqlNamedOperations"
| "lint/correctness/useHookAtTopLevel"
| "lint/correctness/useImageSize"
| "lint/correctness/useImportExtensions"
| "lint/correctness/useInlineScriptId"
| "lint/correctness/useIsNan"
| "lint/correctness/useJsonImportAttributes"
| "lint/correctness/useJsxKeyInIterable"
| "lint/correctness/useLoneAnonymousOperation"
| "lint/correctness/useParseIntRadix"
| "lint/correctness/useQwikClasslist"
| "lint/correctness/useQwikMethodUsage"
| "lint/correctness/useQwikValidLexicalScope"
| "lint/correctness/useSingleJsDocAsterisk"
| "lint/correctness/useUniqueElementIds"
| "lint/correctness/useValidForDirection"
| "lint/correctness/useValidTypeof"
| "lint/correctness/useVueVForKey"
| "lint/correctness/useVueValidTemplateRoot"
| "lint/correctness/useVueValidVBind"
| "lint/correctness/useVueValidVCloak"
| "lint/correctness/useVueValidVElse"
| "lint/correctness/useVueValidVElseIf"
| "lint/correctness/useVueValidVHtml"
| "lint/correctness/useVueValidVIf"
| "lint/correctness/useVueValidVOn"
| "lint/correctness/useVueValidVOnce"
| "lint/correctness/useVueValidVPre"
| "lint/correctness/useVueValidVText"
| "lint/correctness/useYield"
| "lint/nursery/noBaseToString"
| "lint/nursery/noColorInvalidHex"
| "lint/nursery/noComponentHookFactories"
| "lint/nursery/noConditionalExpect"
| "lint/nursery/noDrizzleDeleteWithoutWhere"
| "lint/nursery/noDrizzleUpdateWithoutWhere"
| "lint/nursery/noDuplicateFieldDefinitionNames"
| "lint/nursery/noDuplicateSelectors"
| "lint/nursery/noEmptyObjectKeys"
| "lint/nursery/noExcessiveNestedCallbacks"
| "lint/nursery/noExcessiveSelectorClasses"
| "lint/nursery/noFloatingPromises"
| "lint/nursery/noIdenticalTestTitle"
| "lint/nursery/noImplicitCoercion"
| "lint/nursery/noImpliedEval"
| "lint/nursery/noInlineStyles"
| "lint/nursery/noJsxLeakedDollar"
| "lint/nursery/noJsxNamespace"
| "lint/nursery/noLoopFunc"
| "lint/nursery/noMisleadingReturnType"
| "lint/nursery/noMissingGenericFamilyKeyword"
| "lint/nursery/noMisusedPromises"
| "lint/nursery/noNegationInEqualityCheck"
| "lint/nursery/noPlaywrightElementHandle"
| "lint/nursery/noPlaywrightEval"
| "lint/nursery/noPlaywrightForceOption"
| "lint/nursery/noPlaywrightMissingAwait"
| "lint/nursery/noPlaywrightNetworkidle"
| "lint/nursery/noPlaywrightPagePause"
| "lint/nursery/noPlaywrightUselessAwait"
| "lint/nursery/noPlaywrightWaitForNavigation"
| "lint/nursery/noPlaywrightWaitForSelector"
| "lint/nursery/noPlaywrightWaitForTimeout"
| "lint/nursery/noReactNativeDeepImports"
| "lint/nursery/noReactNativeLiteralColors"
| "lint/nursery/noReactNativeRawText"
| "lint/nursery/noReactStringRefs"
| "lint/nursery/noRestrictedDependencies"
| "lint/nursery/noSvelteUnnecessaryStateWrap"
| "lint/nursery/noTopLevelLiterals"
| "lint/nursery/noUndeclaredClasses"
| "lint/nursery/noUnnecessaryTemplateExpression"
| "lint/nursery/noUnsafePlusOperands"
| "lint/nursery/noUntrustedLicenses"
| "lint/nursery/noUnusedClasses"
| "lint/nursery/noUnwantedPolyfillio"
| "lint/nursery/noUselessBackrefInRegex"
| "lint/nursery/noUselessTypeConversion"
| "lint/nursery/noVueImportCompilerMacros"
| "lint/nursery/noVueRefAsOperand"
| "lint/nursery/noVueVOnNumberValues"
| "lint/nursery/useArraySome"
| "lint/nursery/useAwaitThenable"
| "lint/nursery/useBaseline"
| "lint/nursery/useBiomeSuppressionComment"
| "lint/nursery/useConsistentObjectDefinition"
| "lint/nursery/useConsistentTestIt"
| "lint/nursery/useDisposables"
| "lint/nursery/useDomNodeTextContent"
| "lint/nursery/useDomQuerySelector"
| "lint/nursery/useExhaustiveSwitchCases"
| "lint/nursery/useExpect"
| "lint/nursery/useExplicitFunctionReturnType"
| "lint/nursery/useExplicitReturnType"
| "lint/nursery/useExplicitType"
| "lint/nursery/useFind"
| "lint/nursery/useGlobalThis"
| "lint/nursery/useIframeSandbox"
| "lint/nursery/useImportRestrictions"
| "lint/nursery/useImportsFirst"
| "lint/nursery/useIncludes"
| "lint/nursery/useJsxCurlyBraceConvention"
| "lint/nursery/useMathMinMax"
| "lint/nursery/useMaxParams"
| "lint/nursery/useNamedCaptureGroup"
| "lint/nursery/useNullishCoalescing"
| "lint/nursery/usePlaywrightValidDescribeCallback"
| "lint/nursery/useQwikLoaderLocation"
| "lint/nursery/useQwikMethodUsage"
| "lint/nursery/useQwikValidLexicalScope"
| "lint/nursery/useReactAsyncServerFunction"
| "lint/nursery/useReactFunctionComponentDefinition"
| "lint/nursery/useReactNativePlatformComponents"
| "lint/nursery/useReduceTypeParameter"
| "lint/nursery/useRegexpExec"
| "lint/nursery/useRegexpTest"
| "lint/nursery/useScopedStyles"
| "lint/nursery/useSortedClasses"
| "lint/nursery/useStringStartsEndsWith"
| "lint/nursery/useSvelteRequireEachKey"
| "lint/nursery/useTestHooksInOrder"
| "lint/nursery/useTestHooksOnTop"
| "lint/nursery/useThisInClassMethods"
| "lint/nursery/useUnicodeRegex"
| "lint/nursery/useUniqueArgumentNames"
| "lint/nursery/useUniqueFieldDefinitionNames"
| "lint/nursery/useUniqueGraphqlOperationName"
| "lint/nursery/useUniqueInputFieldNames"
| "lint/nursery/useUniqueVariableNames"
| "lint/nursery/useVarsOnTop"
| "lint/nursery/useVueConsistentDefinePropsDeclaration"
| "lint/nursery/useVueNextTickPromise"
| "lint/nursery/useVueValidVFor"
| "lint/nursery/useVueValidVModel"
| "lint/performance/noAccumulatingSpread"
| "lint/performance/noAwaitInLoops"
| "lint/performance/noBarrelFile"
| "lint/performance/noDelete"
| "lint/performance/noDynamicNamespaceImportAccess"
| "lint/performance/noImgElement"
| "lint/performance/noJsxPropsBind"
| "lint/performance/noNamespaceImport"
| "lint/performance/noReExportAll"
| "lint/performance/noSyncScripts"
| "lint/performance/noUnwantedPolyfillio"
| "lint/performance/useGoogleFontPreconnect"
| "lint/performance/useSolidForComponent"
| "lint/performance/useTopLevelRegex"
| "lint/performance/useVueVapor"
| "lint/security/noBlankTarget"
| "lint/security/noDangerouslySetInnerHtml"
| "lint/security/noDangerouslySetInnerHtmlWithChildren"
| "lint/security/noGlobalEval"
| "lint/security/noScriptUrl"
| "lint/security/noSecrets"
| "lint/style/noCommonJs"
| "lint/style/noContinue"
| "lint/style/noDefaultExport"
| "lint/style/noDescendingSpecificity"
| "lint/style/noDoneCallback"
| "lint/style/noEnum"
| "lint/style/noExcessiveClassesPerFile"
| "lint/style/noExcessiveLinesPerFile"
| "lint/style/noExportedImports"
| "lint/style/noHeadElement"
| "lint/style/noHexColors"
| "lint/style/noImplicitBoolean"
| "lint/style/noIncrementDecrement"
| "lint/style/noInferrableTypes"
| "lint/style/noJsxLiterals"
| "lint/style/noMagicNumbers"
| "lint/style/noMultiAssign"
| "lint/style/noMultilineString"
| "lint/style/noNamespace"
| "lint/style/noNegationElse"
| "lint/style/noNestedTernary"
| "lint/style/noNonNullAssertion"
| "lint/style/noParameterAssign"
| "lint/style/noParameterProperties"
| "lint/style/noProcessEnv"
| "lint/style/noRestrictedGlobals"
| "lint/style/noRestrictedImports"
| "lint/style/noRestrictedTypes"
| "lint/style/noRootType"
| "lint/style/noShoutyConstants"
| "lint/style/noSubstr"
| "lint/style/noTernary"
| "lint/style/noUnusedTemplateLiteral"
| "lint/style/noUselessElse"
| "lint/style/noValueAtRule"
| "lint/style/noVueOptionsApi"
| "lint/style/noYodaExpression"
| "lint/style/useArrayLiterals"
| "lint/style/useAsConstAssertion"
| "lint/style/useAtIndex"
| "lint/style/useBlockStatements"
| "lint/style/useCollapsedElseIf"
| "lint/style/useCollapsedIf"
| "lint/style/useComponentExportOnlyModules"
| "lint/style/useConsistentArrayType"
| "lint/style/useConsistentArrowReturn"
| "lint/style/useConsistentBuiltinInstantiation"
| "lint/style/useConsistentCurlyBraces"
| "lint/style/useConsistentEnumValueType"
| "lint/style/useConsistentGraphqlDescriptions"
| "lint/style/useConsistentMemberAccessibility"
| "lint/style/useConsistentMethodSignatures"
| "lint/style/useConsistentObjectDefinitions"
| "lint/style/useConsistentTypeDefinitions"
| "lint/style/useConst"
| "lint/style/useDefaultParameterLast"
| "lint/style/useDefaultSwitchClause"
| "lint/style/useDeprecatedReason"
| "lint/style/useDestructuring"
| "lint/style/useEnumInitializers"
| "lint/style/useErrorCause"
| "lint/style/useExplicitLengthCheck"
| "lint/style/useExponentiationOperator"
| "lint/style/useExportType"
| "lint/style/useExportsLast"
| "lint/style/useFilenamingConvention"
| "lint/style/useForOf"
| "lint/style/useFragmentSyntax"
| "lint/style/useGlobalThis"
| "lint/style/useGraphqlNamingConvention"
| "lint/style/useGroupedAccessorPairs"
| "lint/style/useImportType"
| "lint/style/useInputName"
| "lint/style/useLiteralEnumMembers"
| "lint/style/useLoneExecutableDefinition"
| "lint/style/useNamingConvention"
| "lint/style/useNodeAssertStrict"
| "lint/style/useNodejsImportProtocol"
| "lint/style/useNumberNamespace"
| "lint/style/useNumericSeparators"
| "lint/style/useObjectSpread"
| "lint/style/useReactFunctionComponents"
| "lint/style/useReadonlyClassProperties"
| "lint/style/useSelfClosingElements"
| "lint/style/useShorthandAssign"
| "lint/style/useShorthandFunctionType"
| "lint/style/useSingleCaseStatement"
| "lint/style/useSingleVarDeclarator"
| "lint/style/useSpreadOverApply"
| "lint/style/useSymbolDescription"
| "lint/style/useTemplate"
| "lint/style/useThrowNewError"
| "lint/style/useThrowOnlyError"
| "lint/style/useTrimStartEnd"
| "lint/style/useUnifiedTypeSignatures"
| "lint/style/useVueConsistentVBindStyle"
| "lint/style/useVueConsistentVOnStyle"
| "lint/style/useVueDefineMacrosOrder"
| "lint/style/useVueHyphenatedAttributes"
| "lint/style/useVueMultiWordComponentNames"
| "lint/suspicious/noAlert"
| "lint/suspicious/noApproximativeNumericConstant"
| "lint/suspicious/noArrayIndexKey"
| "lint/suspicious/noAssignInExpressions"
| "lint/suspicious/noAsyncPromiseExecutor"
| "lint/suspicious/noBiomeFirstException"
| "lint/suspicious/noBitwiseOperators"
| "lint/suspicious/noCatchAssign"
| "lint/suspicious/noClassAssign"
| "lint/suspicious/noCommentText"
| "lint/suspicious/noCompareNegZero"
| "lint/suspicious/noConfusingLabels"
| "lint/suspicious/noConfusingVoidType"
| "lint/suspicious/noConsole"
| "lint/suspicious/noConstEnum"
| "lint/suspicious/noConstantBinaryExpressions"
| "lint/suspicious/noControlCharactersInRegex"
| "lint/suspicious/noDebugger"
| "lint/suspicious/noDeprecatedImports"
| "lint/suspicious/noDeprecatedMediaType"
| "lint/suspicious/noDocumentCookie"
| "lint/suspicious/noDocumentImportInPage"
| "lint/suspicious/noDoubleEquals"
| "lint/suspicious/noDuplicateAtImportRules"
| "lint/suspicious/noDuplicateCase"
| "lint/suspicious/noDuplicateClassMembers"
| "lint/suspicious/noDuplicateCustomProperties"
| "lint/suspicious/noDuplicateDependencies"
| "lint/suspicious/noDuplicateElseIf"
| "lint/suspicious/noDuplicateEnumValues"
| "lint/suspicious/noDuplicateFields"
| "lint/suspicious/noDuplicateFontNames"
| "lint/suspicious/noDuplicateGraphqlOperationName"
| "lint/suspicious/noDuplicateJsxProps"
| "lint/suspicious/noDuplicateObjectKeys"
| "lint/suspicious/noDuplicateParameters"
| "lint/suspicious/noDuplicateProperties"
| "lint/suspicious/noDuplicateSelectorsKeyframeBlock"
| "lint/suspicious/noDuplicateTestHooks"
| "lint/suspicious/noDuplicatedSpreadProps"
| "lint/suspicious/noEmptyBlock"
| "lint/suspicious/noEmptyBlockStatements"
| "lint/suspicious/noEmptyInterface"
| "lint/suspicious/noEmptySource"
| "lint/suspicious/noEqualsToNull"
| "lint/suspicious/noEvolvingTypes"
| "lint/suspicious/noExplicitAny"
| "lint/suspicious/noExportsInTest"
| "lint/suspicious/noExtraNonNullAssertion"
| "lint/suspicious/noFallthroughSwitchClause"
| "lint/suspicious/noFocusedTests"
| "lint/suspicious/noForIn"
| "lint/suspicious/noFunctionAssign"
| "lint/suspicious/noGlobalAssign"
| "lint/suspicious/noGlobalIsFinite"
| "lint/suspicious/noGlobalIsNan"
| "lint/suspicious/noHeadImportInDocument"
| "lint/suspicious/noImplicitAnyLet"
| "lint/suspicious/noImportAssign"
| "lint/suspicious/noImportCycles"
| "lint/suspicious/noImportantInKeyframe"
| "lint/suspicious/noIrregularWhitespace"
| "lint/suspicious/noLabelVar"
| "lint/suspicious/noLeakedRender"
| "lint/suspicious/noMisleadingCharacterClass"
| "lint/suspicious/noMisleadingInstantiator"
| "lint/suspicious/noMisplacedAssertion"
| "lint/suspicious/noMisrefactoredShorthandAssign"
| "lint/suspicious/noNestedPromises"
| "lint/suspicious/noNonNullAssertedOptionalChain"
| "lint/suspicious/noOctalEscape"
| "lint/suspicious/noParametersOnlyUsedInRecursion"
| "lint/suspicious/noProto"
| "lint/suspicious/noPrototypeBuiltins"
| "lint/suspicious/noQuickfixBiome"
| "lint/suspicious/noReactForwardRef"
| "lint/suspicious/noReactSpecificProps"
| "lint/suspicious/noRedeclare"
| "lint/suspicious/noRedundantUseStrict"
| "lint/suspicious/noReturnAssign"
| "lint/suspicious/noSelfCompare"
| "lint/suspicious/noShadow"
| "lint/suspicious/noShadowRestrictedNames"
| "lint/suspicious/noShorthandPropertyOverrides"
| "lint/suspicious/noSkippedTests"
| "lint/suspicious/noSparseArray"
| "lint/suspicious/noSuspiciousSemicolonInJsx"
| "lint/suspicious/noTemplateCurlyInString"
| "lint/suspicious/noThenProperty"
| "lint/suspicious/noTsIgnore"
| "lint/suspicious/noUnassignedVariables"
| "lint/suspicious/noUndeclaredEnvVars"
| "lint/suspicious/noUnknownAtRules"
| "lint/suspicious/noUnknownAttribute"
| "lint/suspicious/noUnnecessaryConditions"
| "lint/suspicious/noUnsafeDeclarationMerging"
| "lint/suspicious/noUnsafeNegation"
| "lint/suspicious/noUnusedExpressions"
| "lint/suspicious/noUselessEscapeInString"
| "lint/suspicious/noUselessRegexBackrefs"
| "lint/suspicious/noVar"
| "lint/suspicious/noVueArrowFuncInWatch"
| "lint/suspicious/noWith"
| "lint/suspicious/useAdjacentOverloadSignatures"
| "lint/suspicious/useArraySortCompare"
| "lint/suspicious/useAwait"
| "lint/suspicious/useBiomeIgnoreFolder"
| "lint/suspicious/useDefaultSwitchClauseLast"
| "lint/suspicious/useDeprecatedDate"
| "lint/suspicious/useErrorMessage"
| "lint/suspicious/useGetterReturn"
| "lint/suspicious/useGoogleFontDisplay"
| "lint/suspicious/useGuardForIn"
| "lint/suspicious/useIsArray"
| "lint/suspicious/useIterableCallbackReturn"
| "lint/suspicious/useNamespaceKeyword"
| "lint/suspicious/useNumberToFixedDigitsArgument"
| "lint/suspicious/useRequiredScripts"
| "lint/suspicious/useStaticResponseMethods"
| "lint/suspicious/useStrictMode"
| "assist/source/noDuplicateClasses"
| "assist/source/organizeImports"
| "assist/source/useSortedAttributes"
| "assist/source/useSortedEnumMembers"
| "assist/source/useSortedInterfaceMembers"
| "assist/source/useSortedKeys"
| "assist/source/useSortedPackageJson"
| "assist/source/useSortedProperties"
| "assist/source/useSortedSelectionSet"
| "assist/source/useSortedTypeFields"
| "syntax/correctness/noTypeOnlyImportAttributes"
| "syntax/correctness/noSuperWithoutExtends"
| "syntax/correctness/noInitializerWithDefinite"
| "syntax/correctness/noDuplicatePrivateClassMembers"
| "files/missingHandler"
| "format"
| "check"
| "ci"
| "stdin"
| "init"
| "configuration"
| "assist"
| "migrate"
| "upgrade"
| "deserialize"
| "plugin"
| "project"
| "search"
| "internalError/io"
| "internalError/fs"
| "internalError/panic"
| "internalError/db"
| "reporter/parse"
| "reporter/format"
| "reporter/violations"
| "parse"
| "lint"
| "lint/a11y"
| "lint/complexity"
| "lint/correctness"
| "lint/nursery"
| "lint/performance"
| "lint/security"
| "lint/style"
| "lint/suspicious"
| "lint/plugin"
| "suppressions/parse"
| "suppressions/unknownGroup"
| "suppressions/unknownRule"
| "suppressions/unknownAction"
| "suppressions/unused"
| "suppressions/incorrect"
| "args/fileNotFound"
| "flags/invalid"
| "semanticTests";
interface Location {
    path?: Resource;
    sourceCode?: string;
    span?: TextRange;
}
type MarkupBuf = MarkupNodeBuf[];
type Severity = "hint" | "information" | "warning" | "error" | "fatal";
type DiagnosticTags = DiagnosticTag[];
type Advice =
| { log: [LogCategory, MarkupBuf] }
| { list: MarkupBuf[] }
| { frame: Location }
| { diff: TextEdit }
| { codeSuggestion: [Location, TextEdit] }
| { backtrace: [MarkupBuf, Backtrace] }
| { command: string }
| { group: [MarkupBuf, Advices] };
type Resource = "argv" | "memory" | { file: string };
type TextRange = [TextSize, TextSize];
interface MarkupNodeBuf {
    content: string;
    elements: MarkupElement[];
}
type DiagnosticTag =
| "fixable"
| "internal"
| "unnecessaryCode"
| "deprecatedCode"
| "verbose";
type LogCategory = "none" | "info" | "warn" | "error";
interface TextEdit {
    dictionary: string;
    ops: CompressedOp[];
}
type Backtrace = BacktraceFrame[];
type TextSize = number;
type MarkupElement =
| "Emphasis"
| "Dim"
| "Italic"
| "Underline"
| "Error"
| "Success"
| "Warn"
| "Info"
| "Debug"
| "Trace"
| "Inverse"
| { Hyperlink: { href: string } };
type CompressedOp = { diffOp: DiffOp } | { equalLines: { line_count: number } };
interface BacktraceFrame {
    ip: number;
    symbols: BacktraceSymbol[];
}
type DiffOp =
| { equal: { range: TextRange } }
| { insert: { range: TextRange } }
| { delete: { range: TextRange } };
interface BacktraceSymbol {
    colno?: number;
    filename?: string;
    lineno?: number;
    name?: string;
}
interface OpenProjectParams {
    /**
     * Whether the folder should be opened as a project, even if no
    `biome.json` can be found.
     */
    openUninitialized: boolean;
    /**
     * The path to open
     */
    path: BiomePath;
}
interface OpenProjectResult {
    /**
     * A unique identifier for this project
     */
    projectKey: ProjectKey;
}
interface ScanProjectParams {
    /**
     * Forces scanning of the folder, even if it is already being watched.
     */
    force: boolean;
    projectKey: ProjectKey;
    scanKind: ScanKind;
    verbose?: boolean;
    /**
     * Whether the watcher should watch this path.

    Does nothing if the watcher is already watching this path.
     */
    watch: boolean;
}
type ScanKind =
| "noScanner"
| "knownFiles"
| {
    targetedKnownFiles: {
        /**
         * Determines whether the file scanner should descend into
        subdirectories of the target paths.
         */
        descendFromTargets: boolean;
        /**
         * The paths to target by the scanner.

        If a target path indicates a folder, all files within are scanned as well.

        Target paths must be absolute.
         */
        targetPaths: BiomePath[];
    };
}
| "project"
| "typeAware";
interface ScanProjectResult {
    /**
     * A list of child configuration files found inside the project
     */
    configurationFiles: BiomePath[];
    /**
     * Diagnostics reported while scanning the project.
     */
    diagnostics: Diagnostic[];
    /**
     * Duration of the scan.
     */
    duration: Duration;
}
interface Duration {
    nanos: number;
    secs: number;
}
interface OpenFileParams {
    content: FileContent;
    documentFileSource?: DocumentFileSource;
    /**
     * Used to enable further document services e.g. semantic model
     */
    editorFeatures?: EditorFeatures;
    inlineConfig?: Configuration;
    path: BiomePath;
    /**
     * Set to `true` to persist the node cache used during parsing, in order to
    speed up subsequent reparsing if the document has been edited.

    This should only be enabled if reparsing is to be expected, such as when
    the file is opened through the LSP Proxy.
     */
    persistNodeCache?: boolean;
    projectKey: ProjectKey;
}
type FileContent =
| { content: string; type: "fromClient"; version: number }
| { type: "fromServer" };
type DocumentFileSource =
| "Ignore"
| "Unknown"
| { Js: JsFileSource }
| { Json: JsonFileSource }
| { Css: CssFileSource }
| { Graphql: GraphqlFileSource }
| { Html: HtmlFileSource }
| { Grit: GritFileSource };
type EditorFeatures = EditorFeature[];
interface JsFileSource {
    /**
     * Used to mark if the JavaScript is embedded inside some particular files. This affects the parsing.
    For example, if inside an Astro file, a top-level return statement is allowed.
     */
    embedding_kind: JsEmbeddingKind;
    language: Language;
    module_kind: ModuleKind;
    variant: LanguageVariant;
    version: LanguageVersion;
}
interface JsonFileSource {
    allowComments: boolean;
    allowTrailingCommas: boolean;
    variant: JsonFileVariant;
}
interface CssFileSource {
    /**
     * Used to mark if the CSS is embedded inside some particular files. This affects the parsing.
    For example, if inside a styled`` literal, a top-level declaration is allowed.
     */
    embeddingKind: CssEmbeddingKind;
    language: CssFileLanguage;
    variant: CssVariant;
}
interface GraphqlFileSource {
    variant: GraphqlVariant;
}
interface HtmlFileSource {
    variant: HtmlVariant;
}
interface GritFileSource {
    variant: GritVariant;
}
type EditorFeature = "gotoDefinition";
type JsEmbeddingKind =
| "None"
| {
    Astro: {
        /**
         * Whether the script is inside Astro frontmatter
         */
        frontmatter: boolean;
        /**
         * Whether this snippet is from a class-related attribute
        (e.g., `class:list={...}` or `class={...}`)
         */
        is_class_attribute: boolean;
    };
}
| {
    Vue: {
        /**
         * Whether this embed should be parsed as statements (module/script).
        When `false`, the content is parsed as an expression via `parse_template_expression`.
        Source-level embeds (`<script>`) use `true`; directives and text expressions use `false`.
         */
        allow_statements: boolean;
        /**
         * Whether this is a v-on event handler (e.g., @click="handler")
         */
        event_handler: boolean;
        /**
         * Where the bindings are defined
         */
        is_source: boolean;
        /**
         * Whether the script is inside script tag with setup attribute
         */
        setup: boolean;
    };
}
| {
    Svelte: {
        /**
         * Whether this is a `{@const name = value}` block.
         */
        is_const_block: boolean;
        /**
         * Whether this is the declaration of a function, usually declared in `#snippet`
         */
        is_function_signature: boolean;
        /**
         * Where the bindings are defined
         */
        is_source: boolean;
        /**
         * `kind` models whether the Svelte file is a component document or a
        source module. That distinction controls whether downstream code
        extracts `<script>` content or treats the file as a standalone JS/TS
        module, while `is_source` still tracks where bindings come from.
         */
        kind: SvelteFileKind;
    };
};
type Language = "javaScript" | { typeScript: { definition_file: boolean } };
type ModuleKind = "script" | "module";
type LanguageVariant = "standard" | "standardRestricted" | "jsx";
type LanguageVersion = "eS2022" | "eSNext";
type JsonFileVariant = "standard" | "jsonc";
type CssEmbeddingKind = "None" | "Styled" | { Html: EmbeddingHtmlKind };
type CssFileLanguage = "css" | "scss";
type CssVariant = "standard" | "cssModules" | "tailwindCss";
type GraphqlVariant = "standard";
type HtmlVariant =
| { Standard: HtmlTextExpressions }
| "Astro"
| "Vue"
| "Svelte"
| "Angular";
type GritVariant = "Standard";
type SvelteFileKind = "Component" | "SourceModule";
type EmbeddingHtmlKind =
| "None"
| "Html"
| { Vue: { applicability: EmbeddingStyleApplicability } }
| { Astro: { applicability: EmbeddingStyleApplicability } }
| { Svelte: { applicability: EmbeddingStyleApplicability } };
type HtmlTextExpressions = "None" | "Single" | "Double";
type EmbeddingStyleApplicability = "Local" | "Global" | "Unknown";
interface OpenFileResult {
    diagnostics: Diagnostic[];
}
interface ChangeFileParams {
    content: string;
    /**
     * Used to enable further document services e.g. semantic model
     */
    editorFeatures?: EditorFeatures;
    inlineConfig?: Configuration;
    path: BiomePath;
    projectKey: ProjectKey;
    version: number;
}
interface ChangeFileResult {
    /**
     * Problems found while updating dependency and module data.
    This does not include lint or parse results for the changed file.
     */
    diagnostics: Diagnostic[];
}
interface CloseFileParams {
    path: BiomePath;
    projectKey: ProjectKey;
}
interface FileExistsParams {
    filePath: BiomePath;
}
interface PathIsIgnoredParams {
    /**
     * Whether the path is ignored for specific features e.g. `formatter.includes`.
    When this field is empty, Biome checks only `files.includes`.
     */
    features: FeatureName;
    /**
     * Controls how to ignore check should be done
     */
    ignoreKind?: IgnoreKind;
    /**
     * Whether the path is a directory. Used to skip stat calls when the caller
    already knows the file type from the filesystem traversal.
     */
    isDir?: boolean;
    /**
     * The path to inspect
     */
    path: BiomePath;
    projectKey: ProjectKey;
}
type IgnoreKind = "path" | "ancestors";
interface UpdateModuleGraphParams {
    path: BiomePath;
    projectKey: ProjectKey;
    /**
     * The kind of update to apply to the module graph
     */
    updateKind: UpdateKind;
}
type UpdateKind = "addOrUpdate" | "remove";
interface GetSyntaxTreeParams {
    path: BiomePath;
    projectKey: ProjectKey;
}
interface GetSyntaxTreeResult {
    ast: string;
    cst: string;
}
interface CheckFileSizeParams {
    path: BiomePath;
    projectKey: ProjectKey;
}
interface CheckFileSizeResult {
    fileSize: number;
    limit: number;
}
interface GetFileContentParams {
    path: BiomePath;
    projectKey: ProjectKey;
}
interface GetControlFlowGraphParams {
    cursor: TextSize;
    path: BiomePath;
    projectKey: ProjectKey;
}
interface GetFormatterIRParams {
    path: BiomePath;
    projectKey: ProjectKey;
}
interface GetTypeInfoParams {
    path: BiomePath;
    projectKey: ProjectKey;
}
interface GetRegisteredTypesParams {
    path: BiomePath;
    projectKey: ProjectKey;
}
interface GetSemanticModelParams {
    path: BiomePath;
    projectKey: ProjectKey;
}
type GetModuleGraphParams = {};
interface GetModuleGraphResult {
    data: Record<string, SerializedModuleInfo>;
}
type SerializedModuleInfo =
| { js: SerializedJsModuleInfo }
| { css: SerializedCssModuleInfo }
| { html: SerializedHtmlModuleInfo };
interface SerializedJsModuleInfo {
    /**
     * Dynamic imports.
     */
    dynamicImports: string[];
    /**
     * Exported symbols.
     */
    exports: string[];
    /**
     * CSS class names referenced in JSX `className` or `class` attributes.
     */
    referencedClasses: string[];
    /**
     * Map of all the paths from static imports in the module.

    Maps from the source specifier name to the absolute path it resolves to.
    Specifiers that could not be resolved to an absolute will map to the
    specifier itself.

    ## Example

    ```json
    {
        "./foo": "/absolute/path/to/foo.js",
        "react": "react"
    }
    ```
     */
    staticImportPaths: Record<string, string>;
    /**
     * Map of all static imports found in the module.

    Maps from the local imported name to the absolute path it resolves to.
     */
    staticImports: Record<string, string>;
}
interface SerializedCssModuleInfo {
    /**
     * Set of all CSS class names defined in this file.
     */
    classes: string[];
    /**
     * Map of all static imports found in the module.

    Maps from the local imported name to the absolute path it resolves to.
     */
    imports: string[];
}
interface SerializedHtmlModuleInfo {
    /**
     * CSS class names referenced in `class` attributes.
     */
    referencedClasses: string[];
    /**
     * CSS class names defined in `<style>` blocks.
     */
    styleClasses: string[];
}
interface PullDiagnosticsParams {
    categories: RuleCategories;
    /**
     * Minimum severity for a diagnostic to be included. Diagnostics with a
    severity below this threshold are ignored entirely (not counted, not
    serialized). Defaults to [`Severity::Hint`] (include everything).
     */
    diagnosticLevel?: Severity;
    /**
     * Rules to apply on top of the configuration
     */
    enabledRules?: AnalyzerSelector[];
    /**
     * When true, promote assist diagnostics (`assist/*`) to error severity
    before applying the diagnostic_level filter.
     */
    enforceAssist?: boolean;
    /**
     * When `true`, diagnostics include code suggestions for rule fixes.
     */
    includeCodeFix?: boolean;
    inlineConfig?: Configuration;
    /**
     * Max limit of diagnostics types to pull. This limit is meant to cap the number of [Diagnostic] to pull.
    However, the workspace still processes ALL diagnostics coming from the analyzer to compute their severity.
    If no value is provided, the workspace will pull all diagnostics.
     */
    maxDiagnostics?: number;
    only?: AnalyzerSelector[];
    path: BiomePath;
    projectKey: ProjectKey;
    skip?: AnalyzerSelector[];
}
type RuleCategories = RuleCategory[];
type AnalyzerSelector = string;
type RuleCategory = "syntax" | "lint" | "action" | "transformation";
interface PullDiagnosticsResult {
    diagnostics: Diagnostic[];
    errors: number;
    infos: number;
    /**
     * Number of parse errors (subset of `errors`). Used by `--skip-parse-errors`
    to distinguish parse errors from analyzer errors.
     */
    parseErrors: number;
    skippedDiagnostics: number;
    warnings: number;
}
interface ProcessFileParams {
    categories: RuleCategories;
    content: FileContent;
    diagnosticLevel: Severity;
    enabledRules?: AnalyzerSelector[];
    enforceAssist: boolean;
    fixFileMode?: FixFileMode;
    format: boolean;
    includeCodeFix: boolean;
    maxDiagnostics?: number;
    only?: AnalyzerSelector[];
    path: BiomePath;
    projectKey: ProjectKey;
    skip?: AnalyzerSelector[];
    skipParseErrors: boolean;
    suppressionReason?: string;
    write: boolean;
}
type FixFileMode = "safeFixes" | "safeAndUnsafeFixes" | "applySuppressions";
interface ProcessFileResult {
    appliedFixes: number;
    diagnostics: Diagnostic[];
    errors: number;
    formatWithErrorsDisabled: boolean;
    infos: number;
    output?: string;
    parseErrors: number;
    skippedDiagnostics: number;
    skippedSuggestedFixes: number;
    warnings: number;
}
interface PullActionsParams {
    categories?: RuleCategories;
    /**
     * When `false`, returned actions have `suggestion: None` (no `BatchMutation`
    computed). Used by `codeAction/resolve` to defer edit computation.
     */
    computeActions?: boolean;
    enabledRules?: AnalyzerSelector[];
    inlineConfig?: Configuration;
    only?: AnalyzerSelector[];
    path: BiomePath;
    projectKey: ProjectKey;
    range?: TextRange;
    skip?: AnalyzerSelector[];
    suppressionReason?: string;
}
interface PullActionsResult {
    actions: CodeAction[];
}
interface CodeAction {
    applicability?: Applicability;
    category: ActionCategory;
    offset?: TextSize;
    ruleName?: [string, string];
    /**
     * The computed code suggestion with text edit. `None` when the action was
    returned without computing edits (deferred for `codeAction/resolve`).
     */
    suggestion?: CodeSuggestion;
}
type Applicability = "always" | "maybeIncorrect";
type ActionCategory =
| { quickFix: string }
| { refactor: RefactorKind }
| { source: SourceActionKind }
| { other: OtherActionCategory };
interface CodeSuggestion {
    applicability: Applicability;
    labels: TextRange[];
    msg: MarkupBuf;
    span: TextRange;
    suggestion: TextEdit;
}
type RefactorKind =
| "none"
| "extract"
| "inline"
| "rewrite"
| { other: string };
type SourceActionKind =
| "fixAll"
| "none"
| "organizeImports"
| { other: string };
type OtherActionCategory =
| "inlineSuppression"
| "toplevelSuppression"
| { generic: string };
interface PullDiagnosticsAndActionsParams {
    categories?: RuleCategories;
    enabledRules?: AnalyzerSelector[];
    inlineConfig?: Configuration;
    only?: AnalyzerSelector[];
    path: BiomePath;
    projectKey: ProjectKey;
    skip?: AnalyzerSelector[];
}
interface PullDiagnosticsAndActionsResult {
    diagnostics: [Diagnostic, CodeAction[]][];
}
interface FormatFileParams {
    inlineConfig?: Configuration;
    path: BiomePath;
    projectKey: ProjectKey;
}
interface Printed {
    code: string;
    range?: TextRange;
    sourcemap: SourceMarker[];
    verbatimRanges: TextRange[];
}
interface SourceMarker {
    /**
     * Position of the marker in the output code
     */
    dest: TextSize;
    /**
     * Position of the marker in the original source
     */
    source: TextSize;
}
interface FormatRangeParams {
    inlineConfig?: Configuration;
    path: BiomePath;
    projectKey: ProjectKey;
    range: TextRange;
}
interface FormatOnTypeParams {
    inlineConfig?: Configuration;
    offset: TextSize;
    path: BiomePath;
    projectKey: ProjectKey;
}
interface FixFileParams {
    /**
     * Rules to apply to the file
     */
    enabledRules?: AnalyzerSelector[];
    fixFileMode: FixFileMode;
    inlineConfig?: Configuration;
    only?: AnalyzerSelector[];
    path: BiomePath;
    projectKey: ProjectKey;
    ruleCategories: RuleCategories;
    shouldFormat: boolean;
    skip?: AnalyzerSelector[];
    suppressionReason?: string;
}
interface FixFileResult {
    /**
     * List of all the code actions applied to the file
     */
    actions: FixAction[];
    /**
     * New source code for the file with all fixes applied
     */
    code: string;
    /**
     * Number of errors
     */
    errors: number;
    /**
     * number of skipped suggested fixes
     */
    skippedSuggestedFixes: number;
}
interface FixAction {
    /**
     * Source range at which this action was applied
     */
    range: TextRange;
    /**
     * Name of the rule group and rule that emitted this code action
     */
    rule_name?: [string, string];
}
interface RenameParams {
    newName: string;
    path: BiomePath;
    projectKey: ProjectKey;
    symbolAt: TextSize;
}
interface RenameResult {
    /**
     * List of text edit operations to apply on the source code
     */
    indels: TextEdit;
    /**
     * Range of source code modified by this rename operation
     */
    range: TextRange;
}
interface ParsePatternParams {
    defaultLanguage: SearchLanguage;
    pattern: string;
}
type SearchLanguage = "css" | "js" | "json";
interface ParsePatternResult {
    patternId: PatternId;
}
type PatternId = string;
interface SearchPatternParams {
    path: BiomePath;
    pattern: PatternId;
    projectKey: ProjectKey;
}
interface SearchResults {
    matches: TextRange[];
    path: BiomePath;
}
interface DropPatternParams {
    pattern: PatternId;
}



export class DiagnosticPrinter {
    free(): void;
    [Symbol.dispose](): void;
    finish(): string;
    constructor(file_name: string, file_source: string);
    print_simple(diagnostic: Diagnostic): void;
    print_verbose(diagnostic: Diagnostic): void;
}

export class MemoryFileSystem {
    free(): void;
    [Symbol.dispose](): void;
    insert(path: string, data: Uint8Array): void;
    constructor();
    remove(path: string): void;
}

export class Workspace {
    free(): void;
    [Symbol.dispose](): void;
    changeFile(params: ChangeFileParams): ChangeFileResult;
    closeFile(params: CloseFileParams): void;
    dropPattern(params: DropPatternParams): void;
    fileExists(params: FileExistsParams): boolean;
    fileFeatures(params: SupportsFeatureParams): FileFeaturesResult;
    fixFile(params: FixFileParams): FixFileResult;
    formatFile(params: FormatFileParams): any;
    formatOnType(params: FormatOnTypeParams): any;
    formatRange(params: FormatRangeParams): any;
    getControlFlowGraph(params: GetControlFlowGraphParams): string;
    getFileContent(params: GetFileContentParams): string;
    getFormatterIr(params: GetFormatterIRParams): string;
    getModuleGraph(params: GetModuleGraphParams): GetModuleGraphResult;
    getRegisteredTypes(params: GetRegisteredTypesParams): string;
    getSemanticModel(params: GetSemanticModelParams): string;
    getSyntaxTree(params: GetSyntaxTreeParams): GetSyntaxTreeResult;
    getTypeInfo(params: GetTypeInfoParams): string;
    isPathIgnored(params: PathIsIgnoredParams): boolean;
    constructor();
    openFile(params: OpenFileParams): OpenFileResult;
    openProject(params: OpenProjectParams): OpenProjectResult;
    parsePattern(params: ParsePatternParams): ParsePatternResult;
    pullActions(params: PullActionsParams): PullActionsResult;
    pullDiagnostics(params: PullDiagnosticsParams): PullDiagnosticsResult;
    rename(params: RenameParams): RenameResult;
    scanProject(params: ScanProjectParams): ScanProjectResult;
    searchPattern(params: SearchPatternParams): SearchResults;
    updateModuleGraph(params: UpdateModuleGraphParams): void;
    updateSettings(params: UpdateSettingsParams): UpdateSettingsResult;
    static withFileSystem(fs: MemoryFileSystem): Workspace;
}

export function main(): void;