@2digits/eslint-config 4.6.6 → 4.6.7

package/dist/index.d.mts

@@ -5317,483 +5317,478 @@ interface RuleOptions {
   'strict'?: Linter.RuleEntry<Strict>;
   /**
    * Enforce linebreaks after opening and before closing array brackets
-   * @see https://eslint.style/rules/js/array-bracket-newline
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/array-element-newline
    */
   'stylistic/array-element-newline'?: Linter.RuleEntry<StylisticArrayElementNewline>;
   /**
    * Require parentheses around arrow function arguments
-   * @see https://eslint.style/rules/js/arrow-parens
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/block-spacing
    */
   'stylistic/block-spacing'?: Linter.RuleEntry<StylisticBlockSpacing>;
   /**
    * Enforce consistent brace style for blocks
-   * @see https://eslint.style/rules/ts/brace-style
+   * @see https://eslint.style/rules/brace-style
    */
   'stylistic/brace-style'?: Linter.RuleEntry<StylisticBraceStyle>;
   /**
    * Require or disallow trailing commas
-   * @see https://eslint.style/rules/ts/comma-dangle
+   * @see https://eslint.style/rules/comma-dangle
    */
   'stylistic/comma-dangle'?: Linter.RuleEntry<StylisticCommaDangle>;
   /**
    * Enforce consistent spacing before and after commas
-   * @see https://eslint.style/rules/ts/comma-spacing
+   * @see https://eslint.style/rules/comma-spacing
    */
   'stylistic/comma-spacing'?: Linter.RuleEntry<StylisticCommaSpacing>;
   /**
    * Enforce consistent comma style
-   * @see https://eslint.style/rules/js/comma-style
+   * @see https://eslint.style/rules/comma-style
    */
   'stylistic/comma-style'?: Linter.RuleEntry<StylisticCommaStyle>;
   /**
    * Enforce consistent spacing inside computed property brackets
-   * @see https://eslint.style/rules/js/computed-property-spacing
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/curly-newline
    */
   'stylistic/curly-newline'?: Linter.RuleEntry<StylisticCurlyNewline>;
   /**
    * Enforce consistent newlines before and after dots
-   * @see https://eslint.style/rules/js/dot-location
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/implicit-arrow-linebreak
    */
   'stylistic/implicit-arrow-linebreak'?: Linter.RuleEntry<StylisticImplicitArrowLinebreak>;
   /**
    * Enforce consistent indentation
-   * @see https://eslint.style/rules/ts/indent
+   * @see https://eslint.style/rules/indent
    */
   'stylistic/indent'?: Linter.RuleEntry<StylisticIndent>;
   /**
    * Indentation for binary operators
-   * @see https://eslint.style/rules/plus/indent-binary-ops
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/jsx-indent
    * @deprecated
    */
   'stylistic/jsx-indent'?: Linter.RuleEntry<StylisticJsxIndent>;
   /**
    * Enforce props indentation in JSX
-   * @see https://eslint.style/rules/jsx/jsx-indent-props
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/key-spacing
    */
   'stylistic/key-spacing'?: Linter.RuleEntry<StylisticKeySpacing>;
   /**
    * Enforce consistent spacing before and after keywords
-   * @see https://eslint.style/rules/ts/keyword-spacing
+   * @see https://eslint.style/rules/keyword-spacing
    */
   'stylistic/keyword-spacing'?: Linter.RuleEntry<StylisticKeywordSpacing>;
   /**
    * Enforce position of line comments
-   * @see https://eslint.style/rules/js/line-comment-position
+   * @see https://eslint.style/rules/line-comment-position
    */
   'stylistic/line-comment-position'?: Linter.RuleEntry<StylisticLineCommentPosition>;
   /**
    * Enforce consistent linebreak style
-   * @see https://eslint.style/rules/js/linebreak-style
+   * @see https://eslint.style/rules/linebreak-style
    */
   'stylistic/linebreak-style'?: Linter.RuleEntry<StylisticLinebreakStyle>;
   /**
    * Require empty lines around comments
-   * @see https://eslint.style/rules/ts/lines-around-comment
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/no-confusing-arrow
    */
   'stylistic/no-confusing-arrow'?: Linter.RuleEntry<StylisticNoConfusingArrow>;
   /**
    * Disallow unnecessary parentheses
-   * @see https://eslint.style/rules/ts/no-extra-parens
+   * @see https://eslint.style/rules/no-extra-parens
    */
   'stylistic/no-extra-parens'?: Linter.RuleEntry<StylisticNoExtraParens>;
   /**
    * Disallow unnecessary semicolons
-   * @see https://eslint.style/rules/ts/no-extra-semi
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/no-floating-decimal
    */
   'stylistic/no-floating-decimal'?: Linter.RuleEntry<[]>;
   /**
    * Disallow mixed binary operators
-   * @see https://eslint.style/rules/js/no-mixed-operators
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/no-multi-spaces
    */
   'stylistic/no-multi-spaces'?: Linter.RuleEntry<StylisticNoMultiSpaces>;
   /**
    * Disallow multiple empty lines
-   * @see https://eslint.style/rules/js/no-multiple-empty-lines
+   * @see https://eslint.style/rules/no-multiple-empty-lines
    */
   'stylistic/no-multiple-empty-lines'?: Linter.RuleEntry<StylisticNoMultipleEmptyLines>;
   /**
    * Disallow all tabs
-   * @see https://eslint.style/rules/js/no-tabs
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/no-trailing-spaces
    */
   'stylistic/no-trailing-spaces'?: Linter.RuleEntry<StylisticNoTrailingSpaces>;
   /**
    * Disallow whitespace before properties
-   * @see https://eslint.style/rules/js/no-whitespace-before-property
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/object-curly-newline
    */
   'stylistic/object-curly-newline'?: Linter.RuleEntry<StylisticObjectCurlyNewline>;
   /**
    * Enforce consistent spacing inside braces
-   * @see https://eslint.style/rules/ts/object-curly-spacing
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/operator-linebreak
    */
   'stylistic/operator-linebreak'?: Linter.RuleEntry<StylisticOperatorLinebreak>;
   /**
    * Require or disallow padding within blocks
-   * @see https://eslint.style/rules/js/padded-blocks
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/rest-spread-spacing
    */
   'stylistic/rest-spread-spacing'?: Linter.RuleEntry<StylisticRestSpreadSpacing>;
   /**
    * Require or disallow semicolons instead of ASI
-   * @see https://eslint.style/rules/ts/semi
+   * @see https://eslint.style/rules/semi
    */
   'stylistic/semi'?: Linter.RuleEntry<StylisticSemi>;
   /**
    * Enforce consistent spacing before and after semicolons
-   * @see https://eslint.style/rules/ts/semi-spacing
+   * @see https://eslint.style/rules/semi-spacing
    */
   'stylistic/semi-spacing'?: Linter.RuleEntry<StylisticSemiSpacing>;
   /**
    * Enforce location of semicolons
-   * @see https://eslint.style/rules/js/semi-style
+   * @see https://eslint.style/rules/semi-style
    */
   'stylistic/semi-style'?: Linter.RuleEntry<StylisticSemiStyle>;
   /**
    * Enforce consistent spacing before blocks
-   * @see https://eslint.style/rules/ts/space-before-blocks
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/space-in-parens
    */
   'stylistic/space-in-parens'?: Linter.RuleEntry<StylisticSpaceInParens>;
   /**
    * Require spacing around infix operators
-   * @see https://eslint.style/rules/ts/space-infix-ops
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/spaced-comment
    */
   'stylistic/spaced-comment'?: Linter.RuleEntry<StylisticSpacedComment>;
   /**
    * Enforce spacing around colons of switch statements
-   * @see https://eslint.style/rules/js/switch-colon-spacing
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/wrap-iife
    */
   'stylistic/wrap-iife'?: Linter.RuleEntry<StylisticWrapIife>;
   /**
    * Require parenthesis around regex literals
-   * @see https://eslint.style/rules/js/wrap-regex
+   * @see https://eslint.style/rules/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
+   * @see https://eslint.style/rules/yield-star-spacing
    */
   'stylistic/yield-star-spacing'?: Linter.RuleEntry<StylisticYieldStarSpacing>;
   /**
@@ -10550,16 +10545,6 @@ type StylisticCurlyNewline = [] | [(("always" | "never") | {
     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;
@@ -10573,14 +10558,6 @@ type StylisticCurlyNewline = [] | [(("always" | "never") | {
 type StylisticDotLocation = [] | [("object" | "property")];
 // ----- stylistic/eol-last -----
 type StylisticEolLast = [] | [("always" | "never" | "unix" | "windows")];
-// ----- stylistic/func-call-spacing -----
-type StylisticFuncCallSpacing = ([] | ["never"] | [] | ["always"] | ["always", {
-  allowNewlines?: boolean;
-  optionalChain?: {
-    before?: boolean;
-    after?: boolean;
-  };
-}]);
 // ----- stylistic/function-call-argument-newline -----
 type StylisticFunctionCallArgumentNewline = [] | [("always" | "never" | "consistent")];
 // ----- stylistic/function-call-spacing -----
@@ -10621,6 +10598,7 @@ type StylisticIndent = [] | [("tab" | number)] | [("tab" | number), {
     var?: (number | ("first" | "off"));
     let?: (number | ("first" | "off"));
     const?: (number | ("first" | "off"));
+    using?: (number | ("first" | "off"));
   });
   outerIIFEBody?: (number | "off");
   MemberExpression?: (number | "off");
@@ -10755,8 +10733,8 @@ type StylisticJsxSortProps = [] | [{
   multiline?: ("ignore" | "first" | "last");
   ignoreCase?: boolean;
   noSortAlphabetically?: boolean;
-  reservedFirst?: (unknown[] | boolean);
-  reservedLast?: unknown[];
+  reservedFirst?: (string[] | boolean);
+  reservedLast?: string[];
   locale?: string;
 }];
 // ----- stylistic/jsx-tag-spacing -----
@@ -11101,6 +11079,10 @@ type StylisticKeywordSpacing = [] | [{
       before?: boolean;
       after?: boolean;
     };
+    using?: {
+      before?: boolean;
+      after?: boolean;
+    };
     yield?: {
       before?: boolean;
       after?: boolean;
@@ -11303,6 +11285,11 @@ type StylisticNoExtraParens = ([] | ["functions"] | [] | ["all"] | ["all", {
   enforceForFunctionPrototypeMethods?: boolean;
   allowParensAfterCommentPattern?: string;
   nestedConditionalExpressions?: boolean;
+  allowNodesInSpreadElement?: {
+    ConditionalExpression?: boolean;
+    LogicalExpression?: boolean;
+    AwaitExpression?: boolean;
+  };
 }]);
 // ----- stylistic/no-mixed-operators -----
 type StylisticNoMixedOperators = [] | [{
@@ -11380,6 +11367,11 @@ type StylisticObjectCurlyNewline = [] | [((("always" | "never") | {
     minProperties?: number;
     consistent?: boolean;
   });
+  TSEnumBody?: (("always" | "never") | {
+    multiline?: boolean;
+    minProperties?: number;
+    consistent?: boolean;
+  });
 })];
 // ----- stylistic/object-curly-spacing -----
 type StylisticObjectCurlySpacing = [] | [("always" | "never")] | [("always" | "never"), {
@@ -11389,7 +11381,6 @@ type StylisticObjectCurlySpacing = [] | [("always" | "never")] | [("always" | "n
 // ----- stylistic/object-property-newline -----
 type StylisticObjectPropertyNewline = [] | [{
   allowAllPropertiesOnSameLine?: boolean;
-  allowMultiplePropertiesPerLine?: boolean;
 }];
 // ----- stylistic/one-var-declaration-per-line -----
 type StylisticOneVarDeclarationPerLine = [] | [("always" | "initializations")];
@@ -11413,7 +11404,7 @@ type StylisticPaddedBlocks = [] | [(("always" | "never" | "start" | "end") | {
 }];
 // ----- stylistic/padding-line-between-statements -----
 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 _StylisticPaddingLineBetweenStatementsStatementType = (("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-using" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-using" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "using" | "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-using" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-using" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "using" | "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-using" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-using" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "using" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload"))[]]);
 type StylisticPaddingLineBetweenStatements = {
   blankLine: _StylisticPaddingLineBetweenStatementsPaddingType;
   prev: _StylisticPaddingLineBetweenStatementsStatementType;
@@ -11452,12 +11443,14 @@ type StylisticSpaceBeforeBlocks = [] | [(("always" | "never") | {
   keywords?: ("always" | "never" | "off");
   functions?: ("always" | "never" | "off");
   classes?: ("always" | "never" | "off");
+  modules?: ("always" | "never" | "off");
 })];
 // ----- stylistic/space-before-function-paren -----
 type StylisticSpaceBeforeFunctionParen = [] | [(("always" | "never") | {
   anonymous?: ("always" | "never" | "ignore");
   named?: ("always" | "never" | "ignore");
   asyncArrow?: ("always" | "never" | "ignore");
+  catch?: ("always" | "never" | "ignore");
 })];
 // ----- stylistic/space-in-parens -----
 type StylisticSpaceInParens = [] | [("always" | "never")] | [("always" | "never"), {
@@ -12077,6 +12070,7 @@ interface _TsNamingConvention_MatchRegexConfig {
 }
 // ----- ts/no-base-to-string -----
 type TsNoBaseToString = [] | [{
+  checkUnknown?: boolean;
   ignoredTypeNames?: string[];
 }];
 // ----- ts/no-confusing-void-expression -----

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2digits/eslint-config",
-  "version": "4.6.6",
+  "version": "4.6.7",
   "description": "Effortlessly enforce best practices and catch errors with this comprehensive ESLint configuration for TypeScript, featuring popular plugins like @typescript-eslint, eslint-plugin-react, and eslint-plugin-unicorn.",
   "homepage": "https://2d-configs.vercel.app/",
   "repository": {
@@ -34,10 +34,10 @@
     "@eslint/markdown": "6.6.0",
     "@graphql-eslint/eslint-plugin": "4.4.0",
     "@next/eslint-plugin-next": "15.3.4",
-    "@stylistic/eslint-plugin": "4.4.1",
-    "@tanstack/eslint-plugin-query": "5.81.0",
-    "@typescript-eslint/parser": "8.34.1",
-    "@typescript-eslint/utils": "8.34.1",
+    "@stylistic/eslint-plugin": "5.0.0",
+    "@tanstack/eslint-plugin-query": "5.81.2",
+    "@typescript-eslint/parser": "8.35.0",
+    "@typescript-eslint/utils": "8.35.0",
     "eslint-config-flat-gitignore": "2.1.0",
     "eslint-config-prettier": "10.1.5",
     "eslint-flat-config-utils": "2.1.0",
@@ -45,7 +45,7 @@
     "eslint-plugin-antfu": "3.1.1",
     "eslint-plugin-de-morgan": "1.3.0",
     "eslint-plugin-drizzle": "0.2.3",
-    "eslint-plugin-jsdoc": "51.1.1",
+    "eslint-plugin-jsdoc": "51.2.2",
     "eslint-plugin-jsonc": "2.20.1",
     "eslint-plugin-n": "17.20.0",
     "eslint-plugin-pnpm": "0.3.1",
@@ -63,10 +63,10 @@
     "graphql-config": "5.1.5",
     "jsonc-eslint-parser": "2.4.0",
     "local-pkg": "1.1.1",
-    "typescript-eslint": "8.34.1",
+    "typescript-eslint": "8.35.0",
     "yaml-eslint-parser": "1.3.0",
     "@2digits/constants": "1.1.2",
-    "@2digits/eslint-plugin": "3.1.4"
+    "@2digits/eslint-plugin": "3.1.5"
   },
   "devDependencies": {
     "@eslint/config-inspector": "1.1.0",