@kazupon/eslint-config 0.26.1 → 0.28.0

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { FlatConfigComposer } from 'eslint-flat-config-utils';
 import { Awaitable } from '@kazupon/jts-utils/types';
 import { Linter, ESLint } from 'eslint';
+import { StylisticCustomizeOptions } from '@stylistic/eslint-plugin';
 
 /**
  * define eslint configurations
@@ -109,8 +110,9 @@ interface CssRules {
     'css/prefer-logical-properties'?: Linter.RuleEntry<CssPreferLogicalProperties>;
     /**
      * Enforce the use of baseline features
+     * @see https://github.com/eslint/css/blob/main/docs/rules/use-baseline.md
      */
-    'css/require-baseline'?: Linter.RuleEntry<CssRequireBaseline>;
+    'css/use-baseline'?: Linter.RuleEntry<CssUseBaseline>;
     /**
      * Require use of layers
      * @see https://github.com/eslint/css/blob/main/docs/rules/use-layers.md
@@ -123,7 +125,7 @@ type CssPreferLogicalProperties = [] | [
         allowUnits?: string[];
     }
 ];
-type CssRequireBaseline = [] | [
+type CssUseBaseline = [] | [
     {
         available?: (("widely" | "newly") | number);
     }
@@ -6948,6 +6950,1726 @@ type RegexpUnicodeProperty = [] | [
     }
 ];
 
+interface StylisticRules {
+    /**
+     * Enforce linebreaks after opening and before closing array brackets
+     * @see https://eslint.style/rules/js/array-bracket-newline
+     */
+    '@stylistic/array-bracket-newline'?: Linter.RuleEntry<StylisticArrayBracketNewline>;
+    /**
+     * Enforce consistent spacing inside array brackets
+     * @see https://eslint.style/rules/js/array-bracket-spacing
+     */
+    '@stylistic/array-bracket-spacing'?: Linter.RuleEntry<StylisticArrayBracketSpacing>;
+    /**
+     * Enforce line breaks after each array element
+     * @see https://eslint.style/rules/js/array-element-newline
+     */
+    '@stylistic/array-element-newline'?: Linter.RuleEntry<StylisticArrayElementNewline>;
+    /**
+     * Require parentheses around arrow function arguments
+     * @see https://eslint.style/rules/js/arrow-parens
+     */
+    '@stylistic/arrow-parens'?: Linter.RuleEntry<StylisticArrowParens>;
+    /**
+     * Enforce consistent spacing before and after the arrow in arrow functions
+     * @see https://eslint.style/rules/js/arrow-spacing
+     */
+    '@stylistic/arrow-spacing'?: Linter.RuleEntry<StylisticArrowSpacing>;
+    /**
+     * Disallow or enforce spaces inside of blocks after opening block and before closing block
+     * @see https://eslint.style/rules/ts/block-spacing
+     */
+    '@stylistic/block-spacing'?: Linter.RuleEntry<StylisticBlockSpacing>;
+    /**
+     * Enforce consistent brace style for blocks
+     * @see https://eslint.style/rules/ts/brace-style
+     */
+    '@stylistic/brace-style'?: Linter.RuleEntry<StylisticBraceStyle>;
+    /**
+     * Require or disallow trailing commas
+     * @see https://eslint.style/rules/ts/comma-dangle
+     */
+    '@stylistic/comma-dangle'?: Linter.RuleEntry<StylisticCommaDangle>;
+    /**
+     * Enforce consistent spacing before and after commas
+     * @see https://eslint.style/rules/ts/comma-spacing
+     */
+    '@stylistic/comma-spacing'?: Linter.RuleEntry<StylisticCommaSpacing>;
+    /**
+     * Enforce consistent comma style
+     * @see https://eslint.style/rules/js/comma-style
+     */
+    '@stylistic/comma-style'?: Linter.RuleEntry<StylisticCommaStyle>;
+    /**
+     * Enforce consistent spacing inside computed property brackets
+     * @see https://eslint.style/rules/js/computed-property-spacing
+     */
+    '@stylistic/computed-property-spacing'?: Linter.RuleEntry<StylisticComputedPropertySpacing>;
+    /**
+     * Enforce consistent line breaks after opening and before closing braces
+     * @see https://eslint.style/rules/plus/curly-newline
+     */
+    '@stylistic/curly-newline'?: Linter.RuleEntry<StylisticCurlyNewline>;
+    /**
+     * Enforce consistent newlines before and after dots
+     * @see https://eslint.style/rules/js/dot-location
+     */
+    '@stylistic/dot-location'?: Linter.RuleEntry<StylisticDotLocation>;
+    /**
+     * Require or disallow newline at the end of files
+     * @see https://eslint.style/rules/js/eol-last
+     */
+    '@stylistic/eol-last'?: Linter.RuleEntry<StylisticEolLast>;
+    /**
+     * Require or disallow spacing between function identifiers and their invocations
+     * @see https://eslint.style/rules/ts/function-call-spacing
+     */
+    '@stylistic/func-call-spacing'?: Linter.RuleEntry<StylisticFuncCallSpacing>;
+    /**
+     * Enforce line breaks between arguments of a function call
+     * @see https://eslint.style/rules/js/function-call-argument-newline
+     */
+    '@stylistic/function-call-argument-newline'?: Linter.RuleEntry<StylisticFunctionCallArgumentNewline>;
+    /**
+     * Require or disallow spacing between function identifiers and their invocations
+     * @see https://eslint.style/rules/ts/function-call-spacing
+     */
+    '@stylistic/function-call-spacing'?: Linter.RuleEntry<StylisticFunctionCallSpacing>;
+    /**
+     * Enforce consistent line breaks inside function parentheses
+     * @see https://eslint.style/rules/js/function-paren-newline
+     */
+    '@stylistic/function-paren-newline'?: Linter.RuleEntry<StylisticFunctionParenNewline>;
+    /**
+     * Enforce consistent spacing around `*` operators in generator functions
+     * @see https://eslint.style/rules/js/generator-star-spacing
+     */
+    '@stylistic/generator-star-spacing'?: Linter.RuleEntry<StylisticGeneratorStarSpacing>;
+    /**
+     * Enforce the location of arrow function bodies
+     * @see https://eslint.style/rules/js/implicit-arrow-linebreak
+     */
+    '@stylistic/implicit-arrow-linebreak'?: Linter.RuleEntry<StylisticImplicitArrowLinebreak>;
+    /**
+     * Enforce consistent indentation
+     * @see https://eslint.style/rules/ts/indent
+     */
+    '@stylistic/indent'?: Linter.RuleEntry<StylisticIndent>;
+    /**
+     * Indentation for binary operators
+     * @see https://eslint.style/rules/plus/indent-binary-ops
+     */
+    '@stylistic/indent-binary-ops'?: Linter.RuleEntry<StylisticIndentBinaryOps>;
+    /**
+     * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
+     * @see https://eslint.style/rules/jsx/jsx-child-element-spacing
+     */
+    '@stylistic/jsx-child-element-spacing'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce closing bracket location in JSX
+     * @see https://eslint.style/rules/jsx/jsx-closing-bracket-location
+     */
+    '@stylistic/jsx-closing-bracket-location'?: Linter.RuleEntry<StylisticJsxClosingBracketLocation>;
+    /**
+     * Enforce closing tag location for multiline JSX
+     * @see https://eslint.style/rules/jsx/jsx-closing-tag-location
+     */
+    '@stylistic/jsx-closing-tag-location'?: Linter.RuleEntry<StylisticJsxClosingTagLocation>;
+    /**
+     * Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
+     * @see https://eslint.style/rules/jsx/jsx-curly-brace-presence
+     */
+    '@stylistic/jsx-curly-brace-presence'?: Linter.RuleEntry<StylisticJsxCurlyBracePresence>;
+    /**
+     * Enforce consistent linebreaks in curly braces in JSX attributes and expressions
+     * @see https://eslint.style/rules/jsx/jsx-curly-newline
+     */
+    '@stylistic/jsx-curly-newline'?: Linter.RuleEntry<StylisticJsxCurlyNewline>;
+    /**
+     * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
+     * @see https://eslint.style/rules/jsx/jsx-curly-spacing
+     */
+    '@stylistic/jsx-curly-spacing'?: Linter.RuleEntry<StylisticJsxCurlySpacing>;
+    /**
+     * Enforce or disallow spaces around equal signs in JSX attributes
+     * @see https://eslint.style/rules/jsx/jsx-equals-spacing
+     */
+    '@stylistic/jsx-equals-spacing'?: Linter.RuleEntry<StylisticJsxEqualsSpacing>;
+    /**
+     * Enforce proper position of the first property in JSX
+     * @see https://eslint.style/rules/jsx/jsx-first-prop-new-line
+     */
+    '@stylistic/jsx-first-prop-new-line'?: Linter.RuleEntry<StylisticJsxFirstPropNewLine>;
+    /**
+     * Enforce line breaks before and after JSX elements when they are used as arguments to a function.
+     * @see https://eslint.style/rules/jsx/jsx-function-call-newline
+     */
+    '@stylistic/jsx-function-call-newline'?: Linter.RuleEntry<StylisticJsxFunctionCallNewline>;
+    /**
+     * Enforce JSX indentation. Deprecated, use `indent` rule instead.
+     * @see https://eslint.style/rules/jsx/jsx-indent
+     * @deprecated
+     */
+    '@stylistic/jsx-indent'?: Linter.RuleEntry<StylisticJsxIndent>;
+    /**
+     * Enforce props indentation in JSX
+     * @see https://eslint.style/rules/jsx/jsx-indent-props
+     */
+    '@stylistic/jsx-indent-props'?: Linter.RuleEntry<StylisticJsxIndentProps>;
+    /**
+     * Enforce maximum of props on a single line in JSX
+     * @see https://eslint.style/rules/jsx/jsx-max-props-per-line
+     */
+    '@stylistic/jsx-max-props-per-line'?: Linter.RuleEntry<StylisticJsxMaxPropsPerLine>;
+    /**
+     * Require or prevent a new line after jsx elements and expressions.
+     * @see https://eslint.style/rules/jsx/jsx-newline
+     */
+    '@stylistic/jsx-newline'?: Linter.RuleEntry<StylisticJsxNewline>;
+    /**
+     * Require one JSX element per line
+     * @see https://eslint.style/rules/jsx/jsx-one-expression-per-line
+     */
+    '@stylistic/jsx-one-expression-per-line'?: Linter.RuleEntry<StylisticJsxOneExpressionPerLine>;
+    /**
+     * Enforce PascalCase for user-defined JSX components
+     * @see https://eslint.style/rules/jsx/jsx-pascal-case
+     */
+    '@stylistic/jsx-pascal-case'?: Linter.RuleEntry<StylisticJsxPascalCase>;
+    /**
+     * Disallow multiple spaces between inline JSX props
+     * @see https://eslint.style/rules/jsx/jsx-props-no-multi-spaces
+     */
+    '@stylistic/jsx-props-no-multi-spaces'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce the consistent use of either double or single quotes in JSX attributes
+     * @see https://eslint.style/rules/js/jsx-quotes
+     */
+    '@stylistic/jsx-quotes'?: Linter.RuleEntry<StylisticJsxQuotes>;
+    /**
+     * Disallow extra closing tags for components without children
+     * @see https://eslint.style/rules/jsx/jsx-self-closing-comp
+     */
+    '@stylistic/jsx-self-closing-comp'?: Linter.RuleEntry<StylisticJsxSelfClosingComp>;
+    /**
+     * Enforce props alphabetical sorting
+     * @see https://eslint.style/rules/jsx/jsx-sort-props
+     */
+    '@stylistic/jsx-sort-props'?: Linter.RuleEntry<StylisticJsxSortProps>;
+    /**
+     * Enforce whitespace in and around the JSX opening and closing brackets
+     * @see https://eslint.style/rules/jsx/jsx-tag-spacing
+     */
+    '@stylistic/jsx-tag-spacing'?: Linter.RuleEntry<StylisticJsxTagSpacing>;
+    /**
+     * Disallow missing parentheses around multiline JSX
+     * @see https://eslint.style/rules/jsx/jsx-wrap-multilines
+     */
+    '@stylistic/jsx-wrap-multilines'?: Linter.RuleEntry<StylisticJsxWrapMultilines>;
+    /**
+     * Enforce consistent spacing between property names and type annotations in types and interfaces
+     * @see https://eslint.style/rules/ts/key-spacing
+     */
+    '@stylistic/key-spacing'?: Linter.RuleEntry<StylisticKeySpacing>;
+    /**
+     * Enforce consistent spacing before and after keywords
+     * @see https://eslint.style/rules/ts/keyword-spacing
+     */
+    '@stylistic/keyword-spacing'?: Linter.RuleEntry<StylisticKeywordSpacing>;
+    /**
+     * Enforce position of line comments
+     * @see https://eslint.style/rules/js/line-comment-position
+     */
+    '@stylistic/line-comment-position'?: Linter.RuleEntry<StylisticLineCommentPosition>;
+    /**
+     * Enforce consistent linebreak style
+     * @see https://eslint.style/rules/js/linebreak-style
+     */
+    '@stylistic/linebreak-style'?: Linter.RuleEntry<StylisticLinebreakStyle>;
+    /**
+     * Require empty lines around comments
+     * @see https://eslint.style/rules/ts/lines-around-comment
+     */
+    '@stylistic/lines-around-comment'?: Linter.RuleEntry<StylisticLinesAroundComment>;
+    /**
+     * Require or disallow an empty line between class members
+     * @see https://eslint.style/rules/ts/lines-between-class-members
+     */
+    '@stylistic/lines-between-class-members'?: Linter.RuleEntry<StylisticLinesBetweenClassMembers>;
+    /**
+     * Enforce a maximum line length
+     * @see https://eslint.style/rules/js/max-len
+     */
+    '@stylistic/max-len'?: Linter.RuleEntry<StylisticMaxLen>;
+    /**
+     * Enforce a maximum number of statements allowed per line
+     * @see https://eslint.style/rules/js/max-statements-per-line
+     */
+    '@stylistic/max-statements-per-line'?: Linter.RuleEntry<StylisticMaxStatementsPerLine>;
+    /**
+     * Require a specific member delimiter style for interfaces and type literals
+     * @see https://eslint.style/rules/ts/member-delimiter-style
+     */
+    '@stylistic/member-delimiter-style'?: Linter.RuleEntry<StylisticMemberDelimiterStyle>;
+    /**
+     * Enforce a particular style for multiline comments
+     * @see https://eslint.style/rules/js/multiline-comment-style
+     */
+    '@stylistic/multiline-comment-style'?: Linter.RuleEntry<StylisticMultilineCommentStyle>;
+    /**
+     * Enforce newlines between operands of ternary expressions
+     * @see https://eslint.style/rules/js/multiline-ternary
+     */
+    '@stylistic/multiline-ternary'?: Linter.RuleEntry<StylisticMultilineTernary>;
+    /**
+     * Enforce or disallow parentheses when invoking a constructor with no arguments
+     * @see https://eslint.style/rules/js/new-parens
+     */
+    '@stylistic/new-parens'?: Linter.RuleEntry<StylisticNewParens>;
+    /**
+     * Require a newline after each call in a method chain
+     * @see https://eslint.style/rules/js/newline-per-chained-call
+     */
+    '@stylistic/newline-per-chained-call'?: Linter.RuleEntry<StylisticNewlinePerChainedCall>;
+    /**
+     * Disallow arrow functions where they could be confused with comparisons
+     * @see https://eslint.style/rules/js/no-confusing-arrow
+     */
+    '@stylistic/no-confusing-arrow'?: Linter.RuleEntry<StylisticNoConfusingArrow>;
+    /**
+     * Disallow unnecessary parentheses
+     * @see https://eslint.style/rules/ts/no-extra-parens
+     */
+    '@stylistic/no-extra-parens'?: Linter.RuleEntry<StylisticNoExtraParens>;
+    /**
+     * Disallow unnecessary semicolons
+     * @see https://eslint.style/rules/ts/no-extra-semi
+     */
+    '@stylistic/no-extra-semi'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow leading or trailing decimal points in numeric literals
+     * @see https://eslint.style/rules/js/no-floating-decimal
+     */
+    '@stylistic/no-floating-decimal'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow mixed binary operators
+     * @see https://eslint.style/rules/js/no-mixed-operators
+     */
+    '@stylistic/no-mixed-operators'?: Linter.RuleEntry<StylisticNoMixedOperators>;
+    /**
+     * Disallow mixed spaces and tabs for indentation
+     * @see https://eslint.style/rules/js/no-mixed-spaces-and-tabs
+     */
+    '@stylistic/no-mixed-spaces-and-tabs'?: Linter.RuleEntry<StylisticNoMixedSpacesAndTabs>;
+    /**
+     * Disallow multiple spaces
+     * @see https://eslint.style/rules/js/no-multi-spaces
+     */
+    '@stylistic/no-multi-spaces'?: Linter.RuleEntry<StylisticNoMultiSpaces>;
+    /**
+     * Disallow multiple empty lines
+     * @see https://eslint.style/rules/js/no-multiple-empty-lines
+     */
+    '@stylistic/no-multiple-empty-lines'?: Linter.RuleEntry<StylisticNoMultipleEmptyLines>;
+    /**
+     * Disallow all tabs
+     * @see https://eslint.style/rules/js/no-tabs
+     */
+    '@stylistic/no-tabs'?: Linter.RuleEntry<StylisticNoTabs>;
+    /**
+     * Disallow trailing whitespace at the end of lines
+     * @see https://eslint.style/rules/js/no-trailing-spaces
+     */
+    '@stylistic/no-trailing-spaces'?: Linter.RuleEntry<StylisticNoTrailingSpaces>;
+    /**
+     * Disallow whitespace before properties
+     * @see https://eslint.style/rules/js/no-whitespace-before-property
+     */
+    '@stylistic/no-whitespace-before-property'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce the location of single-line statements
+     * @see https://eslint.style/rules/js/nonblock-statement-body-position
+     */
+    '@stylistic/nonblock-statement-body-position'?: Linter.RuleEntry<StylisticNonblockStatementBodyPosition>;
+    /**
+     * Enforce consistent line breaks after opening and before closing braces
+     * @see https://eslint.style/rules/ts/object-curly-newline
+     */
+    '@stylistic/object-curly-newline'?: Linter.RuleEntry<StylisticObjectCurlyNewline>;
+    /**
+     * Enforce consistent spacing inside braces
+     * @see https://eslint.style/rules/ts/object-curly-spacing
+     */
+    '@stylistic/object-curly-spacing'?: Linter.RuleEntry<StylisticObjectCurlySpacing>;
+    /**
+     * Enforce placing object properties on separate lines
+     * @see https://eslint.style/rules/ts/object-property-newline
+     */
+    '@stylistic/object-property-newline'?: Linter.RuleEntry<StylisticObjectPropertyNewline>;
+    /**
+     * Require or disallow newlines around variable declarations
+     * @see https://eslint.style/rules/js/one-var-declaration-per-line
+     */
+    '@stylistic/one-var-declaration-per-line'?: Linter.RuleEntry<StylisticOneVarDeclarationPerLine>;
+    /**
+     * Enforce consistent linebreak style for operators
+     * @see https://eslint.style/rules/js/operator-linebreak
+     */
+    '@stylistic/operator-linebreak'?: Linter.RuleEntry<StylisticOperatorLinebreak>;
+    /**
+     * Require or disallow padding within blocks
+     * @see https://eslint.style/rules/js/padded-blocks
+     */
+    '@stylistic/padded-blocks'?: Linter.RuleEntry<StylisticPaddedBlocks>;
+    /**
+     * Require or disallow padding lines between statements
+     * @see https://eslint.style/rules/ts/padding-line-between-statements
+     */
+    '@stylistic/padding-line-between-statements'?: Linter.RuleEntry<StylisticPaddingLineBetweenStatements>;
+    /**
+     * Require quotes around object literal, type literal, interfaces and enums property names
+     * @see https://eslint.style/rules/ts/quote-props
+     */
+    '@stylistic/quote-props'?: Linter.RuleEntry<StylisticQuoteProps>;
+    /**
+     * Enforce the consistent use of either backticks, double, or single quotes
+     * @see https://eslint.style/rules/ts/quotes
+     */
+    '@stylistic/quotes'?: Linter.RuleEntry<StylisticQuotes>;
+    /**
+     * Enforce spacing between rest and spread operators and their expressions
+     * @see https://eslint.style/rules/js/rest-spread-spacing
+     */
+    '@stylistic/rest-spread-spacing'?: Linter.RuleEntry<StylisticRestSpreadSpacing>;
+    /**
+     * Require or disallow semicolons instead of ASI
+     * @see https://eslint.style/rules/ts/semi
+     */
+    '@stylistic/semi'?: Linter.RuleEntry<StylisticSemi>;
+    /**
+     * Enforce consistent spacing before and after semicolons
+     * @see https://eslint.style/rules/ts/semi-spacing
+     */
+    '@stylistic/semi-spacing'?: Linter.RuleEntry<StylisticSemiSpacing>;
+    /**
+     * Enforce location of semicolons
+     * @see https://eslint.style/rules/js/semi-style
+     */
+    '@stylistic/semi-style'?: Linter.RuleEntry<StylisticSemiStyle>;
+    /**
+     * Enforce consistent spacing before blocks
+     * @see https://eslint.style/rules/ts/space-before-blocks
+     */
+    '@stylistic/space-before-blocks'?: Linter.RuleEntry<StylisticSpaceBeforeBlocks>;
+    /**
+     * Enforce consistent spacing before function parenthesis
+     * @see https://eslint.style/rules/ts/space-before-function-paren
+     */
+    '@stylistic/space-before-function-paren'?: Linter.RuleEntry<StylisticSpaceBeforeFunctionParen>;
+    /**
+     * Enforce consistent spacing inside parentheses
+     * @see https://eslint.style/rules/js/space-in-parens
+     */
+    '@stylistic/space-in-parens'?: Linter.RuleEntry<StylisticSpaceInParens>;
+    /**
+     * Require spacing around infix operators
+     * @see https://eslint.style/rules/ts/space-infix-ops
+     */
+    '@stylistic/space-infix-ops'?: Linter.RuleEntry<StylisticSpaceInfixOps>;
+    /**
+     * Enforce consistent spacing before or after unary operators
+     * @see https://eslint.style/rules/js/space-unary-ops
+     */
+    '@stylistic/space-unary-ops'?: Linter.RuleEntry<StylisticSpaceUnaryOps>;
+    /**
+     * Enforce consistent spacing after the `//` or `/*` in a comment
+     * @see https://eslint.style/rules/js/spaced-comment
+     */
+    '@stylistic/spaced-comment'?: Linter.RuleEntry<StylisticSpacedComment>;
+    /**
+     * Enforce spacing around colons of switch statements
+     * @see https://eslint.style/rules/js/switch-colon-spacing
+     */
+    '@stylistic/switch-colon-spacing'?: Linter.RuleEntry<StylisticSwitchColonSpacing>;
+    /**
+     * Require or disallow spacing around embedded expressions of template strings
+     * @see https://eslint.style/rules/js/template-curly-spacing
+     */
+    '@stylistic/template-curly-spacing'?: Linter.RuleEntry<StylisticTemplateCurlySpacing>;
+    /**
+     * Require or disallow spacing between template tags and their literals
+     * @see https://eslint.style/rules/js/template-tag-spacing
+     */
+    '@stylistic/template-tag-spacing'?: Linter.RuleEntry<StylisticTemplateTagSpacing>;
+    /**
+     * Require consistent spacing around type annotations
+     * @see https://eslint.style/rules/ts/type-annotation-spacing
+     */
+    '@stylistic/type-annotation-spacing'?: Linter.RuleEntry<StylisticTypeAnnotationSpacing>;
+    /**
+     * Enforces consistent spacing inside TypeScript type generics
+     * @see https://eslint.style/rules/plus/type-generic-spacing
+     */
+    '@stylistic/type-generic-spacing'?: Linter.RuleEntry<[]>;
+    /**
+     * Expect space before the type declaration in the named tuple
+     * @see https://eslint.style/rules/plus/type-named-tuple-spacing
+     */
+    '@stylistic/type-named-tuple-spacing'?: Linter.RuleEntry<[]>;
+    /**
+     * Require parentheses around immediate `function` invocations
+     * @see https://eslint.style/rules/js/wrap-iife
+     */
+    '@stylistic/wrap-iife'?: Linter.RuleEntry<StylisticWrapIife>;
+    /**
+     * Require parenthesis around regex literals
+     * @see https://eslint.style/rules/js/wrap-regex
+     */
+    '@stylistic/wrap-regex'?: Linter.RuleEntry<[]>;
+    /**
+     * Require or disallow spacing around the `*` in `yield*` expressions
+     * @see https://eslint.style/rules/js/yield-star-spacing
+     */
+    '@stylistic/yield-star-spacing'?: Linter.RuleEntry<StylisticYieldStarSpacing>;
+}
+type StylisticArrayBracketNewline = [] | [
+    (("always" | "never" | "consistent") | {
+        multiline?: boolean;
+        minItems?: (number | null);
+    })
+];
+type StylisticArrayBracketSpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        singleValue?: boolean;
+        objectsInArrays?: boolean;
+        arraysInArrays?: boolean;
+    }
+];
+type StylisticArrayElementNewline = [] | [
+    (_StylisticArrayElementNewlineBasicConfig | {
+        ArrayExpression?: _StylisticArrayElementNewlineBasicConfig;
+        ArrayPattern?: _StylisticArrayElementNewlineBasicConfig;
+    })
+];
+type _StylisticArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
+    consistent?: boolean;
+    multiline?: boolean;
+    minItems?: (number | null);
+});
+type StylisticArrowParens = [] | [("always" | "as-needed")] | [
+    ("always" | "as-needed"),
+    {
+        requireForBlockBody?: boolean;
+    }
+];
+type StylisticArrowSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+    }
+];
+type StylisticBlockSpacing = [] | [("always" | "never")];
+type StylisticBraceStyle = [] | [("1tbs" | "stroustrup" | "allman")] | [
+    ("1tbs" | "stroustrup" | "allman"),
+    {
+        allowSingleLine?: boolean;
+    }
+];
+type StylisticCommaDangle = [] | [
+    (_StylisticCommaDangleValue | {
+        arrays?: _StylisticCommaDangleValueWithIgnore;
+        objects?: _StylisticCommaDangleValueWithIgnore;
+        imports?: _StylisticCommaDangleValueWithIgnore;
+        exports?: _StylisticCommaDangleValueWithIgnore;
+        functions?: _StylisticCommaDangleValueWithIgnore;
+        importAttributes?: _StylisticCommaDangleValueWithIgnore;
+        dynamicImports?: _StylisticCommaDangleValueWithIgnore;
+        enums?: _StylisticCommaDangleValueWithIgnore;
+        generics?: _StylisticCommaDangleValueWithIgnore;
+        tuples?: _StylisticCommaDangleValueWithIgnore;
+    })
+];
+type _StylisticCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline");
+type _StylisticCommaDangleValueWithIgnore = ("always-multiline" | "always" | "never" | "only-multiline" | "ignore");
+type StylisticCommaSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+    }
+];
+type StylisticCommaStyle = [] | [("first" | "last")] | [
+    ("first" | "last"),
+    {
+        exceptions?: {
+            [k: string]: boolean | undefined;
+        };
+    }
+];
+type StylisticComputedPropertySpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        enforceForClassMembers?: boolean;
+    }
+];
+type StylisticCurlyNewline = [] | [
+    (("always" | "never") | {
+        IfStatementConsequent?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        IfStatementAlternative?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        DoWhileStatement?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        ForInStatement?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        ForOfStatement?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        ForStatement?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        WhileStatement?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        SwitchStatement?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        SwitchCase?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        TryStatementBlock?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        TryStatementHandler?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        TryStatementFinalizer?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        BlockStatement?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        ArrowFunctionExpression?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        FunctionDeclaration?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        FunctionExpression?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        Property?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        ClassBody?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        StaticBlock?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        WithStatement?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        TSEnumBody?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        TSInterfaceBody?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        TSModuleBlock?: (("always" | "never") | {
+            multiline?: boolean;
+            minElements?: number;
+            consistent?: boolean;
+        });
+        multiline?: boolean;
+        minElements?: number;
+        consistent?: boolean;
+    })
+];
+type StylisticDotLocation = [] | [("object" | "property")];
+type StylisticEolLast = [] | [("always" | "never" | "unix" | "windows")];
+type StylisticFuncCallSpacing = ([] | ["never"] | [] | ["always"] | [
+    "always",
+    {
+        allowNewlines?: boolean;
+        optionalChain?: {
+            before?: boolean;
+            after?: boolean;
+        };
+    }
+]);
+type StylisticFunctionCallArgumentNewline = [] | [("always" | "never" | "consistent")];
+type StylisticFunctionCallSpacing = ([] | ["never"] | [] | ["always"] | [
+    "always",
+    {
+        allowNewlines?: boolean;
+        optionalChain?: {
+            before?: boolean;
+            after?: boolean;
+        };
+    }
+]);
+type StylisticFunctionParenNewline = [] | [
+    (("always" | "never" | "consistent" | "multiline" | "multiline-arguments") | {
+        minItems?: number;
+    })
+];
+type StylisticGeneratorStarSpacing = [] | [
+    (("before" | "after" | "both" | "neither") | {
+        before?: boolean;
+        after?: boolean;
+        named?: (("before" | "after" | "both" | "neither") | {
+            before?: boolean;
+            after?: boolean;
+        });
+        anonymous?: (("before" | "after" | "both" | "neither") | {
+            before?: boolean;
+            after?: boolean;
+        });
+        method?: (("before" | "after" | "both" | "neither") | {
+            before?: boolean;
+            after?: boolean;
+        });
+    })
+];
+type StylisticImplicitArrowLinebreak = [] | [("beside" | "below")];
+type StylisticIndent = [] | [("tab" | number)] | [
+    ("tab" | number),
+    {
+        SwitchCase?: number;
+        VariableDeclarator?: ((number | ("first" | "off")) | {
+            var?: (number | ("first" | "off"));
+            let?: (number | ("first" | "off"));
+            const?: (number | ("first" | "off"));
+        });
+        outerIIFEBody?: (number | "off");
+        MemberExpression?: (number | "off");
+        FunctionDeclaration?: {
+            parameters?: (number | ("first" | "off"));
+            body?: number;
+        };
+        FunctionExpression?: {
+            parameters?: (number | ("first" | "off"));
+            body?: number;
+        };
+        StaticBlock?: {
+            body?: number;
+        };
+        CallExpression?: {
+            arguments?: (number | ("first" | "off"));
+        };
+        ArrayExpression?: (number | ("first" | "off"));
+        ObjectExpression?: (number | ("first" | "off"));
+        ImportDeclaration?: (number | ("first" | "off"));
+        flatTernaryExpressions?: boolean;
+        offsetTernaryExpressions?: boolean;
+        offsetTernaryExpressionsOffsetCallExpressions?: boolean;
+        ignoredNodes?: string[];
+        ignoreComments?: boolean;
+        tabLength?: number;
+    }
+];
+type StylisticIndentBinaryOps = [] | [(number | "tab")];
+type StylisticJsxClosingBracketLocation = [] | [
+    (("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | {
+        location?: ("after-props" | "props-aligned" | "tag-aligned" | "line-aligned");
+    } | {
+        nonEmpty?: (("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | false);
+        selfClosing?: (("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | false);
+    })
+];
+type StylisticJsxClosingTagLocation = [] | [("tag-aligned" | "line-aligned")];
+type StylisticJsxCurlyBracePresence = [] | [
+    ({
+        props?: ("always" | "never" | "ignore");
+        children?: ("always" | "never" | "ignore");
+        propElementValues?: ("always" | "never" | "ignore");
+    } | ("always" | "never" | "ignore"))
+];
+type StylisticJsxCurlyNewline = [] | [
+    (("consistent" | "never") | {
+        singleline?: ("consistent" | "require" | "forbid");
+        multiline?: ("consistent" | "require" | "forbid");
+    })
+];
+type StylisticJsxCurlySpacing = [] | [
+    ((_StylisticJsxCurlySpacing_BasicConfig & {
+        attributes?: _StylisticJsxCurlySpacingBasicConfigOrBoolean;
+        children?: _StylisticJsxCurlySpacingBasicConfigOrBoolean;
+        [k: string]: unknown | undefined;
+    }) | ("always" | "never"))
+] | [
+    ((_StylisticJsxCurlySpacing_BasicConfig & {
+        attributes?: _StylisticJsxCurlySpacingBasicConfigOrBoolean;
+        children?: _StylisticJsxCurlySpacingBasicConfigOrBoolean;
+        [k: string]: unknown | undefined;
+    }) | ("always" | "never")),
+    {
+        allowMultiline?: boolean;
+        spacing?: {
+            objectLiterals?: ("always" | "never");
+            [k: string]: unknown | undefined;
+        };
+    }
+];
+type _StylisticJsxCurlySpacingBasicConfigOrBoolean = (_StylisticJsxCurlySpacing_BasicConfig | boolean);
+interface _StylisticJsxCurlySpacing_BasicConfig {
+    when?: ("always" | "never");
+    allowMultiline?: boolean;
+    spacing?: {
+        objectLiterals?: ("always" | "never");
+        [k: string]: unknown | undefined;
+    };
+    [k: string]: unknown | undefined;
+}
+type StylisticJsxEqualsSpacing = [] | [("always" | "never")];
+type StylisticJsxFirstPropNewLine = [] | [("always" | "never" | "multiline" | "multiline-multiprop" | "multiprop")];
+type StylisticJsxFunctionCallNewline = [] | [("always" | "multiline")];
+type StylisticJsxIndent = [] | [("tab" | number)] | [
+    ("tab" | number),
+    {
+        checkAttributes?: boolean;
+        indentLogicalExpressions?: boolean;
+    }
+];
+type StylisticJsxIndentProps = [] | [
+    (("tab" | "first") | number | {
+        indentMode?: (("tab" | "first") | number);
+        ignoreTernaryOperator?: boolean;
+        [k: string]: unknown | undefined;
+    })
+];
+type StylisticJsxMaxPropsPerLine = [] | [
+    ({
+        maximum?: {
+            single?: number;
+            multi?: number;
+            [k: string]: unknown | undefined;
+        };
+    } | {
+        maximum?: number;
+        when?: ("always" | "multiline");
+    })
+];
+type StylisticJsxNewline = [] | [
+    {
+        prevent?: boolean;
+        allowMultilines?: boolean;
+    }
+];
+type StylisticJsxOneExpressionPerLine = [] | [
+    {
+        allow?: ("none" | "literal" | "single-child" | "single-line" | "non-jsx");
+    }
+];
+type StylisticJsxPascalCase = [] | [
+    {
+        allowAllCaps?: boolean;
+        allowLeadingUnderscore?: boolean;
+        allowNamespace?: boolean;
+        ignore?: string[];
+    }
+];
+type StylisticJsxQuotes = [] | [("prefer-single" | "prefer-double")];
+type StylisticJsxSelfClosingComp = [] | [
+    {
+        component?: boolean;
+        html?: boolean;
+    }
+];
+type StylisticJsxSortProps = [] | [
+    {
+        callbacksLast?: boolean;
+        shorthandFirst?: boolean;
+        shorthandLast?: boolean;
+        multiline?: ("ignore" | "first" | "last");
+        ignoreCase?: boolean;
+        noSortAlphabetically?: boolean;
+        reservedFirst?: (unknown[] | boolean);
+        locale?: string;
+    }
+];
+type StylisticJsxTagSpacing = [] | [
+    {
+        closingSlash?: ("always" | "never" | "allow");
+        beforeSelfClosing?: ("always" | "proportional-always" | "never" | "allow");
+        afterOpening?: ("always" | "allow-multiline" | "never" | "allow");
+        beforeClosing?: ("always" | "proportional-always" | "never" | "allow");
+    }
+];
+type StylisticJsxWrapMultilines = [] | [
+    {
+        declaration?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
+        assignment?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
+        return?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
+        arrow?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
+        condition?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
+        logical?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
+        prop?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
+        propertyValue?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
+    }
+];
+type StylisticKeySpacing = [] | [
+    ({
+        align?: (("colon" | "value") | {
+            mode?: ("strict" | "minimum");
+            on?: ("colon" | "value");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        });
+        mode?: ("strict" | "minimum");
+        beforeColon?: boolean;
+        afterColon?: boolean;
+        ignoredNodes?: ("ObjectExpression" | "ObjectPattern" | "ImportDeclaration" | "ExportNamedDeclaration" | "ExportAllDeclaration" | "TSTypeLiteral" | "TSInterfaceBody" | "ClassBody")[];
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            align?: (("colon" | "value") | {
+                mode?: ("strict" | "minimum");
+                on?: ("colon" | "value");
+                beforeColon?: boolean;
+                afterColon?: boolean;
+            });
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        align?: {
+            mode?: ("strict" | "minimum");
+            on?: ("colon" | "value");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    })
+];
+type StylisticKeywordSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+        overrides?: {
+            abstract?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            as?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            async?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            await?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            boolean?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            break?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            byte?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            case?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            catch?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            char?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            class?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            const?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            continue?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            debugger?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            default?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            delete?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            do?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            double?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            else?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            enum?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            export?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            extends?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            false?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            final?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            finally?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            float?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            for?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            from?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            function?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            get?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            goto?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            if?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            implements?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            import?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            in?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            instanceof?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            int?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            interface?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            let?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            long?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            native?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            new?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            null?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            of?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            package?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            private?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            protected?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            public?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            return?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            satisfies?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            set?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            short?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            static?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            super?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            switch?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            synchronized?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            this?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            throw?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            throws?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            transient?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            true?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            try?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            typeof?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            var?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            void?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            volatile?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            while?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            with?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            yield?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            type?: {
+                before?: boolean;
+                after?: boolean;
+            };
+        };
+    }
+];
+type StylisticLineCommentPosition = [] | [
+    (("above" | "beside") | {
+        position?: ("above" | "beside");
+        ignorePattern?: string;
+        applyDefaultPatterns?: boolean;
+        applyDefaultIgnorePatterns?: boolean;
+    })
+];
+type StylisticLinebreakStyle = [] | [("unix" | "windows")];
+type StylisticLinesAroundComment = [] | [
+    {
+        beforeBlockComment?: boolean;
+        afterBlockComment?: boolean;
+        beforeLineComment?: boolean;
+        afterLineComment?: boolean;
+        allowBlockStart?: boolean;
+        allowBlockEnd?: boolean;
+        allowClassStart?: boolean;
+        allowClassEnd?: boolean;
+        allowObjectStart?: boolean;
+        allowObjectEnd?: boolean;
+        allowArrayStart?: boolean;
+        allowArrayEnd?: boolean;
+        allowInterfaceStart?: boolean;
+        allowInterfaceEnd?: boolean;
+        allowTypeStart?: boolean;
+        allowTypeEnd?: boolean;
+        allowEnumStart?: boolean;
+        allowEnumEnd?: boolean;
+        allowModuleStart?: boolean;
+        allowModuleEnd?: boolean;
+        ignorePattern?: string;
+        applyDefaultIgnorePatterns?: boolean;
+        afterHashbangComment?: boolean;
+    }
+];
+type StylisticLinesBetweenClassMembers = [] | [
+    ({
+        enforce: [
+            {
+                blankLine: ("always" | "never");
+                prev: ("method" | "field" | "*");
+                next: ("method" | "field" | "*");
+            },
+            ...({
+                blankLine: ("always" | "never");
+                prev: ("method" | "field" | "*");
+                next: ("method" | "field" | "*");
+            })[]
+        ];
+    } | ("always" | "never"))
+] | [
+    ({
+        enforce: [
+            {
+                blankLine: ("always" | "never");
+                prev: ("method" | "field" | "*");
+                next: ("method" | "field" | "*");
+            },
+            ...({
+                blankLine: ("always" | "never");
+                prev: ("method" | "field" | "*");
+                next: ("method" | "field" | "*");
+            })[]
+        ];
+    } | ("always" | "never")),
+    {
+        exceptAfterSingleLine?: boolean;
+        exceptAfterOverload?: boolean;
+    }
+];
+type StylisticMaxLen = [] | [
+    ({
+        code?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreStrings?: boolean;
+        ignoreUrls?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreTrailingComments?: boolean;
+    } | number)
+] | [
+    ({
+        code?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreStrings?: boolean;
+        ignoreUrls?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreTrailingComments?: boolean;
+    } | number),
+    ({
+        code?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreStrings?: boolean;
+        ignoreUrls?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreTrailingComments?: boolean;
+    } | number)
+] | [
+    ({
+        code?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreStrings?: boolean;
+        ignoreUrls?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreTrailingComments?: boolean;
+    } | number),
+    ({
+        code?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreStrings?: boolean;
+        ignoreUrls?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreTrailingComments?: boolean;
+    } | number),
+    {
+        code?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreStrings?: boolean;
+        ignoreUrls?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreTrailingComments?: boolean;
+    }
+];
+type StylisticMaxStatementsPerLine = [] | [
+    {
+        max?: number;
+        ignoredNodes?: ("BreakStatement" | "ClassDeclaration" | "ContinueStatement" | "DebuggerStatement" | "DoWhileStatement" | "ExpressionStatement" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "IfStatement" | "ImportDeclaration" | "LabeledStatement" | "ReturnStatement" | "SwitchStatement" | "ThrowStatement" | "TryStatement" | "VariableDeclaration" | "WhileStatement" | "WithStatement" | "ExportNamedDeclaration" | "ExportDefaultDeclaration" | "ExportAllDeclaration")[];
+    }
+];
+type StylisticMemberDelimiterStyle = [] | [
+    {
+        multiline?: {
+            delimiter?: ("none" | "semi" | "comma");
+            requireLast?: boolean;
+        };
+        singleline?: {
+            delimiter?: ("semi" | "comma");
+            requireLast?: boolean;
+        };
+        overrides?: {
+            interface?: _StylisticMemberDelimiterStyle_DelimiterConfig;
+            typeLiteral?: _StylisticMemberDelimiterStyle_DelimiterConfig;
+        };
+        multilineDetection?: ("brackets" | "last-member");
+    }
+];
+interface _StylisticMemberDelimiterStyle_DelimiterConfig {
+    multiline?: {
+        delimiter?: ("none" | "semi" | "comma");
+        requireLast?: boolean;
+    };
+    singleline?: {
+        delimiter?: ("semi" | "comma");
+        requireLast?: boolean;
+    };
+}
+type StylisticMultilineCommentStyle = ([] | [("starred-block" | "bare-block")] | [] | ["separate-lines"] | [
+    "separate-lines",
+    {
+        checkJSDoc?: boolean;
+    }
+]);
+type StylisticMultilineTernary = [] | [("always" | "always-multiline" | "never")] | [
+    ("always" | "always-multiline" | "never"),
+    {
+        ignoreJSX?: boolean;
+        [k: string]: unknown | undefined;
+    }
+];
+type StylisticNewParens = [] | [("always" | "never")];
+type StylisticNewlinePerChainedCall = [] | [
+    {
+        ignoreChainWithDepth?: number;
+    }
+];
+type StylisticNoConfusingArrow = [] | [
+    {
+        allowParens?: boolean;
+        onlyOneSimpleParam?: boolean;
+    }
+];
+type StylisticNoExtraParens = ([] | ["functions"] | [] | ["all"] | [
+    "all",
+    {
+        conditionalAssign?: boolean;
+        ternaryOperandBinaryExpressions?: boolean;
+        nestedBinaryExpressions?: boolean;
+        returnAssign?: boolean;
+        ignoreJSX?: ("none" | "all" | "single-line" | "multi-line");
+        enforceForArrowConditionals?: boolean;
+        enforceForSequenceExpressions?: boolean;
+        enforceForNewInMemberExpressions?: boolean;
+        enforceForFunctionPrototypeMethods?: boolean;
+        allowParensAfterCommentPattern?: string;
+        nestedConditionalExpressions?: boolean;
+    }
+]);
+type StylisticNoMixedOperators = [] | [
+    {
+        groups?: [("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ...(("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"))[]][];
+        allowSamePrecedence?: boolean;
+    }
+];
+type StylisticNoMixedSpacesAndTabs = [] | [("smart-tabs" | boolean)];
+type StylisticNoMultiSpaces = [] | [
+    {
+        exceptions?: {
+            [k: string]: boolean;
+        };
+        ignoreEOLComments?: boolean;
+        includeTabs?: boolean;
+    }
+];
+type StylisticNoMultipleEmptyLines = [] | [
+    {
+        max: number;
+        maxEOF?: number;
+        maxBOF?: number;
+    }
+];
+type StylisticNoTabs = [] | [
+    {
+        allowIndentationTabs?: boolean;
+    }
+];
+type StylisticNoTrailingSpaces = [] | [
+    {
+        skipBlankLines?: boolean;
+        ignoreComments?: boolean;
+    }
+];
+type StylisticNonblockStatementBodyPosition = [] | [("beside" | "below" | "any")] | [
+    ("beside" | "below" | "any"),
+    {
+        overrides?: {
+            if?: ("beside" | "below" | "any");
+            else?: ("beside" | "below" | "any");
+            while?: ("beside" | "below" | "any");
+            do?: ("beside" | "below" | "any");
+            for?: ("beside" | "below" | "any");
+        };
+    }
+];
+type StylisticObjectCurlyNewline = [] | [
+    ((("always" | "never") | {
+        multiline?: boolean;
+        minProperties?: number;
+        consistent?: boolean;
+    }) | {
+        ObjectExpression?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ObjectPattern?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ImportDeclaration?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ExportDeclaration?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        TSTypeLiteral?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        TSInterfaceBody?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+    })
+];
+type StylisticObjectCurlySpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        arraysInObjects?: boolean;
+        objectsInObjects?: boolean;
+    }
+];
+type StylisticObjectPropertyNewline = [] | [
+    {
+        allowAllPropertiesOnSameLine?: boolean;
+        allowMultiplePropertiesPerLine?: boolean;
+    }
+];
+type StylisticOneVarDeclarationPerLine = [] | [("always" | "initializations")];
+type StylisticOperatorLinebreak = [] | [(("after" | "before" | "none") | null)] | [
+    (("after" | "before" | "none") | null),
+    {
+        overrides?: {
+            [k: string]: ("after" | "before" | "none" | "ignore") | undefined;
+        };
+    }
+];
+type StylisticPaddedBlocks = [] | [
+    (("always" | "never" | "start" | "end") | {
+        blocks?: ("always" | "never" | "start" | "end");
+        switches?: ("always" | "never" | "start" | "end");
+        classes?: ("always" | "never" | "start" | "end");
+    })
+] | [
+    (("always" | "never" | "start" | "end") | {
+        blocks?: ("always" | "never" | "start" | "end");
+        switches?: ("always" | "never" | "start" | "end");
+        classes?: ("always" | "never" | "start" | "end");
+    }),
+    {
+        allowSingleLineBlocks?: boolean;
+    }
+];
+type _StylisticPaddingLineBetweenStatementsPaddingType = ("any" | "never" | "always");
+type _StylisticPaddingLineBetweenStatementsStatementType = (("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload") | [("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload"), ...(("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload"))[]]);
+type StylisticPaddingLineBetweenStatements = {
+    blankLine: _StylisticPaddingLineBetweenStatementsPaddingType;
+    prev: _StylisticPaddingLineBetweenStatementsStatementType;
+    next: _StylisticPaddingLineBetweenStatementsStatementType;
+}[];
+type StylisticQuoteProps = ([] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [
+    ("always" | "as-needed" | "consistent" | "consistent-as-needed"),
+    {
+        keywords?: boolean;
+        unnecessary?: boolean;
+        numbers?: boolean;
+    }
+]);
+type StylisticQuotes = [] | [("single" | "double" | "backtick")] | [
+    ("single" | "double" | "backtick"),
+    ("avoid-escape" | {
+        avoidEscape?: boolean;
+        allowTemplateLiterals?: (boolean | ("never" | "avoidEscape" | "always"));
+        ignoreStringLiterals?: boolean;
+    })
+];
+type StylisticRestSpreadSpacing = [] | [("always" | "never")];
+type StylisticSemi = ([] | ["never"] | [
+    "never",
+    {
+        beforeStatementContinuationChars?: ("always" | "any" | "never");
+    }
+] | [] | ["always"] | [
+    "always",
+    {
+        omitLastInOneLineBlock?: boolean;
+        omitLastInOneLineClassBody?: boolean;
+    }
+]);
+type StylisticSemiSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+    }
+];
+type StylisticSemiStyle = [] | [("last" | "first")];
+type StylisticSpaceBeforeBlocks = [] | [
+    (("always" | "never") | {
+        keywords?: ("always" | "never" | "off");
+        functions?: ("always" | "never" | "off");
+        classes?: ("always" | "never" | "off");
+    })
+];
+type StylisticSpaceBeforeFunctionParen = [] | [
+    (("always" | "never") | {
+        anonymous?: ("always" | "never" | "ignore");
+        named?: ("always" | "never" | "ignore");
+        asyncArrow?: ("always" | "never" | "ignore");
+    })
+];
+type StylisticSpaceInParens = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        exceptions?: ("{}" | "[]" | "()" | "empty")[];
+    }
+];
+type StylisticSpaceInfixOps = [] | [
+    {
+        int32Hint?: boolean;
+        ignoreTypes?: boolean;
+    }
+];
+type StylisticSpaceUnaryOps = [] | [
+    {
+        words?: boolean;
+        nonwords?: boolean;
+        overrides?: {
+            [k: string]: boolean | undefined;
+        };
+    }
+];
+type StylisticSpacedComment = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        exceptions?: string[];
+        markers?: string[];
+        line?: {
+            exceptions?: string[];
+            markers?: string[];
+        };
+        block?: {
+            exceptions?: string[];
+            markers?: string[];
+            balanced?: boolean;
+        };
+    }
+];
+type StylisticSwitchColonSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+    }
+];
+type StylisticTemplateCurlySpacing = [] | [("always" | "never")];
+type StylisticTemplateTagSpacing = [] | [("always" | "never")];
+type StylisticTypeAnnotationSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+        overrides?: {
+            colon?: _StylisticTypeAnnotationSpacing_SpacingConfig;
+            arrow?: _StylisticTypeAnnotationSpacing_SpacingConfig;
+            variable?: _StylisticTypeAnnotationSpacing_SpacingConfig;
+            parameter?: _StylisticTypeAnnotationSpacing_SpacingConfig;
+            property?: _StylisticTypeAnnotationSpacing_SpacingConfig;
+            returnType?: _StylisticTypeAnnotationSpacing_SpacingConfig;
+        };
+    }
+];
+interface _StylisticTypeAnnotationSpacing_SpacingConfig {
+    before?: boolean;
+    after?: boolean;
+}
+type StylisticWrapIife = [] | [("outside" | "inside" | "any")] | [
+    ("outside" | "inside" | "any"),
+    {
+        functionPrototypeMethods?: boolean;
+    }
+];
+type StylisticYieldStarSpacing = [] | [
+    (("before" | "after" | "both" | "neither") | {
+        before?: boolean;
+        after?: boolean;
+    })
+];
+
 interface SvelteRules {
     /**
      * disallow conditionals where the type is always truthy or always falsy
@@ -9381,642 +11103,643 @@ type TypescriptEslintUnifiedSignatures = [] | [
 interface UnicornRules {
     /**
      * Improve regexes by making them shorter, consistent, and safer.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/better-regex.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/better-regex.md
      */
     'unicorn/better-regex'?: Linter.RuleEntry<UnicornBetterRegex>;
     /**
      * Enforce a specific parameter name in catch clauses.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/catch-error-name.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/catch-error-name.md
      */
     'unicorn/catch-error-name'?: Linter.RuleEntry<UnicornCatchErrorName>;
     /**
      * Enforce consistent assertion style with `node:assert`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/consistent-assert.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/consistent-assert.md
      */
     'unicorn/consistent-assert'?: Linter.RuleEntry<[]>;
     /**
      * Prefer passing `Date` directly to the constructor when cloning.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/consistent-date-clone.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/consistent-date-clone.md
      */
     'unicorn/consistent-date-clone'?: Linter.RuleEntry<[]>;
     /**
      * Use destructured variables over properties.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/consistent-destructuring.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/consistent-destructuring.md
      */
     'unicorn/consistent-destructuring'?: Linter.RuleEntry<[]>;
     /**
      * Prefer consistent types when spreading a ternary in an array literal.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/consistent-empty-array-spread.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/consistent-empty-array-spread.md
      */
     'unicorn/consistent-empty-array-spread'?: Linter.RuleEntry<[]>;
     /**
      * Enforce consistent style for element existence checks with `indexOf()`, `lastIndexOf()`, `findIndex()`, and `findLastIndex()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/consistent-existence-index-check.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/consistent-existence-index-check.md
      */
     'unicorn/consistent-existence-index-check'?: Linter.RuleEntry<[]>;
     /**
      * Move function definitions to the highest possible scope.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/consistent-function-scoping.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/consistent-function-scoping.md
      */
     'unicorn/consistent-function-scoping'?: Linter.RuleEntry<UnicornConsistentFunctionScoping>;
     /**
      * Enforce correct `Error` subclassing.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/custom-error-definition.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/custom-error-definition.md
      */
     'unicorn/custom-error-definition'?: Linter.RuleEntry<[]>;
     /**
      * Enforce no spaces between braces.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/empty-brace-spaces.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/empty-brace-spaces.md
      */
     'unicorn/empty-brace-spaces'?: Linter.RuleEntry<[]>;
     /**
      * Enforce passing a `message` value when creating a built-in error.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/error-message.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/error-message.md
      */
     'unicorn/error-message'?: Linter.RuleEntry<[]>;
     /**
-     * Require escape sequences to use uppercase values.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/escape-case.md
+     * Require escape sequences to use uppercase or lowercase values.
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/escape-case.md
      */
-    'unicorn/escape-case'?: Linter.RuleEntry<[]>;
+    'unicorn/escape-case'?: Linter.RuleEntry<UnicornEscapeCase>;
     /**
      * Add expiration conditions to TODO comments.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/expiring-todo-comments.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/expiring-todo-comments.md
      */
     'unicorn/expiring-todo-comments'?: Linter.RuleEntry<UnicornExpiringTodoComments>;
     /**
      * Enforce explicitly comparing the `length` or `size` property of a value.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/explicit-length-check.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/explicit-length-check.md
      */
     'unicorn/explicit-length-check'?: Linter.RuleEntry<UnicornExplicitLengthCheck>;
     /**
      * Enforce a case style for filenames.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/filename-case.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/filename-case.md
      */
     'unicorn/filename-case'?: Linter.RuleEntry<UnicornFilenameCase>;
     /**
      * Enforce specific import styles per module.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/import-style.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/import-style.md
      */
     'unicorn/import-style'?: Linter.RuleEntry<UnicornImportStyle>;
     /**
      * Enforce the use of `new` for all builtins, except `String`, `Number`, `Boolean`, `Symbol` and `BigInt`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/new-for-builtins.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/new-for-builtins.md
      */
     'unicorn/new-for-builtins'?: Linter.RuleEntry<[]>;
     /**
      * Enforce specifying rules to disable in `eslint-disable` comments.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-abusive-eslint-disable.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-abusive-eslint-disable.md
      */
     'unicorn/no-abusive-eslint-disable'?: Linter.RuleEntry<[]>;
     /**
      * Disallow recursive access to `this` within getters and setters.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-accessor-recursion.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-accessor-recursion.md
      */
     'unicorn/no-accessor-recursion'?: Linter.RuleEntry<[]>;
     /**
      * Disallow anonymous functions and classes as the default export.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-anonymous-default-export.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-anonymous-default-export.md
      */
     'unicorn/no-anonymous-default-export'?: Linter.RuleEntry<[]>;
     /**
      * Prevent passing a function reference directly to iterator methods.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-array-callback-reference.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-array-callback-reference.md
      */
     'unicorn/no-array-callback-reference'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `for…of` over the `forEach` method.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-array-for-each.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-array-for-each.md
      */
     'unicorn/no-array-for-each'?: Linter.RuleEntry<[]>;
     /**
      * Disallow using the `this` argument in array methods.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-array-method-this-argument.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-array-method-this-argument.md
      */
     'unicorn/no-array-method-this-argument'?: Linter.RuleEntry<[]>;
     /**
      * Enforce combining multiple `Array#push()` into one call.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-array-push-push.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-array-push-push.md
      */
     'unicorn/no-array-push-push'?: Linter.RuleEntry<UnicornNoArrayPushPush>;
     /**
      * Disallow `Array#reduce()` and `Array#reduceRight()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-array-reduce.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-array-reduce.md
      */
     'unicorn/no-array-reduce'?: Linter.RuleEntry<UnicornNoArrayReduce>;
     /**
      * Disallow member access from await expression.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-await-expression-member.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-await-expression-member.md
      */
     'unicorn/no-await-expression-member'?: Linter.RuleEntry<[]>;
     /**
      * Disallow using `await` in `Promise` method parameters.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-await-in-promise-methods.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-await-in-promise-methods.md
      */
     'unicorn/no-await-in-promise-methods'?: Linter.RuleEntry<[]>;
     /**
      * Do not use leading/trailing space between `console.log` parameters.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-console-spaces.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-console-spaces.md
      */
     'unicorn/no-console-spaces'?: Linter.RuleEntry<[]>;
     /**
      * Do not use `document.cookie` directly.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-document-cookie.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-document-cookie.md
      */
     'unicorn/no-document-cookie'?: Linter.RuleEntry<[]>;
     /**
      * Disallow empty files.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-empty-file.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-empty-file.md
      */
     'unicorn/no-empty-file'?: Linter.RuleEntry<[]>;
     /**
      * Do not use a `for` loop that can be replaced with a `for-of` loop.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-for-loop.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-for-loop.md
      */
     'unicorn/no-for-loop'?: Linter.RuleEntry<[]>;
     /**
      * Enforce the use of Unicode escapes instead of hexadecimal escapes.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-hex-escape.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-hex-escape.md
      */
     'unicorn/no-hex-escape'?: Linter.RuleEntry<[]>;
     /**
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/deprecated-rules.md#no-instanceof-array
+     * Replaced by `unicorn/no-instanceof-builtins` which covers more cases.
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/deprecated-rules.md#no-instanceof-array
      * @deprecated
      */
     'unicorn/no-instanceof-array'?: Linter.RuleEntry<[]>;
     /**
      * Disallow `instanceof` with built-in objects
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-instanceof-builtins.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-instanceof-builtins.md
      */
     'unicorn/no-instanceof-builtins'?: Linter.RuleEntry<UnicornNoInstanceofBuiltins>;
     /**
      * Disallow invalid options in `fetch()` and `new Request()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-invalid-fetch-options.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-invalid-fetch-options.md
      */
     'unicorn/no-invalid-fetch-options'?: Linter.RuleEntry<[]>;
     /**
      * Prevent calling `EventTarget#removeEventListener()` with the result of an expression.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-invalid-remove-event-listener.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-invalid-remove-event-listener.md
      */
     'unicorn/no-invalid-remove-event-listener'?: Linter.RuleEntry<[]>;
     /**
      * Disallow identifiers starting with `new` or `class`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-keyword-prefix.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-keyword-prefix.md
      */
     'unicorn/no-keyword-prefix'?: Linter.RuleEntry<UnicornNoKeywordPrefix>;
     /**
      * Disallow using `.length` as the `end` argument of `{Array,String,TypedArray}#slice()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-length-as-slice-end.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-length-as-slice-end.md
      */
     'unicorn/no-length-as-slice-end'?: Linter.RuleEntry<[]>;
     /**
      * Disallow `if` statements as the only statement in `if` blocks without `else`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-lonely-if.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-lonely-if.md
      */
     'unicorn/no-lonely-if'?: Linter.RuleEntry<[]>;
     /**
      * Disallow a magic number as the `depth` argument in `Array#flat(…).`
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-magic-array-flat-depth.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-magic-array-flat-depth.md
      */
     'unicorn/no-magic-array-flat-depth'?: Linter.RuleEntry<[]>;
     /**
      * Disallow named usage of default import and export.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-named-default.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-named-default.md
      */
     'unicorn/no-named-default'?: Linter.RuleEntry<[]>;
     /**
      * Disallow negated conditions.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-negated-condition.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-negated-condition.md
      */
     'unicorn/no-negated-condition'?: Linter.RuleEntry<[]>;
     /**
      * Disallow negated expression in equality check.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-negation-in-equality-check.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-negation-in-equality-check.md
      */
     'unicorn/no-negation-in-equality-check'?: Linter.RuleEntry<[]>;
     /**
      * Disallow nested ternary expressions.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-nested-ternary.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-nested-ternary.md
      */
     'unicorn/no-nested-ternary'?: Linter.RuleEntry<[]>;
     /**
      * Disallow `new Array()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-new-array.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-new-array.md
      */
     'unicorn/no-new-array'?: Linter.RuleEntry<[]>;
     /**
      * Enforce the use of `Buffer.from()` and `Buffer.alloc()` instead of the deprecated `new Buffer()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-new-buffer.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-new-buffer.md
      */
     'unicorn/no-new-buffer'?: Linter.RuleEntry<[]>;
     /**
      * Disallow the use of the `null` literal.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-null.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-null.md
      */
     'unicorn/no-null'?: Linter.RuleEntry<UnicornNoNull>;
     /**
      * Disallow the use of objects as default parameters.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-object-as-default-parameter.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-object-as-default-parameter.md
      */
     'unicorn/no-object-as-default-parameter'?: Linter.RuleEntry<[]>;
     /**
      * Disallow `process.exit()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-process-exit.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-process-exit.md
      */
     'unicorn/no-process-exit'?: Linter.RuleEntry<[]>;
     /**
      * Disallow passing single-element arrays to `Promise` methods.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-single-promise-in-promise-methods.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-single-promise-in-promise-methods.md
      */
     'unicorn/no-single-promise-in-promise-methods'?: Linter.RuleEntry<[]>;
     /**
      * Disallow classes that only have static members.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-static-only-class.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-static-only-class.md
      */
     'unicorn/no-static-only-class'?: Linter.RuleEntry<[]>;
     /**
      * Disallow `then` property.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-thenable.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-thenable.md
      */
     'unicorn/no-thenable'?: Linter.RuleEntry<[]>;
     /**
      * Disallow assigning `this` to a variable.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-this-assignment.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-this-assignment.md
      */
     'unicorn/no-this-assignment'?: Linter.RuleEntry<[]>;
     /**
      * Disallow comparing `undefined` using `typeof`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-typeof-undefined.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-typeof-undefined.md
      */
     'unicorn/no-typeof-undefined'?: Linter.RuleEntry<UnicornNoTypeofUndefined>;
     /**
      * Disallow awaiting non-promise values.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-unnecessary-await.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-unnecessary-await.md
      */
     'unicorn/no-unnecessary-await'?: Linter.RuleEntry<[]>;
     /**
      * Enforce the use of built-in methods instead of unnecessary polyfills.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-unnecessary-polyfills.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-unnecessary-polyfills.md
      */
     'unicorn/no-unnecessary-polyfills'?: Linter.RuleEntry<UnicornNoUnnecessaryPolyfills>;
     /**
      * Disallow unreadable array destructuring.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-unreadable-array-destructuring.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-unreadable-array-destructuring.md
      */
     'unicorn/no-unreadable-array-destructuring'?: Linter.RuleEntry<[]>;
     /**
      * Disallow unreadable IIFEs.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-unreadable-iife.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-unreadable-iife.md
      */
     'unicorn/no-unreadable-iife'?: Linter.RuleEntry<[]>;
     /**
      * Disallow unused object properties.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-unused-properties.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-unused-properties.md
      */
     'unicorn/no-unused-properties'?: Linter.RuleEntry<[]>;
     /**
      * Disallow useless fallback when spreading in object literals.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-useless-fallback-in-spread.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-useless-fallback-in-spread.md
      */
     'unicorn/no-useless-fallback-in-spread'?: Linter.RuleEntry<[]>;
     /**
      * Disallow useless array length check.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-useless-length-check.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-useless-length-check.md
      */
     'unicorn/no-useless-length-check'?: Linter.RuleEntry<[]>;
     /**
      * Disallow returning/yielding `Promise.resolve/reject()` in async functions or promise callbacks
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-useless-promise-resolve-reject.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-useless-promise-resolve-reject.md
      */
     'unicorn/no-useless-promise-resolve-reject'?: Linter.RuleEntry<[]>;
     /**
      * Disallow unnecessary spread.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-useless-spread.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-useless-spread.md
      */
     'unicorn/no-useless-spread'?: Linter.RuleEntry<[]>;
     /**
      * Disallow useless case in switch statements.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-useless-switch-case.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-useless-switch-case.md
      */
     'unicorn/no-useless-switch-case'?: Linter.RuleEntry<[]>;
     /**
      * Disallow useless `undefined`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-useless-undefined.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-useless-undefined.md
      */
     'unicorn/no-useless-undefined'?: Linter.RuleEntry<UnicornNoUselessUndefined>;
     /**
      * Disallow number literals with zero fractions or dangling dots.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/no-zero-fractions.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/no-zero-fractions.md
      */
     'unicorn/no-zero-fractions'?: Linter.RuleEntry<[]>;
     /**
      * Enforce proper case for numeric literals.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/number-literal-case.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/number-literal-case.md
      */
-    'unicorn/number-literal-case'?: Linter.RuleEntry<[]>;
+    'unicorn/number-literal-case'?: Linter.RuleEntry<UnicornNumberLiteralCase>;
     /**
      * Enforce the style of numeric separators by correctly grouping digits.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/numeric-separators-style.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/numeric-separators-style.md
      */
     'unicorn/numeric-separators-style'?: Linter.RuleEntry<UnicornNumericSeparatorsStyle>;
     /**
      * Prefer `.addEventListener()` and `.removeEventListener()` over `on`-functions.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-add-event-listener.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-add-event-listener.md
      */
     'unicorn/prefer-add-event-listener'?: Linter.RuleEntry<UnicornPreferAddEventListener>;
     /**
      * Prefer `.find(…)` and `.findLast(…)` over the first or last element from `.filter(…)`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-array-find.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-array-find.md
      */
     'unicorn/prefer-array-find'?: Linter.RuleEntry<UnicornPreferArrayFind>;
     /**
      * Prefer `Array#flat()` over legacy techniques to flatten arrays.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-array-flat.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-array-flat.md
      */
     'unicorn/prefer-array-flat'?: Linter.RuleEntry<UnicornPreferArrayFlat>;
     /**
      * Prefer `.flatMap(…)` over `.map(…).flat()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-array-flat-map.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-array-flat-map.md
      */
     'unicorn/prefer-array-flat-map'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `Array#{indexOf,lastIndexOf}()` over `Array#{findIndex,findLastIndex}()` when looking for the index of an item.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-array-index-of.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-array-index-of.md
      */
     'unicorn/prefer-array-index-of'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast,findIndex,findLastIndex}(…)`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-array-some.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-array-some.md
      */
     'unicorn/prefer-array-some'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `.at()` method for index access and `String#charAt()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-at.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-at.md
      */
     'unicorn/prefer-at'?: Linter.RuleEntry<UnicornPreferAt>;
     /**
      * Prefer `Blob#arrayBuffer()` over `FileReader#readAsArrayBuffer(…)` and `Blob#text()` over `FileReader#readAsText(…)`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-blob-reading-methods.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-blob-reading-methods.md
      */
     'unicorn/prefer-blob-reading-methods'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `String#codePointAt(…)` over `String#charCodeAt(…)` and `String.fromCodePoint(…)` over `String.fromCharCode(…)`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-code-point.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-code-point.md
      */
     'unicorn/prefer-code-point'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `Date.now()` to get the number of milliseconds since the Unix Epoch.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-date-now.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-date-now.md
      */
     'unicorn/prefer-date-now'?: Linter.RuleEntry<[]>;
     /**
      * Prefer default parameters over reassignment.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-default-parameters.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-default-parameters.md
      */
     'unicorn/prefer-default-parameters'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `Node#append()` over `Node#appendChild()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-dom-node-append.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-dom-node-append.md
      */
     'unicorn/prefer-dom-node-append'?: Linter.RuleEntry<[]>;
     /**
      * Prefer using `.dataset` on DOM elements over calling attribute methods.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-dom-node-dataset.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-dom-node-dataset.md
      */
     'unicorn/prefer-dom-node-dataset'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-dom-node-remove.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-dom-node-remove.md
      */
     'unicorn/prefer-dom-node-remove'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `.textContent` over `.innerText`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-dom-node-text-content.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-dom-node-text-content.md
      */
     'unicorn/prefer-dom-node-text-content'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `EventTarget` over `EventEmitter`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-event-target.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-event-target.md
      */
     'unicorn/prefer-event-target'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `export…from` when re-exporting.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-export-from.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-export-from.md
      */
     'unicorn/prefer-export-from'?: Linter.RuleEntry<UnicornPreferExportFrom>;
     /**
      * Prefer `globalThis` over `window`, `self`, and `global`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-global-this.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-global-this.md
      */
     'unicorn/prefer-global-this'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `.includes()` over `.indexOf()`, `.lastIndexOf()`, and `Array#some()` when checking for existence or non-existence.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-includes.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-includes.md
      */
     'unicorn/prefer-includes'?: Linter.RuleEntry<[]>;
     /**
      * Prefer reading a JSON file as a buffer.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-json-parse-buffer.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-json-parse-buffer.md
      */
     'unicorn/prefer-json-parse-buffer'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-keyboard-event-key.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-keyboard-event-key.md
      */
     'unicorn/prefer-keyboard-event-key'?: Linter.RuleEntry<[]>;
     /**
      * Prefer using a logical operator over a ternary.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-logical-operator-over-ternary.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-logical-operator-over-ternary.md
      */
     'unicorn/prefer-logical-operator-over-ternary'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `Math.min()` and `Math.max()` over ternaries for simple comparisons.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-math-min-max.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-math-min-max.md
      */
     'unicorn/prefer-math-min-max'?: Linter.RuleEntry<[]>;
     /**
      * Enforce the use of `Math.trunc` instead of bitwise operators.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-math-trunc.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-math-trunc.md
      */
     'unicorn/prefer-math-trunc'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `.before()` over `.insertBefore()`, `.replaceWith()` over `.replaceChild()`, prefer one of `.before()`, `.after()`, `.append()` or `.prepend()` over `insertAdjacentText()` and `insertAdjacentElement()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-modern-dom-apis.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-modern-dom-apis.md
      */
     'unicorn/prefer-modern-dom-apis'?: Linter.RuleEntry<[]>;
     /**
      * Prefer modern `Math` APIs over legacy patterns.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-modern-math-apis.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-modern-math-apis.md
      */
     'unicorn/prefer-modern-math-apis'?: Linter.RuleEntry<[]>;
     /**
      * Prefer JavaScript modules (ESM) over CommonJS.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-module.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-module.md
      */
     'unicorn/prefer-module'?: Linter.RuleEntry<[]>;
     /**
      * Prefer using `String`, `Number`, `BigInt`, `Boolean`, and `Symbol` directly.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-native-coercion-functions.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-native-coercion-functions.md
      */
     'unicorn/prefer-native-coercion-functions'?: Linter.RuleEntry<[]>;
     /**
      * Prefer negative index over `.length - index` when possible.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-negative-index.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-negative-index.md
      */
     'unicorn/prefer-negative-index'?: Linter.RuleEntry<[]>;
     /**
      * Prefer using the `node:` protocol when importing Node.js builtin modules.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-node-protocol.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-node-protocol.md
      */
     'unicorn/prefer-node-protocol'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `Number` static properties over global ones.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-number-properties.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-number-properties.md
      */
     'unicorn/prefer-number-properties'?: Linter.RuleEntry<UnicornPreferNumberProperties>;
     /**
      * Prefer using `Object.fromEntries(…)` to transform a list of key-value pairs into an object.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-object-from-entries.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-object-from-entries.md
      */
     'unicorn/prefer-object-from-entries'?: Linter.RuleEntry<UnicornPreferObjectFromEntries>;
     /**
      * Prefer omitting the `catch` binding parameter.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-optional-catch-binding.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-optional-catch-binding.md
      */
     'unicorn/prefer-optional-catch-binding'?: Linter.RuleEntry<[]>;
     /**
      * Prefer borrowing methods from the prototype instead of the instance.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-prototype-methods.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-prototype-methods.md
      */
     'unicorn/prefer-prototype-methods'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()` and `.getElementsByName()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-query-selector.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-query-selector.md
      */
     'unicorn/prefer-query-selector'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `Reflect.apply()` over `Function#apply()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-reflect-apply.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-reflect-apply.md
      */
     'unicorn/prefer-reflect-apply'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-regexp-test.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-regexp-test.md
      */
     'unicorn/prefer-regexp-test'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-set-has.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-set-has.md
      */
     'unicorn/prefer-set-has'?: Linter.RuleEntry<[]>;
     /**
      * Prefer using `Set#size` instead of `Array#length`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-set-size.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-set-size.md
      */
     'unicorn/prefer-set-size'?: Linter.RuleEntry<[]>;
     /**
      * Prefer the spread operator over `Array.from(…)`, `Array#concat(…)`, `Array#{slice,toSpliced}()` and `String#split('')`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-spread.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-spread.md
      */
     'unicorn/prefer-spread'?: Linter.RuleEntry<[]>;
     /**
      * Prefer using the `String.raw` tag to avoid escaping `\`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-string-raw.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-string-raw.md
      */
     'unicorn/prefer-string-raw'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `String#replaceAll()` over regex searches with the global flag.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-string-replace-all.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-string-replace-all.md
      */
     'unicorn/prefer-string-replace-all'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `String#slice()` over `String#substr()` and `String#substring()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-string-slice.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-string-slice.md
      */
     'unicorn/prefer-string-slice'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `String#startsWith()` & `String#endsWith()` over `RegExp#test()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-string-starts-ends-with.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-string-starts-ends-with.md
      */
     'unicorn/prefer-string-starts-ends-with'?: Linter.RuleEntry<[]>;
     /**
      * Prefer `String#trimStart()` / `String#trimEnd()` over `String#trimLeft()` / `String#trimRight()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-string-trim-start-end.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-string-trim-start-end.md
      */
     'unicorn/prefer-string-trim-start-end'?: Linter.RuleEntry<[]>;
     /**
      * Prefer using `structuredClone` to create a deep clone.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-structured-clone.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-structured-clone.md
      */
     'unicorn/prefer-structured-clone'?: Linter.RuleEntry<UnicornPreferStructuredClone>;
     /**
      * Prefer `switch` over multiple `else-if`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-switch.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-switch.md
      */
     'unicorn/prefer-switch'?: Linter.RuleEntry<UnicornPreferSwitch>;
     /**
      * Prefer ternary expressions over simple `if-else` statements.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-ternary.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-ternary.md
      */
     'unicorn/prefer-ternary'?: Linter.RuleEntry<UnicornPreferTernary>;
     /**
      * Prefer top-level await over top-level promises and async function calls.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-top-level-await.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-top-level-await.md
      */
     'unicorn/prefer-top-level-await'?: Linter.RuleEntry<[]>;
     /**
      * Enforce throwing `TypeError` in type checking conditions.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prefer-type-error.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prefer-type-error.md
      */
     'unicorn/prefer-type-error'?: Linter.RuleEntry<[]>;
     /**
      * Prevent abbreviations.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/prevent-abbreviations.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/prevent-abbreviations.md
      */
     'unicorn/prevent-abbreviations'?: Linter.RuleEntry<UnicornPreventAbbreviations>;
     /**
      * Enforce consistent relative URL style.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/relative-url-style.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/relative-url-style.md
      */
     'unicorn/relative-url-style'?: Linter.RuleEntry<UnicornRelativeUrlStyle>;
     /**
      * Enforce using the separator argument with `Array#join()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/require-array-join-separator.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/require-array-join-separator.md
      */
     'unicorn/require-array-join-separator'?: Linter.RuleEntry<[]>;
     /**
      * Enforce using the digits argument with `Number#toFixed()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/require-number-to-fixed-digits-argument.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/require-number-to-fixed-digits-argument.md
      */
     'unicorn/require-number-to-fixed-digits-argument'?: Linter.RuleEntry<[]>;
     /**
      * Enforce using the `targetOrigin` argument with `window.postMessage()`.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/require-post-message-target-origin.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/require-post-message-target-origin.md
      */
     'unicorn/require-post-message-target-origin'?: Linter.RuleEntry<[]>;
     /**
      * Enforce better string content.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/string-content.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/string-content.md
      */
     'unicorn/string-content'?: Linter.RuleEntry<UnicornStringContent>;
     /**
      * Enforce consistent brace style for `case` clauses.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/switch-case-braces.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/switch-case-braces.md
      */
     'unicorn/switch-case-braces'?: Linter.RuleEntry<UnicornSwitchCaseBraces>;
     /**
      * Fix whitespace-insensitive template indentation.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/template-indent.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/template-indent.md
      */
     'unicorn/template-indent'?: Linter.RuleEntry<UnicornTemplateIndent>;
     /**
      * Enforce consistent case for text encoding identifiers.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/text-encoding-identifier-case.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/text-encoding-identifier-case.md
      */
     'unicorn/text-encoding-identifier-case'?: Linter.RuleEntry<[]>;
     /**
      * Require `new` when creating an error.
-     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v57.0.0/docs/rules/throw-new-error.md
+     * @see https://github.com/sindresorhus/eslint-plugin-unicorn/blob/v58.0.0/docs/rules/throw-new-error.md
      */
     'unicorn/throw-new-error'?: Linter.RuleEntry<[]>;
 }
@@ -10036,6 +11759,7 @@ type UnicornConsistentFunctionScoping = [] | [
         checkArrowFunctions?: boolean;
     }
 ];
+type UnicornEscapeCase = [] | [("uppercase" | "lowercase")];
 type UnicornExpiringTodoComments = [] | [
     {
         terms?: string[];
@@ -10131,6 +11855,11 @@ type UnicornNoUselessUndefined = [] | [
         checkArrowFunctionBody?: boolean;
     }
 ];
+type UnicornNumberLiteralCase = [] | [
+    {
+        hexadecimalValue?: ("uppercase" | "lowercase");
+    }
+];
 type UnicornNumericSeparatorsStyle = [] | [
     {
         binary?: {
@@ -10686,6 +12415,111 @@ type VitestValidTitle = [] | [
 ];
 
 interface VueRules {
+    /**
+     * enforce specific casing for localization keys
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/key-format-style.html
+     */
+    '@intlify/vue-i18n/key-format-style'?: Linter.RuleEntry<IntlifyVueI18NKeyFormatStyle>;
+    /**
+     * disallow using deprecated `<i18n>` components (in Vue I18n 9.0.0+)
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-i18n-component.html
+     */
+    '@intlify/vue-i18n/no-deprecated-i18n-component'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `place` attribute (Removed in Vue I18n 9.0.0+)
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-i18n-place-attr.html
+     */
+    '@intlify/vue-i18n/no-deprecated-i18n-place-attr'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `places` prop (Removed in Vue I18n 9.0.0+)
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-i18n-places-prop.html
+     */
+    '@intlify/vue-i18n/no-deprecated-i18n-places-prop'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce modulo interpolation to be named interpolation
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-modulo-syntax.html
+     */
+    '@intlify/vue-i18n/no-deprecated-modulo-syntax'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `tc` or `$tc` (Deprecated in Vue I18n 10.0.0, removed fully in Vue I18n 11.0.0)
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-tc.html
+     */
+    '@intlify/vue-i18n/no-deprecated-tc'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `v-t` custom directive (Deprecated in Vue I18n 11.0.0, removed fully in Vue I18n 12.0.0)
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-deprecated-v-t.html
+     */
+    '@intlify/vue-i18n/no-deprecated-v-t'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow duplicate localization keys within the same locale
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-duplicate-keys-in-locale.html
+     */
+    '@intlify/vue-i18n/no-duplicate-keys-in-locale'?: Linter.RuleEntry<IntlifyVueI18NNoDuplicateKeysInLocale>;
+    /**
+     * disallow localization dynamic keys at localization methods
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-dynamic-keys.html
+     */
+    '@intlify/vue-i18n/no-dynamic-keys'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow use HTML localization messages
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-html-messages.html
+     */
+    '@intlify/vue-i18n/no-html-messages'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using `path` prop with `<i18n-t>`
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-i18n-t-path-prop.html
+     */
+    '@intlify/vue-i18n/no-i18n-t-path-prop'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow missing locale message key at localization methods
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-missing-keys.html
+     */
+    '@intlify/vue-i18n/no-missing-keys'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow missing locale message keys in other locales
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-missing-keys-in-other-locales.html
+     */
+    '@intlify/vue-i18n/no-missing-keys-in-other-locales'?: Linter.RuleEntry<IntlifyVueI18NNoMissingKeysInOtherLocales>;
+    /**
+     * disallow to string literal in template or JSX
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-raw-text.html
+     */
+    '@intlify/vue-i18n/no-raw-text'?: Linter.RuleEntry<IntlifyVueI18NNoRawText>;
+    /**
+     * disallow unknown locale name
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-unknown-locale.html
+     */
+    '@intlify/vue-i18n/no-unknown-locale'?: Linter.RuleEntry<IntlifyVueI18NNoUnknownLocale>;
+    /**
+     * disallow unused localization keys
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-unused-keys.html
+     */
+    '@intlify/vue-i18n/no-unused-keys'?: Linter.RuleEntry<IntlifyVueI18NNoUnusedKeys>;
+    /**
+     * disallow use of localization methods on v-html to prevent XSS attack
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/no-v-html.html
+     */
+    '@intlify/vue-i18n/no-v-html'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce linked key to be enclosed in parentheses
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/prefer-linked-key-with-paren.html
+     */
+    '@intlify/vue-i18n/prefer-linked-key-with-paren'?: Linter.RuleEntry<[]>;
+    /**
+     * require lang attribute on `<i18n>` block
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/prefer-sfc-lang-attr.html
+     */
+    '@intlify/vue-i18n/prefer-sfc-lang-attr'?: Linter.RuleEntry<[]>;
+    /**
+     * require or disallow the locale attribute on `<i18n>` block
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/sfc-locale-attr.html
+     */
+    '@intlify/vue-i18n/sfc-locale-attr'?: Linter.RuleEntry<IntlifyVueI18NSfcLocaleAttr>;
+    /**
+     * disallow invalid message syntax
+     * @see https://eslint-plugin-vue-i18n.intlify.dev/rules/valid-message-syntax.html
+     */
+    '@intlify/vue-i18n/valid-message-syntax'?: Linter.RuleEntry<IntlifyVueI18NValidMessageSyntax>;
     'vue-composable/composable-placement'?: Linter.RuleEntry<[]>;
     'vue-composable/lifecycle-placement'?: Linter.RuleEntry<[]>;
     /**
@@ -10864,12 +12698,6 @@ interface VueRules {
      * @see https://eslint.vuejs.org/rules/component-options-name-casing.html
      */
     'vue/component-options-name-casing'?: Linter.RuleEntry<VueComponentOptionsNameCasing>;
-    /**
-     * enforce order of component top-level elements
-     * @see https://eslint.vuejs.org/rules/component-tags-order.html
-     * @deprecated
-     */
-    'vue/component-tags-order'?: Linter.RuleEntry<VueComponentTagsOrder>;
     /**
      * enforce specific casing for custom event name
      * @see https://eslint.vuejs.org/rules/custom-event-name-casing.html
@@ -10976,7 +12804,7 @@ interface VueRules {
      */
     'vue/jsx-uses-vars'?: Linter.RuleEntry<[]>;
     /**
-     * Enforce consistent spacing between keys and values in object literal properties in `<template>`
+     * Enforce consistent spacing between property names and type annotations in types and interfaces in `<template>`
      * @see https://eslint.vuejs.org/rules/key-spacing.html
      */
     'vue/key-spacing'?: Linter.RuleEntry<VueKeySpacing>;
@@ -11251,11 +13079,10 @@ interface VueRules {
      */
     'vue/no-implicit-coercion'?: Linter.RuleEntry<VueNoImplicitCoercion>;
     /**
-     * require valid keys in model option
-     * @see https://eslint.vuejs.org/rules/no-invalid-model-keys.html
-     * @deprecated
+     * disallow importing Vue compiler macros
+     * @see https://eslint.vuejs.org/rules/no-import-compiler-macros.html
      */
-    'vue/no-invalid-model-keys'?: Linter.RuleEntry<[]>;
+    'vue/no-import-compiler-macros'?: Linter.RuleEntry<[]>;
     /**
      * disallow irregular whitespace in `.vue` files
      * @see https://eslint.vuejs.org/rules/no-irregular-whitespace.html
@@ -11316,12 +13143,6 @@ interface VueRules {
      * @see https://eslint.vuejs.org/rules/no-ref-as-operand.html
      */
     'vue/no-ref-as-operand'?: Linter.RuleEntry<[]>;
-    /**
-     * disallow usages of ref objects that can lead to loss of reactivity
-     * @see https://eslint.vuejs.org/rules/no-ref-object-destructure.html
-     * @deprecated
-     */
-    'vue/no-ref-object-destructure'?: Linter.RuleEntry<[]>;
     /**
      * disallow usages of ref objects that can lead to loss of reactivity
      * @see https://eslint.vuejs.org/rules/no-ref-object-reactivity-loss.html
@@ -11412,12 +13233,6 @@ interface VueRules {
      * @see https://eslint.vuejs.org/rules/no-root-v-if.html
      */
     'vue/no-root-v-if'?: Linter.RuleEntry<[]>;
-    /**
-     * disallow usages that lose the reactivity of `props` passed to `setup`
-     * @see https://eslint.vuejs.org/rules/no-setup-props-destructure.html
-     * @deprecated
-     */
-    'vue/no-setup-props-destructure'?: Linter.RuleEntry<[]>;
     /**
      * disallow usages that lose the reactivity of `props` passed to `setup`
      * @see https://eslint.vuejs.org/rules/no-setup-props-reactivity-loss.html
@@ -11551,6 +13366,7 @@ interface VueRules {
     /**
      * disallow `key` attribute on `<template v-for>`
      * @see https://eslint.vuejs.org/rules/no-v-for-template-key.html
+     * @deprecated
      */
     'vue/no-v-for-template-key'?: Linter.RuleEntry<[]>;
     /**
@@ -11566,6 +13382,7 @@ interface VueRules {
     /**
      * disallow adding an argument to `v-model` used in custom component
      * @see https://eslint.vuejs.org/rules/no-v-model-argument.html
+     * @deprecated
      */
     'vue/no-v-model-argument'?: Linter.RuleEntry<[]>;
     /**
@@ -11674,7 +13491,7 @@ interface VueRules {
      */
     'vue/prop-name-casing'?: Linter.RuleEntry<VuePropNameCasing>;
     /**
-     * Require quotes around object literal property names in `<template>`
+     * Require quotes around object literal, type literal, interfaces and enums property names in `<template>`
      * @see https://eslint.vuejs.org/rules/quote-props.html
      */
     'vue/quote-props'?: Linter.RuleEntry<VueQuoteProps>;
@@ -11798,12 +13615,6 @@ interface VueRules {
      * @see https://eslint.vuejs.org/rules/script-indent.html
      */
     'vue/script-indent'?: Linter.RuleEntry<VueScriptIndent>;
-    /**
-     * prevent `<script setup>` variables used in `<template>` to be marked as unused
-     * @see https://eslint.vuejs.org/rules/script-setup-uses-vars.html
-     * @deprecated
-     */
-    'vue/script-setup-uses-vars'?: Linter.RuleEntry<[]>;
     /**
      * require a line break before and after the contents of a singleline element
      * @see https://eslint.vuejs.org/rules/singleline-html-element-content-newline.html
@@ -11874,12 +13685,6 @@ interface VueRules {
      * @see https://eslint.vuejs.org/rules/v-on-event-hyphenation.html
      */
     'vue/v-on-event-hyphenation'?: Linter.RuleEntry<VueVOnEventHyphenation>;
-    /**
-     * enforce or forbid parentheses after method calls without arguments in `v-on` directives
-     * @see https://eslint.vuejs.org/rules/v-on-function-call.html
-     * @deprecated
-     */
-    'vue/v-on-function-call'?: Linter.RuleEntry<VueVOnFunctionCall>;
     /**
      * enforce writing style for handlers in `v-on` directives
      * @see https://eslint.vuejs.org/rules/v-on-handler-style.html
@@ -11918,6 +13723,7 @@ interface VueRules {
     /**
      * require valid keys in model option
      * @see https://eslint.vuejs.org/rules/valid-model-definition.html
+     * @deprecated
      */
     'vue/valid-model-definition'?: Linter.RuleEntry<[]>;
     /**
@@ -11938,6 +13744,7 @@ interface VueRules {
     /**
      * enforce valid `.sync` modifier on `v-bind` directives
      * @see https://eslint.vuejs.org/rules/valid-v-bind-sync.html
+     * @deprecated
      */
     'vue/valid-v-bind-sync'?: Linter.RuleEntry<[]>;
     /**
@@ -12109,6 +13916,54 @@ interface VueRules {
      */
     'vuejs-accessibility/tabindex-no-positive'?: Linter.RuleEntry<[]>;
 }
+type IntlifyVueI18NKeyFormatStyle = [] | [("camelCase" | "kebab-case" | "lowercase" | "snake_case" | "SCREAMING_SNAKE_CASE")] | [
+    ("camelCase" | "kebab-case" | "lowercase" | "snake_case" | "SCREAMING_SNAKE_CASE"),
+    {
+        allowArray?: boolean;
+        splitByDots?: boolean;
+    }
+];
+type IntlifyVueI18NNoDuplicateKeysInLocale = [] | [
+    {
+        ignoreI18nBlock?: boolean;
+    }
+];
+type IntlifyVueI18NNoMissingKeysInOtherLocales = [] | [
+    {
+        ignoreLocales?: string[];
+    }
+];
+type IntlifyVueI18NNoRawText = [] | [
+    {
+        attributes?: {
+            [k: string]: string[];
+        };
+        ignoreNodes?: unknown[];
+        ignorePattern?: string;
+        ignoreText?: unknown[];
+        [k: string]: unknown | undefined;
+    }
+];
+type IntlifyVueI18NNoUnknownLocale = [] | [
+    {
+        locales?: string[];
+        disableRFC5646?: boolean;
+    }
+];
+type IntlifyVueI18NNoUnusedKeys = [] | [
+    {
+        src?: string;
+        extensions?: string[];
+        ignores?: string[];
+        enableFix?: boolean;
+    }
+];
+type IntlifyVueI18NSfcLocaleAttr = [] | [("always" | "never")];
+type IntlifyVueI18NValidMessageSyntax = [] | [
+    {
+        allowNotString?: boolean;
+    }
+];
 type VueScopedCssEnforceStyleType = [] | [
     {
         allows?: [("plain" | "scoped" | "module"), ...(("plain" | "scoped" | "module"))[]];
@@ -12158,6 +14013,7 @@ type VueArrayElementNewline = [] | [
     })
 ];
 type _VueArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
+    consistent?: boolean;
     multiline?: boolean;
     minItems?: (number | null);
 });
@@ -12234,10 +14090,15 @@ type VueCommaDangle = [] | [
         imports?: _VueCommaDangleValueWithIgnore;
         exports?: _VueCommaDangleValueWithIgnore;
         functions?: _VueCommaDangleValueWithIgnore;
+        importAttributes?: _VueCommaDangleValueWithIgnore;
+        dynamicImports?: _VueCommaDangleValueWithIgnore;
+        enums?: _VueCommaDangleValueWithIgnore;
+        generics?: _VueCommaDangleValueWithIgnore;
+        tuples?: _VueCommaDangleValueWithIgnore;
     })
 ];
 type _VueCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline");
-type _VueCommaDangleValueWithIgnore = ("always-multiline" | "always" | "ignore" | "never" | "only-multiline");
+type _VueCommaDangleValueWithIgnore = ("always-multiline" | "always" | "never" | "only-multiline" | "ignore");
 type VueCommaSpacing = [] | [
     {
         before?: boolean;
@@ -12268,21 +14129,12 @@ type VueComponentNameInTemplateCasing = [] | [("PascalCase" | "kebab-case")] | [
     }
 ];
 type VueComponentOptionsNameCasing = [] | [("camelCase" | "kebab-case" | "PascalCase")];
-type VueComponentTagsOrder = [] | [
-    {
-        order?: (string | string[])[];
-    }
-];
-type VueCustomEventNameCasing = ([] | [("kebab-case" | "camelCase")] | [
+type VueCustomEventNameCasing = [] | [("kebab-case" | "camelCase")] | [
     ("kebab-case" | "camelCase"),
     {
         ignores?: string[];
     }
-] | [] | [
-    {
-        ignores?: string[];
-    }
-]);
+];
 type VueDefineEmitsDeclaration = [] | [("type-based" | "type-literal" | "runtime")];
 type VueDefineMacrosOrder = [] | [
     {
@@ -12319,6 +14171,10 @@ type VueFuncCallSpacing = ([] | ["never"] | [] | ["always"] | [
     "always",
     {
         allowNewlines?: boolean;
+        optionalChain?: {
+            before?: boolean;
+            after?: boolean;
+        };
     }
 ]);
 type VueHtmlButtonHasType = [] | [
@@ -12414,6 +14270,7 @@ type VueKeySpacing = [] | [
         mode?: ("strict" | "minimum");
         beforeColon?: boolean;
         afterColon?: boolean;
+        ignoredNodes?: ("ObjectExpression" | "ObjectPattern" | "ImportDeclaration" | "ExportNamedDeclaration" | "ExportAllDeclaration" | "TSTypeLiteral" | "TSInterfaceBody" | "ClassBody")[];
     } | {
         singleLine?: {
             mode?: ("strict" | "minimum");
@@ -12651,6 +14508,10 @@ type VueKeywordSpacing = [] | [
                 before?: boolean;
                 after?: boolean;
             };
+            satisfies?: {
+                before?: boolean;
+                after?: boolean;
+            };
             set?: {
                 before?: boolean;
                 after?: boolean;
@@ -12727,6 +14588,10 @@ type VueKeywordSpacing = [] | [
                 before?: boolean;
                 after?: boolean;
             };
+            type?: {
+                before?: boolean;
+                after?: boolean;
+            };
         };
     }
 ];
@@ -12870,7 +14735,13 @@ type VueMultilineHtmlElementContentNewline = [] | [
         allowEmptyLines?: boolean;
     }
 ];
-type VueMultilineTernary = [] | [("always" | "always-multiline" | "never")];
+type VueMultilineTernary = [] | [("always" | "always-multiline" | "never")] | [
+    ("always" | "always-multiline" | "never"),
+    {
+        ignoreJSX?: boolean;
+        [k: string]: unknown | undefined;
+    }
+];
 type VueMustacheInterpolationSpacing = [] | [("always" | "never")];
 type VueNewLineBetweenMultiLineProperty = [] | [
     {
@@ -12952,6 +14823,7 @@ type VueNoExtraParens = ([] | ["functions"] | [] | ["all"] | [
         enforceForNewInMemberExpressions?: boolean;
         enforceForFunctionPrototypeMethods?: boolean;
         allowParensAfterCommentPattern?: string;
+        nestedConditionalExpressions?: boolean;
     }
 ]);
 type VueNoImplicitCoercion = [] | [
@@ -13212,6 +15084,16 @@ type VueObjectCurlyNewline = [] | [
             minProperties?: number;
             consistent?: boolean;
         });
+        TSTypeLiteral?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        TSInterfaceBody?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
     })
 ];
 type VueObjectCurlySpacing = [] | [("always" | "never")] | [
@@ -13241,8 +15123,8 @@ type VueObjectShorthand = ([] | [("always" | "methods" | "properties" | "never"
         avoidExplicitReturnArrows?: boolean;
     }
 ]);
-type VueOperatorLinebreak = [] | [("after" | "before" | "none" | null)] | [
-    ("after" | "before" | "none" | null),
+type VueOperatorLinebreak = [] | [(("after" | "before" | "none") | null)] | [
+    (("after" | "before" | "none") | null),
     {
         overrides?: {
             [k: string]: ("after" | "before" | "none" | "ignore") | undefined;
@@ -13274,7 +15156,12 @@ type VuePaddingLinesInComponentDefinition = [] | [
         groupSingleLineProperties?: boolean;
     })
 ];
-type VuePreferTrueAttributeShorthand = [] | [("always" | "never")];
+type VuePreferTrueAttributeShorthand = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        except?: string[];
+    }
+];
 type VuePropNameCasing = [] | [("camelCase" | "snake_case")] | [
     ("camelCase" | "snake_case"),
     {
@@ -13357,7 +15244,6 @@ type VueSortKeys = [] | [("asc" | "desc")] | [
         ignoreGrandchildrenOf?: unknown[];
         minKeys?: number;
         natural?: boolean;
-        runOutsideVue?: boolean;
     }
 ];
 type VueSpaceInParens = [] | [("always" | "never")] | [
@@ -13369,6 +15255,7 @@ type VueSpaceInParens = [] | [("always" | "never")] | [
 type VueSpaceInfixOps = [] | [
     {
         int32Hint?: boolean;
+        ignoreTypes?: boolean;
     }
 ];
 type VueSpaceUnaryOps = [] | [
@@ -13401,12 +15288,6 @@ type VueVOnEventHyphenation = [] | [("always" | "never")] | [
         ignoreTags?: string[];
     }
 ];
-type VueVOnFunctionCall = [] | [("always" | "never")] | [
-    ("always" | "never"),
-    {
-        ignoreIncludesComment?: boolean;
-    }
-];
 type VueVOnHandlerStyle = [] | [(("inline" | "inline-function") | ["method", ("inline" | "inline-function")])] | [
     (("inline" | "inline-function") | ["method", ("inline" | "inline-function")]),
     {
@@ -13893,7 +15774,7 @@ type YmlSpacedComment = [] | [("always" | "never")] | [
 
 declare module 'eslint' {
     namespace Linter {
-        interface RulesRecord extends CommentsRules, CssRules, ImportsRules, JavascriptRules, JsdocRules, JsoncRules, MarkdownRules, PrettierRules, PromiseRules, ReactRules, RegexpRules, SvelteRules, TomlRules, TypescriptRules, UnicornRules, VitestRules, VueRules, YmlRules {
+        interface RulesRecord extends CommentsRules, CssRules, ImportsRules, JavascriptRules, JsdocRules, JsoncRules, MarkdownRules, PrettierRules, PromiseRules, ReactRules, RegexpRules, StylisticRules, SvelteRules, TomlRules, TypescriptRules, UnicornRules, VitestRules, VueRules, YmlRules {
         }
     }
 }
@@ -13927,6 +15808,10 @@ interface CssOptions {
      * @description if 'tailwind', it will enable [Tailwind Syntax](https://github.com/eslint/css?tab=readme-ov-file#configuring-tailwind-syntax), otherwise it will enable [custom syntax](https://github.com/eslint/css?tab=readme-ov-file#configuring-custom-syntax)
      * @default false
      */
+    /**
+     * TODO: If this issue is resolved, we should define more strict types for customSyntax
+     * https://github.com/eslint/css/issues/56
+     */
     customSyntax?: false | 'tailwind' | Record<string, any>;
 }
 /**
@@ -13955,7 +15840,7 @@ interface ImportsOptions {
 }
 /**
  * `eslint-plugin-import-x`, `eslint-plugin-unused-imports` and overrides configuration options
- * @description **if you want to use this preset, you need to put after `javascirpt` and `typescript` presets**
+ * @description if you want to use this preset, you need to put after `javascript` and `typescript` presets**
  * @param {ImportsOptions & OverridesOptions} options
  *  import configuration options
  * @returns {Promise<Linter.Config[]>}
@@ -13970,10 +15855,8 @@ interface JavaScriptOptions {
 }
 /**
  * `@eslint/js` and overrides configuration options
- * @param {JavaScriptOptions & OverridesOptions} options
- * eslint configuration options for JavaScript
- * @returns {Promise<Linter.Config[]>}
- * eslint flat configurations with `@eslint/js` and overrides
+ * @param {JavaScriptOptions & OverridesOptions} options eslint configuration options for JavaScript
+ * @returns {Promise<Linter.Config[]>} eslint flat configurations with `@eslint/js` and overrides
  */
 declare function javascript(options?: JavaScriptOptions & OverridesOptions<JavascriptRules>): Promise<Linter.Config[]>;
 
@@ -14196,6 +16079,25 @@ interface RegexpOptions {
  */
 declare function regexp(options?: RegexpOptions & OverridesOptions<RegexpRules>): Promise<Linter.Config[]>;
 
+/**
+ * stylistic eslint plugin configuration options
+ */
+interface StylisticOptions {
+    /**
+     * stylistic customize options
+     * @see https://eslint.style/guide/config-presets#configuration-factory
+     */
+    customize?: StylisticCustomizeOptions;
+}
+/**
+ * `@stylistic/eslint-plugin` and overrides configuration options
+ * @param {StylisticOptions & OverridesOptions} options
+ *  stylistic eslint plugin configuration options
+ * @returns {Promise<Linter.Config[]>}
+ *  eslint flat configurations with `@stylistic/eslint-plugin` and overrides
+ */
+declare function stylistic(options?: StylisticOptions & OverridesOptions<StylisticRules>): Promise<Linter.Config[]>;
+
 /**
  * Svelte configuration options
  */
@@ -14293,6 +16195,20 @@ interface VueScriptOptions {
      * @default false
      */
     a11y?: boolean;
+    /**
+     * enable `@intlify/eslint-plugin-vue-i18n` rules
+     * @default false
+     */
+    i18n?: VueI18nOptions;
+}
+/**
+ * `@intlify/eslint-plugin-vue-i18n` configuration options.
+ * same `settings['vue-i18n']`
+ * see https://eslint-plugin-vue-i18n.intlify.dev/started.html#settings-vue-i18n
+ */
+interface VueI18nOptions {
+    localeDir?: string;
+    messageSyntaxVersion?: string;
 }
 /**
  * `eslint-plugin-vue`, `eslint-plugin-vue-composable`, `eslint-plugin-vue-eslint-plugin-vuejs-accessibility` and overrides configuration options
@@ -14324,4 +16240,4 @@ interface YmlOptions {
 declare function yml(options?: YmlOptions & OverridesOptions<YmlRules>): Promise<Linter.Config[]>;
 declare const yaml: typeof yml;
 
-export { type CommentsOptions, type CommentsRules, type CssOptions, type CssRules, type ImportsOptions, type ImportsRules, type JavaScriptOptions, type JavascriptRules, type JsDocumentOptions, type JsdocRules, type JsoncOptions, type JsoncRules, type MarkdownOptions, type MarkdownRules, type OverridesOptions, type PrettierOptions, type PrettierRules, type PromiseOptions, type PromiseRules, type ReactOptions, type ReactRules, type RegexpOptions, type RegexpRules, type SvelteRules, type SvelteScriptOptions, type TomlOptions, type TomlRules, type TypeScriptOptions, type TypeScriptParserOptions, type TypeScriptProjectServiceOptions, type TypescriptRules, type UnicornOptions, type UnicornRules, type VitestOptions, type VitestRules, type VueRules, type VueScriptOptions, type YmlOptions, type YmlRules, comments, css, defineConfig, imports, javascript, jsdoc, jsonc, markdown, md, prettier, promise, react, regexp, svelte, toml, typescript, unicorn, vitest, vue, yaml, yml };
+export { type CommentsOptions, type CommentsRules, type CssOptions, type CssRules, type ImportsOptions, type ImportsRules, type JavaScriptOptions, type JavascriptRules, type JsDocumentOptions, type JsdocRules, type JsoncOptions, type JsoncRules, type MarkdownOptions, type MarkdownRules, type OverridesOptions, type PrettierOptions, type PrettierRules, type PromiseOptions, type PromiseRules, type ReactOptions, type ReactRules, type RegexpOptions, type RegexpRules, type StylisticOptions, type StylisticRules, type SvelteRules, type SvelteScriptOptions, type TomlOptions, type TomlRules, type TypeScriptOptions, type TypeScriptParserOptions, type TypeScriptProjectServiceOptions, type TypescriptRules, type UnicornOptions, type UnicornRules, type VitestOptions, type VitestRules, type VueI18nOptions, type VueRules, type VueScriptOptions, type YmlOptions, type YmlRules, comments, css, defineConfig, imports, javascript, jsdoc, jsonc, markdown, md, prettier, promise, react, regexp, stylistic, svelte, toml, typescript, unicorn, vitest, vue, yaml, yml };