@bfra.me/eslint-config 0.2.0 → 0.3.0

package/src/types.ts

@@ -646,11 +646,180 @@ export interface Rules {
    * @see https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable
    */
   '@typescript-eslint/use-unknown-in-catch-callback-variable'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce getter and setter pairs in objects and classes
+   * @see https://eslint.org/docs/latest/rules/accessor-pairs
+   */
+  'accessor-pairs'?: Linter.RuleEntry<AccessorPairs>
+  /**
+   * Enforce linebreaks after opening and before closing array brackets
+   * @see https://eslint.org/docs/latest/rules/array-bracket-newline
+   * @deprecated
+   */
+  'array-bracket-newline'?: Linter.RuleEntry<ArrayBracketNewline>
+  /**
+   * Enforce consistent spacing inside array brackets
+   * @see https://eslint.org/docs/latest/rules/array-bracket-spacing
+   * @deprecated
+   */
+  'array-bracket-spacing'?: Linter.RuleEntry<ArrayBracketSpacing>
+  /**
+   * Enforce `return` statements in callbacks of array methods
+   * @see https://eslint.org/docs/latest/rules/array-callback-return
+   */
+  'array-callback-return'?: Linter.RuleEntry<ArrayCallbackReturn>
+  /**
+   * Enforce line breaks after each array element
+   * @see https://eslint.org/docs/latest/rules/array-element-newline
+   * @deprecated
+   */
+  'array-element-newline'?: Linter.RuleEntry<ArrayElementNewline>
+  /**
+   * Require braces around arrow function bodies
+   * @see https://eslint.org/docs/latest/rules/arrow-body-style
+   */
+  'arrow-body-style'?: Linter.RuleEntry<ArrowBodyStyle>
+  /**
+   * Require parentheses around arrow function arguments
+   * @see https://eslint.org/docs/latest/rules/arrow-parens
+   * @deprecated
+   */
+  'arrow-parens'?: Linter.RuleEntry<ArrowParens>
+  /**
+   * Enforce consistent spacing before and after the arrow in arrow functions
+   * @see https://eslint.org/docs/latest/rules/arrow-spacing
+   * @deprecated
+   */
+  'arrow-spacing'?: Linter.RuleEntry<ArrowSpacing>
+  /**
+   * Enforce the use of variables within the scope they are defined
+   * @see https://eslint.org/docs/latest/rules/block-scoped-var
+   */
+  'block-scoped-var'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow or enforce spaces inside of blocks after opening block and before closing block
+   * @see https://eslint.org/docs/latest/rules/block-spacing
+   * @deprecated
+   */
+  'block-spacing'?: Linter.RuleEntry<BlockSpacing>
+  /**
+   * Enforce consistent brace style for blocks
+   * @see https://eslint.org/docs/latest/rules/brace-style
+   * @deprecated
+   */
+  'brace-style'?: Linter.RuleEntry<BraceStyle>
+  /**
+   * Require `return` statements after callbacks
+   * @see https://eslint.org/docs/latest/rules/callback-return
+   * @deprecated
+   */
+  'callback-return'?: Linter.RuleEntry<CallbackReturn>
+  /**
+   * Enforce camelcase naming convention
+   * @see https://eslint.org/docs/latest/rules/camelcase
+   */
+  'camelcase'?: Linter.RuleEntry<Camelcase>
+  /**
+   * Enforce or disallow capitalization of the first letter of a comment
+   * @see https://eslint.org/docs/latest/rules/capitalized-comments
+   */
+  'capitalized-comments'?: Linter.RuleEntry<CapitalizedComments>
+  /**
+   * Enforce that class methods utilize `this`
+   * @see https://eslint.org/docs/latest/rules/class-methods-use-this
+   */
+  'class-methods-use-this'?: Linter.RuleEntry<ClassMethodsUseThis>
+  /**
+   * Require or disallow trailing commas
+   * @see https://eslint.org/docs/latest/rules/comma-dangle
+   * @deprecated
+   */
+  'comma-dangle'?: Linter.RuleEntry<CommaDangle>
+  /**
+   * Enforce consistent spacing before and after commas
+   * @see https://eslint.org/docs/latest/rules/comma-spacing
+   * @deprecated
+   */
+  'comma-spacing'?: Linter.RuleEntry<CommaSpacing>
+  /**
+   * Enforce consistent comma style
+   * @see https://eslint.org/docs/latest/rules/comma-style
+   * @deprecated
+   */
+  'comma-style'?: Linter.RuleEntry<CommaStyle>
   /**
    * Comment-as-command for one-off codemod with ESLint
    * @see https://github.com/antfu/eslint-plugin-command
    */
   'command/command'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce a maximum cyclomatic complexity allowed in a program
+   * @see https://eslint.org/docs/latest/rules/complexity
+   */
+  'complexity'?: Linter.RuleEntry<Complexity>
+  /**
+   * Enforce consistent spacing inside computed property brackets
+   * @see https://eslint.org/docs/latest/rules/computed-property-spacing
+   * @deprecated
+   */
+  'computed-property-spacing'?: Linter.RuleEntry<ComputedPropertySpacing>
+  /**
+   * Require `return` statements to either always or never specify values
+   * @see https://eslint.org/docs/latest/rules/consistent-return
+   */
+  'consistent-return'?: Linter.RuleEntry<ConsistentReturn>
+  /**
+   * Enforce consistent naming when capturing the current execution context
+   * @see https://eslint.org/docs/latest/rules/consistent-this
+   */
+  'consistent-this'?: Linter.RuleEntry<ConsistentThis>
+  /**
+   * Require `super()` calls in constructors
+   * @see https://eslint.org/docs/latest/rules/constructor-super
+   */
+  'constructor-super'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce consistent brace style for all control statements
+   * @see https://eslint.org/docs/latest/rules/curly
+   */
+  'curly'?: Linter.RuleEntry<Curly>
+  /**
+   * Require `default` cases in `switch` statements
+   * @see https://eslint.org/docs/latest/rules/default-case
+   */
+  'default-case'?: Linter.RuleEntry<DefaultCase>
+  /**
+   * Enforce default clauses in switch statements to be last
+   * @see https://eslint.org/docs/latest/rules/default-case-last
+   */
+  'default-case-last'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce default parameters to be last
+   * @see https://eslint.org/docs/latest/rules/default-param-last
+   */
+  'default-param-last'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce consistent newlines before and after dots
+   * @see https://eslint.org/docs/latest/rules/dot-location
+   * @deprecated
+   */
+  'dot-location'?: Linter.RuleEntry<DotLocation>
+  /**
+   * Enforce dot notation whenever possible
+   * @see https://eslint.org/docs/latest/rules/dot-notation
+   */
+  'dot-notation'?: Linter.RuleEntry<DotNotation>
+  /**
+   * Require or disallow newline at the end of files
+   * @see https://eslint.org/docs/latest/rules/eol-last
+   * @deprecated
+   */
+  'eol-last'?: Linter.RuleEntry<EolLast>
+  /**
+   * Require the use of `===` and `!==`
+   * @see https://eslint.org/docs/latest/rules/eqeqeq
+   */
+  'eqeqeq'?: Linter.RuleEntry<Eqeqeq>
   /**
    * require a `eslint-enable` comment for every `eslint-disable` comment
    * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/disable-enable-pair.html
@@ -696,6 +865,104 @@ export interface Rules {
    * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/require-description.html
    */
   'eslint-comments/require-description'?: Linter.RuleEntry<EslintCommentsRequireDescription>
+  /**
+   * Enforce "for" loop update clause moving the counter in the right direction
+   * @see https://eslint.org/docs/latest/rules/for-direction
+   */
+  'for-direction'?: Linter.RuleEntry<[]>
+  /**
+   * Require or disallow spacing between function identifiers and their invocations
+   * @see https://eslint.org/docs/latest/rules/func-call-spacing
+   * @deprecated
+   */
+  'func-call-spacing'?: Linter.RuleEntry<FuncCallSpacing>
+  /**
+   * Require function names to match the name of the variable or property to which they are assigned
+   * @see https://eslint.org/docs/latest/rules/func-name-matching
+   */
+  'func-name-matching'?: Linter.RuleEntry<FuncNameMatching>
+  /**
+   * Require or disallow named `function` expressions
+   * @see https://eslint.org/docs/latest/rules/func-names
+   */
+  'func-names'?: Linter.RuleEntry<FuncNames>
+  /**
+   * Enforce the consistent use of either `function` declarations or expressions assigned to variables
+   * @see https://eslint.org/docs/latest/rules/func-style
+   */
+  'func-style'?: Linter.RuleEntry<FuncStyle>
+  /**
+   * Enforce line breaks between arguments of a function call
+   * @see https://eslint.org/docs/latest/rules/function-call-argument-newline
+   * @deprecated
+   */
+  'function-call-argument-newline'?: Linter.RuleEntry<FunctionCallArgumentNewline>
+  /**
+   * Enforce consistent line breaks inside function parentheses
+   * @see https://eslint.org/docs/latest/rules/function-paren-newline
+   * @deprecated
+   */
+  'function-paren-newline'?: Linter.RuleEntry<FunctionParenNewline>
+  /**
+   * Enforce consistent spacing around `*` operators in generator functions
+   * @see https://eslint.org/docs/latest/rules/generator-star-spacing
+   * @deprecated
+   */
+  'generator-star-spacing'?: Linter.RuleEntry<GeneratorStarSpacing>
+  /**
+   * Enforce `return` statements in getters
+   * @see https://eslint.org/docs/latest/rules/getter-return
+   */
+  'getter-return'?: Linter.RuleEntry<GetterReturn>
+  /**
+   * Require `require()` calls to be placed at top-level module scope
+   * @see https://eslint.org/docs/latest/rules/global-require
+   * @deprecated
+   */
+  'global-require'?: Linter.RuleEntry<[]>
+  /**
+   * Require grouped accessor pairs in object literals and classes
+   * @see https://eslint.org/docs/latest/rules/grouped-accessor-pairs
+   */
+  'grouped-accessor-pairs'?: Linter.RuleEntry<GroupedAccessorPairs>
+  /**
+   * Require `for-in` loops to include an `if` statement
+   * @see https://eslint.org/docs/latest/rules/guard-for-in
+   */
+  'guard-for-in'?: Linter.RuleEntry<[]>
+  /**
+   * Require error handling in callbacks
+   * @see https://eslint.org/docs/latest/rules/handle-callback-err
+   * @deprecated
+   */
+  'handle-callback-err'?: Linter.RuleEntry<HandleCallbackErr>
+  /**
+   * Disallow specified identifiers
+   * @see https://eslint.org/docs/latest/rules/id-blacklist
+   * @deprecated
+   */
+  'id-blacklist'?: Linter.RuleEntry<IdBlacklist>
+  /**
+   * Disallow specified identifiers
+   * @see https://eslint.org/docs/latest/rules/id-denylist
+   */
+  'id-denylist'?: Linter.RuleEntry<IdDenylist>
+  /**
+   * Enforce minimum and maximum identifier lengths
+   * @see https://eslint.org/docs/latest/rules/id-length
+   */
+  'id-length'?: Linter.RuleEntry<IdLength>
+  /**
+   * Require identifiers to match a specified regular expression
+   * @see https://eslint.org/docs/latest/rules/id-match
+   */
+  'id-match'?: Linter.RuleEntry<IdMatch>
+  /**
+   * Enforce the location of arrow function bodies
+   * @see https://eslint.org/docs/latest/rules/implicit-arrow-linebreak
+   * @deprecated
+   */
+  'implicit-arrow-linebreak'?: Linter.RuleEntry<ImplicitArrowLinebreak>
   /**
    * Enforce or ban the use of inline type-only markers for named imports.
    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.3.1/docs/rules/consistent-type-specifier-style.md
@@ -927,6 +1194,23 @@ export interface Rules {
    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.3.1/docs/rules/unambiguous.md
    */
   'import-x/unambiguous'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce consistent indentation
+   * @see https://eslint.org/docs/latest/rules/indent
+   * @deprecated
+   */
+  'indent'?: Linter.RuleEntry<Indent>
+  /**
+   * Enforce consistent indentation
+   * @see https://eslint.org/docs/latest/rules/indent-legacy
+   * @deprecated
+   */
+  'indent-legacy'?: Linter.RuleEntry<IndentLegacy>
+  /**
+   * Require or disallow initialization in variable declarations
+   * @see https://eslint.org/docs/latest/rules/init-declarations
+   */
+  'init-declarations'?: Linter.RuleEntry<InitDeclarations>
   /**
    * Checks that `@access` tags have a valid value.
    * @see https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/check-access.md#repos-sticky-header
@@ -1211,181 +1495,1417 @@ export interface Rules {
    */
   'jsdoc/valid-types'?: Linter.RuleEntry<JsdocValidTypes>
   /**
-   * Enforce sorted arrays before include method.
-   * @see https://perfectionist.dev/rules/sort-array-includes
+   * Enforce the consistent use of either double or single quotes in JSX attributes
+   * @see https://eslint.org/docs/latest/rules/jsx-quotes
+   * @deprecated
    */
-  'perfectionist/sort-array-includes'?: Linter.RuleEntry<PerfectionistSortArrayIncludes>
+  'jsx-quotes'?: Linter.RuleEntry<JsxQuotes>
   /**
-   * Enforce sorted Astro attributes.
-   * @see https://perfectionist.dev/rules/sort-astro-attributes
+   * Enforce consistent spacing between keys and values in object literal properties
+   * @see https://eslint.org/docs/latest/rules/key-spacing
+   * @deprecated
    */
-  'perfectionist/sort-astro-attributes'?: Linter.RuleEntry<PerfectionistSortAstroAttributes>
+  'key-spacing'?: Linter.RuleEntry<KeySpacing>
   /**
-   * Enforce sorted classes.
-   * @see https://perfectionist.dev/rules/sort-classes
+   * Enforce consistent spacing before and after keywords
+   * @see https://eslint.org/docs/latest/rules/keyword-spacing
+   * @deprecated
    */
-  'perfectionist/sort-classes'?: Linter.RuleEntry<PerfectionistSortClasses>
+  'keyword-spacing'?: Linter.RuleEntry<KeywordSpacing>
   /**
-   * Enforce sorted TypeScript enums.
-   * @see https://perfectionist.dev/rules/sort-enums
+   * Enforce position of line comments
+   * @see https://eslint.org/docs/latest/rules/line-comment-position
+   * @deprecated
    */
-  'perfectionist/sort-enums'?: Linter.RuleEntry<PerfectionistSortEnums>
+  'line-comment-position'?: Linter.RuleEntry<LineCommentPosition>
   /**
-   * Enforce sorted exports.
-   * @see https://perfectionist.dev/rules/sort-exports
+   * Enforce consistent linebreak style
+   * @see https://eslint.org/docs/latest/rules/linebreak-style
+   * @deprecated
    */
-  'perfectionist/sort-exports'?: Linter.RuleEntry<PerfectionistSortExports>
+  'linebreak-style'?: Linter.RuleEntry<LinebreakStyle>
   /**
-   * Enforce sorted imports.
-   * @see https://perfectionist.dev/rules/sort-imports
+   * Require empty lines around comments
+   * @see https://eslint.org/docs/latest/rules/lines-around-comment
+   * @deprecated
    */
-  'perfectionist/sort-imports'?: Linter.RuleEntry<PerfectionistSortImports>
+  'lines-around-comment'?: Linter.RuleEntry<LinesAroundComment>
   /**
-   * Enforce sorted interface properties.
-   * @see https://perfectionist.dev/rules/sort-interfaces
+   * Require or disallow newlines around directives
+   * @see https://eslint.org/docs/latest/rules/lines-around-directive
+   * @deprecated
    */
-  'perfectionist/sort-interfaces'?: Linter.RuleEntry<PerfectionistSortInterfaces>
+  'lines-around-directive'?: Linter.RuleEntry<LinesAroundDirective>
   /**
-   * Enforce sorted intersection types.
-   * @see https://perfectionist.dev/rules/sort-intersection-types
+   * Require or disallow an empty line between class members
+   * @see https://eslint.org/docs/latest/rules/lines-between-class-members
+   * @deprecated
    */
-  'perfectionist/sort-intersection-types'?: Linter.RuleEntry<PerfectionistSortIntersectionTypes>
+  'lines-between-class-members'?: Linter.RuleEntry<LinesBetweenClassMembers>
   /**
-   * Enforce sorted JSX props.
-   * @see https://perfectionist.dev/rules/sort-jsx-props
+   * Require or disallow logical assignment operator shorthand
+   * @see https://eslint.org/docs/latest/rules/logical-assignment-operators
    */
-  'perfectionist/sort-jsx-props'?: Linter.RuleEntry<PerfectionistSortJsxProps>
+  'logical-assignment-operators'?: Linter.RuleEntry<LogicalAssignmentOperators>
   /**
-   * Enforce sorted Map elements.
-   * @see https://perfectionist.dev/rules/sort-maps
+   * Enforce a maximum number of classes per file
+   * @see https://eslint.org/docs/latest/rules/max-classes-per-file
    */
-  'perfectionist/sort-maps'?: Linter.RuleEntry<PerfectionistSortMaps>
+  'max-classes-per-file'?: Linter.RuleEntry<MaxClassesPerFile>
   /**
-   * Enforce sorted named exports.
-   * @see https://perfectionist.dev/rules/sort-named-exports
+   * Enforce a maximum depth that blocks can be nested
+   * @see https://eslint.org/docs/latest/rules/max-depth
    */
-  'perfectionist/sort-named-exports'?: Linter.RuleEntry<PerfectionistSortNamedExports>
+  'max-depth'?: Linter.RuleEntry<MaxDepth>
   /**
-   * Enforce sorted named imports.
-   * @see https://perfectionist.dev/rules/sort-named-imports
+   * Enforce a maximum line length
+   * @see https://eslint.org/docs/latest/rules/max-len
+   * @deprecated
    */
-  'perfectionist/sort-named-imports'?: Linter.RuleEntry<PerfectionistSortNamedImports>
+  'max-len'?: Linter.RuleEntry<MaxLen>
   /**
-   * Enforce sorted object types.
-   * @see https://perfectionist.dev/rules/sort-object-types
+   * Enforce a maximum number of lines per file
+   * @see https://eslint.org/docs/latest/rules/max-lines
    */
-  'perfectionist/sort-object-types'?: Linter.RuleEntry<PerfectionistSortObjectTypes>
+  'max-lines'?: Linter.RuleEntry<MaxLines>
   /**
-   * Enforce sorted objects.
-   * @see https://perfectionist.dev/rules/sort-objects
+   * Enforce a maximum number of lines of code in a function
+   * @see https://eslint.org/docs/latest/rules/max-lines-per-function
    */
-  'perfectionist/sort-objects'?: Linter.RuleEntry<PerfectionistSortObjects>
+  'max-lines-per-function'?: Linter.RuleEntry<MaxLinesPerFunction>
   /**
-   * Enforce sorted sets.
-   * @see https://perfectionist.dev/rules/sort-sets
+   * Enforce a maximum depth that callbacks can be nested
+   * @see https://eslint.org/docs/latest/rules/max-nested-callbacks
    */
-  'perfectionist/sort-sets'?: Linter.RuleEntry<PerfectionistSortSets>
+  'max-nested-callbacks'?: Linter.RuleEntry<MaxNestedCallbacks>
   /**
-   * Enforce sorted Svelte attributes.
-   * @see https://perfectionist.dev/rules/sort-svelte-attributes
+   * Enforce a maximum number of parameters in function definitions
+   * @see https://eslint.org/docs/latest/rules/max-params
    */
-  'perfectionist/sort-svelte-attributes'?: Linter.RuleEntry<PerfectionistSortSvelteAttributes>
+  'max-params'?: Linter.RuleEntry<MaxParams>
   /**
-   * Enforce sorted switch cases.
-   * @see https://perfectionist.dev/rules/sort-switch-case
+   * Enforce a maximum number of statements allowed in function blocks
+   * @see https://eslint.org/docs/latest/rules/max-statements
    */
-  'perfectionist/sort-switch-case'?: Linter.RuleEntry<PerfectionistSortSwitchCase>
+  'max-statements'?: Linter.RuleEntry<MaxStatements>
   /**
-   * Enforce sorted union types.
-   * @see https://perfectionist.dev/rules/sort-union-types
+   * Enforce a maximum number of statements allowed per line
+   * @see https://eslint.org/docs/latest/rules/max-statements-per-line
+   * @deprecated
    */
-  'perfectionist/sort-union-types'?: Linter.RuleEntry<PerfectionistSortUnionTypes>
+  'max-statements-per-line'?: Linter.RuleEntry<MaxStatementsPerLine>
   /**
-   * Enforce sorted variable declarations.
-   * @see https://perfectionist.dev/rules/sort-variable-declarations
+   * Enforce a particular style for multiline comments
+   * @see https://eslint.org/docs/latest/rules/multiline-comment-style
+   * @deprecated
    */
-  'perfectionist/sort-variable-declarations'?: Linter.RuleEntry<PerfectionistSortVariableDeclarations>
+  'multiline-comment-style'?: Linter.RuleEntry<MultilineCommentStyle>
   /**
-   * Enforce sorted Vue attributes.
-   * @see https://perfectionist.dev/rules/sort-vue-attributes
+   * Enforce newlines between operands of ternary expressions
+   * @see https://eslint.org/docs/latest/rules/multiline-ternary
+   * @deprecated
    */
-  'perfectionist/sort-vue-attributes'?: Linter.RuleEntry<PerfectionistSortVueAttributes>
+  'multiline-ternary'?: Linter.RuleEntry<MultilineTernary>
   /**
-   * Disallow unused variables
-   * @see https://github.com/sweepline/eslint-plugin-unused-imports/blob/master/docs/rules/no-unused-imports.md
+   * Require constructor names to begin with a capital letter
+   * @see https://eslint.org/docs/latest/rules/new-cap
    */
-  'unused-imports/no-unused-imports'?: Linter.RuleEntry<UnusedImportsNoUnusedImports>
+  'new-cap'?: Linter.RuleEntry<NewCap>
   /**
-   * Disallow unused variables
-   * @see https://github.com/sweepline/eslint-plugin-unused-imports/blob/master/docs/rules/no-unused-vars.md
+   * Enforce or disallow parentheses when invoking a constructor with no arguments
+   * @see https://eslint.org/docs/latest/rules/new-parens
+   * @deprecated
    */
-  'unused-imports/no-unused-vars'?: Linter.RuleEntry<UnusedImportsNoUnusedVars>
+  'new-parens'?: Linter.RuleEntry<NewParens>
   /**
-   * require .spec test file pattern
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/consistent-test-filename.md
+   * Require or disallow an empty line after variable declarations
+   * @see https://eslint.org/docs/latest/rules/newline-after-var
+   * @deprecated
    */
-  'vitest/consistent-test-filename'?: Linter.RuleEntry<VitestConsistentTestFilename>
+  'newline-after-var'?: Linter.RuleEntry<NewlineAfterVar>
   /**
-   * enforce using test or it but not both
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/consistent-test-it.md
+   * Require an empty line before `return` statements
+   * @see https://eslint.org/docs/latest/rules/newline-before-return
+   * @deprecated
    */
-  'vitest/consistent-test-it'?: Linter.RuleEntry<VitestConsistentTestIt>
+  'newline-before-return'?: Linter.RuleEntry<[]>
   /**
-   * enforce having expectation in test body
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/expect-expect.md
+   * Require a newline after each call in a method chain
+   * @see https://eslint.org/docs/latest/rules/newline-per-chained-call
+   * @deprecated
    */
-  'vitest/expect-expect'?: Linter.RuleEntry<VitestExpectExpect>
+  'newline-per-chained-call'?: Linter.RuleEntry<NewlinePerChainedCall>
   /**
-   * enforce a maximum number of expect per test
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/max-expects.md
+   * Disallow the use of `alert`, `confirm`, and `prompt`
+   * @see https://eslint.org/docs/latest/rules/no-alert
    */
-  'vitest/max-expects'?: Linter.RuleEntry<VitestMaxExpects>
+  'no-alert'?: Linter.RuleEntry<[]>
   /**
-   * require describe block to be less than set max value or default value
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/max-nested-describe.md
+   * Disallow `Array` constructors
+   * @see https://eslint.org/docs/latest/rules/no-array-constructor
    */
-  'vitest/max-nested-describe'?: Linter.RuleEntry<VitestMaxNestedDescribe>
+  'no-array-constructor'?: Linter.RuleEntry<[]>
   /**
-   * disallow alias methods
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-alias-methods.md
+   * Disallow using an async function as a Promise executor
+   * @see https://eslint.org/docs/latest/rules/no-async-promise-executor
    */
-  'vitest/no-alias-methods'?: Linter.RuleEntry<[]>
+  'no-async-promise-executor'?: Linter.RuleEntry<[]>
   /**
-   * disallow commented out tests
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-commented-out-tests.md
+   * Disallow `await` inside of loops
+   * @see https://eslint.org/docs/latest/rules/no-await-in-loop
    */
-  'vitest/no-commented-out-tests'?: Linter.RuleEntry<[]>
+  'no-await-in-loop'?: Linter.RuleEntry<[]>
   /**
-   * disallow conditional expects
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-expect.md
+   * Disallow bitwise operators
+   * @see https://eslint.org/docs/latest/rules/no-bitwise
    */
-  'vitest/no-conditional-expect'?: Linter.RuleEntry<[]>
+  'no-bitwise'?: Linter.RuleEntry<NoBitwise>
   /**
-   * disallow conditional tests
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-in-test.md
+   * Disallow use of the `Buffer()` constructor
+   * @see https://eslint.org/docs/latest/rules/no-buffer-constructor
+   * @deprecated
    */
-  'vitest/no-conditional-in-test'?: Linter.RuleEntry<[]>
+  'no-buffer-constructor'?: Linter.RuleEntry<[]>
   /**
-   * disallow conditional tests
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-tests.md
+   * Disallow the use of `arguments.caller` or `arguments.callee`
+   * @see https://eslint.org/docs/latest/rules/no-caller
    */
-  'vitest/no-conditional-tests'?: Linter.RuleEntry<[]>
+  'no-caller'?: Linter.RuleEntry<[]>
   /**
-   * disallow disabled tests
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-disabled-tests.md
+   * Disallow lexical declarations in case clauses
+   * @see https://eslint.org/docs/latest/rules/no-case-declarations
    */
-  'vitest/no-disabled-tests'?: Linter.RuleEntry<[]>
+  'no-case-declarations'?: Linter.RuleEntry<[]>
   /**
-   * disallow using a callback in asynchronous tests and hooks
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-done-callback.md
+   * Disallow `catch` clause parameters from shadowing variables in the outer scope
+   * @see https://eslint.org/docs/latest/rules/no-catch-shadow
    * @deprecated
    */
-  'vitest/no-done-callback'?: Linter.RuleEntry<[]>
+  'no-catch-shadow'?: Linter.RuleEntry<[]>
   /**
-   * disallow duplicate hooks and teardown hooks
-   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-duplicate-hooks.md
+   * Disallow reassigning class members
+   * @see https://eslint.org/docs/latest/rules/no-class-assign
    */
-  'vitest/no-duplicate-hooks'?: Linter.RuleEntry<[]>
+  'no-class-assign'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow comparing against -0
+   * @see https://eslint.org/docs/latest/rules/no-compare-neg-zero
+   */
+  'no-compare-neg-zero'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow assignment operators in conditional expressions
+   * @see https://eslint.org/docs/latest/rules/no-cond-assign
+   */
+  'no-cond-assign'?: Linter.RuleEntry<NoCondAssign>
+  /**
+   * Disallow arrow functions where they could be confused with comparisons
+   * @see https://eslint.org/docs/latest/rules/no-confusing-arrow
+   * @deprecated
+   */
+  'no-confusing-arrow'?: Linter.RuleEntry<NoConfusingArrow>
+  /**
+   * Disallow the use of `console`
+   * @see https://eslint.org/docs/latest/rules/no-console
+   */
+  'no-console'?: Linter.RuleEntry<NoConsole>
+  /**
+   * Disallow reassigning `const` variables
+   * @see https://eslint.org/docs/latest/rules/no-const-assign
+   */
+  'no-const-assign'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow expressions where the operation doesn't affect the value
+   * @see https://eslint.org/docs/latest/rules/no-constant-binary-expression
+   */
+  'no-constant-binary-expression'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow constant expressions in conditions
+   * @see https://eslint.org/docs/latest/rules/no-constant-condition
+   */
+  'no-constant-condition'?: Linter.RuleEntry<NoConstantCondition>
+  /**
+   * Disallow returning value from constructor
+   * @see https://eslint.org/docs/latest/rules/no-constructor-return
+   */
+  'no-constructor-return'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `continue` statements
+   * @see https://eslint.org/docs/latest/rules/no-continue
+   */
+  'no-continue'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow control characters in regular expressions
+   * @see https://eslint.org/docs/latest/rules/no-control-regex
+   */
+  'no-control-regex'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow the use of `debugger`
+   * @see https://eslint.org/docs/latest/rules/no-debugger
+   */
+  'no-debugger'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow deleting variables
+   * @see https://eslint.org/docs/latest/rules/no-delete-var
+   */
+  'no-delete-var'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow equal signs explicitly at the beginning of regular expressions
+   * @see https://eslint.org/docs/latest/rules/no-div-regex
+   */
+  'no-div-regex'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow duplicate arguments in `function` definitions
+   * @see https://eslint.org/docs/latest/rules/no-dupe-args
+   */
+  'no-dupe-args'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow duplicate class members
+   * @see https://eslint.org/docs/latest/rules/no-dupe-class-members
+   */
+  'no-dupe-class-members'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow duplicate conditions in if-else-if chains
+   * @see https://eslint.org/docs/latest/rules/no-dupe-else-if
+   */
+  'no-dupe-else-if'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow duplicate keys in object literals
+   * @see https://eslint.org/docs/latest/rules/no-dupe-keys
+   */
+  'no-dupe-keys'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow duplicate case labels
+   * @see https://eslint.org/docs/latest/rules/no-duplicate-case
+   */
+  'no-duplicate-case'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow duplicate module imports
+   * @see https://eslint.org/docs/latest/rules/no-duplicate-imports
+   */
+  'no-duplicate-imports'?: Linter.RuleEntry<NoDuplicateImports>
+  /**
+   * Disallow `else` blocks after `return` statements in `if` statements
+   * @see https://eslint.org/docs/latest/rules/no-else-return
+   */
+  'no-else-return'?: Linter.RuleEntry<NoElseReturn>
+  /**
+   * Disallow empty block statements
+   * @see https://eslint.org/docs/latest/rules/no-empty
+   */
+  'no-empty'?: Linter.RuleEntry<NoEmpty>
+  /**
+   * Disallow empty character classes in regular expressions
+   * @see https://eslint.org/docs/latest/rules/no-empty-character-class
+   */
+  'no-empty-character-class'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow empty functions
+   * @see https://eslint.org/docs/latest/rules/no-empty-function
+   */
+  'no-empty-function'?: Linter.RuleEntry<NoEmptyFunction>
+  /**
+   * Disallow empty destructuring patterns
+   * @see https://eslint.org/docs/latest/rules/no-empty-pattern
+   */
+  'no-empty-pattern'?: Linter.RuleEntry<NoEmptyPattern>
+  /**
+   * Disallow empty static blocks
+   * @see https://eslint.org/docs/latest/rules/no-empty-static-block
+   */
+  'no-empty-static-block'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `null` comparisons without type-checking operators
+   * @see https://eslint.org/docs/latest/rules/no-eq-null
+   */
+  'no-eq-null'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow the use of `eval()`
+   * @see https://eslint.org/docs/latest/rules/no-eval
+   */
+  'no-eval'?: Linter.RuleEntry<NoEval>
+  /**
+   * Disallow reassigning exceptions in `catch` clauses
+   * @see https://eslint.org/docs/latest/rules/no-ex-assign
+   */
+  'no-ex-assign'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow extending native types
+   * @see https://eslint.org/docs/latest/rules/no-extend-native
+   */
+  'no-extend-native'?: Linter.RuleEntry<NoExtendNative>
+  /**
+   * Disallow unnecessary calls to `.bind()`
+   * @see https://eslint.org/docs/latest/rules/no-extra-bind
+   */
+  'no-extra-bind'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unnecessary boolean casts
+   * @see https://eslint.org/docs/latest/rules/no-extra-boolean-cast
+   */
+  'no-extra-boolean-cast'?: Linter.RuleEntry<NoExtraBooleanCast>
+  /**
+   * Disallow unnecessary labels
+   * @see https://eslint.org/docs/latest/rules/no-extra-label
+   */
+  'no-extra-label'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unnecessary parentheses
+   * @see https://eslint.org/docs/latest/rules/no-extra-parens
+   * @deprecated
+   */
+  'no-extra-parens'?: Linter.RuleEntry<NoExtraParens>
+  /**
+   * Disallow unnecessary semicolons
+   * @see https://eslint.org/docs/latest/rules/no-extra-semi
+   * @deprecated
+   */
+  'no-extra-semi'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow fallthrough of `case` statements
+   * @see https://eslint.org/docs/latest/rules/no-fallthrough
+   */
+  'no-fallthrough'?: Linter.RuleEntry<NoFallthrough>
+  /**
+   * Disallow leading or trailing decimal points in numeric literals
+   * @see https://eslint.org/docs/latest/rules/no-floating-decimal
+   * @deprecated
+   */
+  'no-floating-decimal'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow reassigning `function` declarations
+   * @see https://eslint.org/docs/latest/rules/no-func-assign
+   */
+  'no-func-assign'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow assignments to native objects or read-only global variables
+   * @see https://eslint.org/docs/latest/rules/no-global-assign
+   */
+  'no-global-assign'?: Linter.RuleEntry<NoGlobalAssign>
+  /**
+   * Disallow shorthand type conversions
+   * @see https://eslint.org/docs/latest/rules/no-implicit-coercion
+   */
+  'no-implicit-coercion'?: Linter.RuleEntry<NoImplicitCoercion>
+  /**
+   * Disallow declarations in the global scope
+   * @see https://eslint.org/docs/latest/rules/no-implicit-globals
+   */
+  'no-implicit-globals'?: Linter.RuleEntry<NoImplicitGlobals>
+  /**
+   * Disallow the use of `eval()`-like methods
+   * @see https://eslint.org/docs/latest/rules/no-implied-eval
+   */
+  'no-implied-eval'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow assigning to imported bindings
+   * @see https://eslint.org/docs/latest/rules/no-import-assign
+   */
+  'no-import-assign'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow inline comments after code
+   * @see https://eslint.org/docs/latest/rules/no-inline-comments
+   */
+  'no-inline-comments'?: Linter.RuleEntry<NoInlineComments>
+  /**
+   * Disallow variable or `function` declarations in nested blocks
+   * @see https://eslint.org/docs/latest/rules/no-inner-declarations
+   */
+  'no-inner-declarations'?: Linter.RuleEntry<NoInnerDeclarations>
+  /**
+   * Disallow invalid regular expression strings in `RegExp` constructors
+   * @see https://eslint.org/docs/latest/rules/no-invalid-regexp
+   */
+  'no-invalid-regexp'?: Linter.RuleEntry<NoInvalidRegexp>
+  /**
+   * Disallow use of `this` in contexts where the value of `this` is `undefined`
+   * @see https://eslint.org/docs/latest/rules/no-invalid-this
+   */
+  'no-invalid-this'?: Linter.RuleEntry<NoInvalidThis>
+  /**
+   * Disallow irregular whitespace
+   * @see https://eslint.org/docs/latest/rules/no-irregular-whitespace
+   */
+  'no-irregular-whitespace'?: Linter.RuleEntry<NoIrregularWhitespace>
+  /**
+   * Disallow the use of the `__iterator__` property
+   * @see https://eslint.org/docs/latest/rules/no-iterator
+   */
+  'no-iterator'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow labels that share a name with a variable
+   * @see https://eslint.org/docs/latest/rules/no-label-var
+   */
+  'no-label-var'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow labeled statements
+   * @see https://eslint.org/docs/latest/rules/no-labels
+   */
+  'no-labels'?: Linter.RuleEntry<NoLabels>
+  /**
+   * Disallow unnecessary nested blocks
+   * @see https://eslint.org/docs/latest/rules/no-lone-blocks
+   */
+  'no-lone-blocks'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `if` statements as the only statement in `else` blocks
+   * @see https://eslint.org/docs/latest/rules/no-lonely-if
+   */
+  'no-lonely-if'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow function declarations that contain unsafe references inside loop statements
+   * @see https://eslint.org/docs/latest/rules/no-loop-func
+   */
+  'no-loop-func'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow literal numbers that lose precision
+   * @see https://eslint.org/docs/latest/rules/no-loss-of-precision
+   */
+  'no-loss-of-precision'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow magic numbers
+   * @see https://eslint.org/docs/latest/rules/no-magic-numbers
+   */
+  'no-magic-numbers'?: Linter.RuleEntry<NoMagicNumbers>
+  /**
+   * Disallow characters which are made with multiple code points in character class syntax
+   * @see https://eslint.org/docs/latest/rules/no-misleading-character-class
+   */
+  'no-misleading-character-class'?: Linter.RuleEntry<NoMisleadingCharacterClass>
+  /**
+   * Disallow mixed binary operators
+   * @see https://eslint.org/docs/latest/rules/no-mixed-operators
+   * @deprecated
+   */
+  'no-mixed-operators'?: Linter.RuleEntry<NoMixedOperators>
+  /**
+   * Disallow `require` calls to be mixed with regular variable declarations
+   * @see https://eslint.org/docs/latest/rules/no-mixed-requires
+   * @deprecated
+   */
+  'no-mixed-requires'?: Linter.RuleEntry<NoMixedRequires>
+  /**
+   * Disallow mixed spaces and tabs for indentation
+   * @see https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs
+   * @deprecated
+   */
+  'no-mixed-spaces-and-tabs'?: Linter.RuleEntry<NoMixedSpacesAndTabs>
+  /**
+   * Disallow use of chained assignment expressions
+   * @see https://eslint.org/docs/latest/rules/no-multi-assign
+   */
+  'no-multi-assign'?: Linter.RuleEntry<NoMultiAssign>
+  /**
+   * Disallow multiple spaces
+   * @see https://eslint.org/docs/latest/rules/no-multi-spaces
+   * @deprecated
+   */
+  'no-multi-spaces'?: Linter.RuleEntry<NoMultiSpaces>
+  /**
+   * Disallow multiline strings
+   * @see https://eslint.org/docs/latest/rules/no-multi-str
+   */
+  'no-multi-str'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow multiple empty lines
+   * @see https://eslint.org/docs/latest/rules/no-multiple-empty-lines
+   * @deprecated
+   */
+  'no-multiple-empty-lines'?: Linter.RuleEntry<NoMultipleEmptyLines>
+  /**
+   * Disallow assignments to native objects or read-only global variables
+   * @see https://eslint.org/docs/latest/rules/no-native-reassign
+   * @deprecated
+   */
+  'no-native-reassign'?: Linter.RuleEntry<NoNativeReassign>
+  /**
+   * Disallow negated conditions
+   * @see https://eslint.org/docs/latest/rules/no-negated-condition
+   */
+  'no-negated-condition'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow negating the left operand in `in` expressions
+   * @see https://eslint.org/docs/latest/rules/no-negated-in-lhs
+   * @deprecated
+   */
+  'no-negated-in-lhs'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow nested ternary expressions
+   * @see https://eslint.org/docs/latest/rules/no-nested-ternary
+   */
+  'no-nested-ternary'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `new` operators outside of assignments or comparisons
+   * @see https://eslint.org/docs/latest/rules/no-new
+   */
+  'no-new'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `new` operators with the `Function` object
+   * @see https://eslint.org/docs/latest/rules/no-new-func
+   */
+  'no-new-func'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `new` operators with global non-constructor functions
+   * @see https://eslint.org/docs/latest/rules/no-new-native-nonconstructor
+   */
+  'no-new-native-nonconstructor'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `Object` constructors
+   * @see https://eslint.org/docs/latest/rules/no-new-object
+   * @deprecated
+   */
+  'no-new-object'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `new` operators with calls to `require`
+   * @see https://eslint.org/docs/latest/rules/no-new-require
+   * @deprecated
+   */
+  'no-new-require'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `new` operators with the `Symbol` object
+   * @see https://eslint.org/docs/latest/rules/no-new-symbol
+   * @deprecated
+   */
+  'no-new-symbol'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `new` operators with the `String`, `Number`, and `Boolean` objects
+   * @see https://eslint.org/docs/latest/rules/no-new-wrappers
+   */
+  'no-new-wrappers'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `\8` and `\9` escape sequences in string literals
+   * @see https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape
+   */
+  'no-nonoctal-decimal-escape'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow calling global object properties as functions
+   * @see https://eslint.org/docs/latest/rules/no-obj-calls
+   */
+  'no-obj-calls'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow calls to the `Object` constructor without an argument
+   * @see https://eslint.org/docs/latest/rules/no-object-constructor
+   */
+  'no-object-constructor'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow octal literals
+   * @see https://eslint.org/docs/latest/rules/no-octal
+   */
+  'no-octal'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow octal escape sequences in string literals
+   * @see https://eslint.org/docs/latest/rules/no-octal-escape
+   */
+  'no-octal-escape'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow reassigning `function` parameters
+   * @see https://eslint.org/docs/latest/rules/no-param-reassign
+   */
+  'no-param-reassign'?: Linter.RuleEntry<NoParamReassign>
+  /**
+   * Disallow string concatenation with `__dirname` and `__filename`
+   * @see https://eslint.org/docs/latest/rules/no-path-concat
+   * @deprecated
+   */
+  'no-path-concat'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow the unary operators `++` and `--`
+   * @see https://eslint.org/docs/latest/rules/no-plusplus
+   */
+  'no-plusplus'?: Linter.RuleEntry<NoPlusplus>
+  /**
+   * Disallow the use of `process.env`
+   * @see https://eslint.org/docs/latest/rules/no-process-env
+   * @deprecated
+   */
+  'no-process-env'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow the use of `process.exit()`
+   * @see https://eslint.org/docs/latest/rules/no-process-exit
+   * @deprecated
+   */
+  'no-process-exit'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow returning values from Promise executor functions
+   * @see https://eslint.org/docs/latest/rules/no-promise-executor-return
+   */
+  'no-promise-executor-return'?: Linter.RuleEntry<NoPromiseExecutorReturn>
+  /**
+   * Disallow the use of the `__proto__` property
+   * @see https://eslint.org/docs/latest/rules/no-proto
+   */
+  'no-proto'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow calling some `Object.prototype` methods directly on objects
+   * @see https://eslint.org/docs/latest/rules/no-prototype-builtins
+   */
+  'no-prototype-builtins'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow variable redeclaration
+   * @see https://eslint.org/docs/latest/rules/no-redeclare
+   */
+  'no-redeclare'?: Linter.RuleEntry<NoRedeclare>
+  /**
+   * Disallow multiple spaces in regular expressions
+   * @see https://eslint.org/docs/latest/rules/no-regex-spaces
+   */
+  'no-regex-spaces'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow specified names in exports
+   * @see https://eslint.org/docs/latest/rules/no-restricted-exports
+   */
+  'no-restricted-exports'?: Linter.RuleEntry<NoRestrictedExports>
+  /**
+   * Disallow specified global variables
+   * @see https://eslint.org/docs/latest/rules/no-restricted-globals
+   */
+  'no-restricted-globals'?: Linter.RuleEntry<NoRestrictedGlobals>
+  /**
+   * Disallow specified modules when loaded by `import`
+   * @see https://eslint.org/docs/latest/rules/no-restricted-imports
+   */
+  'no-restricted-imports'?: Linter.RuleEntry<NoRestrictedImports>
+  /**
+   * Disallow specified modules when loaded by `require`
+   * @see https://eslint.org/docs/latest/rules/no-restricted-modules
+   * @deprecated
+   */
+  'no-restricted-modules'?: Linter.RuleEntry<NoRestrictedModules>
+  /**
+   * Disallow certain properties on certain objects
+   * @see https://eslint.org/docs/latest/rules/no-restricted-properties
+   */
+  'no-restricted-properties'?: Linter.RuleEntry<NoRestrictedProperties>
+  /**
+   * Disallow specified syntax
+   * @see https://eslint.org/docs/latest/rules/no-restricted-syntax
+   */
+  'no-restricted-syntax'?: Linter.RuleEntry<NoRestrictedSyntax>
+  /**
+   * Disallow assignment operators in `return` statements
+   * @see https://eslint.org/docs/latest/rules/no-return-assign
+   */
+  'no-return-assign'?: Linter.RuleEntry<NoReturnAssign>
+  /**
+   * Disallow unnecessary `return await`
+   * @see https://eslint.org/docs/latest/rules/no-return-await
+   * @deprecated
+   */
+  'no-return-await'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `javascript:` urls
+   * @see https://eslint.org/docs/latest/rules/no-script-url
+   */
+  'no-script-url'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow assignments where both sides are exactly the same
+   * @see https://eslint.org/docs/latest/rules/no-self-assign
+   */
+  'no-self-assign'?: Linter.RuleEntry<NoSelfAssign>
+  /**
+   * Disallow comparisons where both sides are exactly the same
+   * @see https://eslint.org/docs/latest/rules/no-self-compare
+   */
+  'no-self-compare'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow comma operators
+   * @see https://eslint.org/docs/latest/rules/no-sequences
+   */
+  'no-sequences'?: Linter.RuleEntry<NoSequences>
+  /**
+   * Disallow returning values from setters
+   * @see https://eslint.org/docs/latest/rules/no-setter-return
+   */
+  'no-setter-return'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow variable declarations from shadowing variables declared in the outer scope
+   * @see https://eslint.org/docs/latest/rules/no-shadow
+   */
+  'no-shadow'?: Linter.RuleEntry<NoShadow>
+  /**
+   * Disallow identifiers from shadowing restricted names
+   * @see https://eslint.org/docs/latest/rules/no-shadow-restricted-names
+   */
+  'no-shadow-restricted-names'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow spacing between function identifiers and their applications (deprecated)
+   * @see https://eslint.org/docs/latest/rules/no-spaced-func
+   * @deprecated
+   */
+  'no-spaced-func'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow sparse arrays
+   * @see https://eslint.org/docs/latest/rules/no-sparse-arrays
+   */
+  'no-sparse-arrays'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow synchronous methods
+   * @see https://eslint.org/docs/latest/rules/no-sync
+   * @deprecated
+   */
+  'no-sync'?: Linter.RuleEntry<NoSync>
+  /**
+   * Disallow all tabs
+   * @see https://eslint.org/docs/latest/rules/no-tabs
+   * @deprecated
+   */
+  'no-tabs'?: Linter.RuleEntry<NoTabs>
+  /**
+   * Disallow template literal placeholder syntax in regular strings
+   * @see https://eslint.org/docs/latest/rules/no-template-curly-in-string
+   */
+  'no-template-curly-in-string'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow ternary operators
+   * @see https://eslint.org/docs/latest/rules/no-ternary
+   */
+  'no-ternary'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `this`/`super` before calling `super()` in constructors
+   * @see https://eslint.org/docs/latest/rules/no-this-before-super
+   */
+  'no-this-before-super'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow throwing literals as exceptions
+   * @see https://eslint.org/docs/latest/rules/no-throw-literal
+   */
+  'no-throw-literal'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow trailing whitespace at the end of lines
+   * @see https://eslint.org/docs/latest/rules/no-trailing-spaces
+   * @deprecated
+   */
+  'no-trailing-spaces'?: Linter.RuleEntry<NoTrailingSpaces>
+  /**
+   * Disallow the use of undeclared variables unless mentioned in `/*global *\/` comments
+   * @see https://eslint.org/docs/latest/rules/no-undef
+   */
+  'no-undef'?: Linter.RuleEntry<NoUndef>
+  /**
+   * Disallow initializing variables to `undefined`
+   * @see https://eslint.org/docs/latest/rules/no-undef-init
+   */
+  'no-undef-init'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow the use of `undefined` as an identifier
+   * @see https://eslint.org/docs/latest/rules/no-undefined
+   */
+  'no-undefined'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow dangling underscores in identifiers
+   * @see https://eslint.org/docs/latest/rules/no-underscore-dangle
+   */
+  'no-underscore-dangle'?: Linter.RuleEntry<NoUnderscoreDangle>
+  /**
+   * Disallow confusing multiline expressions
+   * @see https://eslint.org/docs/latest/rules/no-unexpected-multiline
+   */
+  'no-unexpected-multiline'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unmodified loop conditions
+   * @see https://eslint.org/docs/latest/rules/no-unmodified-loop-condition
+   */
+  'no-unmodified-loop-condition'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow ternary operators when simpler alternatives exist
+   * @see https://eslint.org/docs/latest/rules/no-unneeded-ternary
+   */
+  'no-unneeded-ternary'?: Linter.RuleEntry<NoUnneededTernary>
+  /**
+   * Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements
+   * @see https://eslint.org/docs/latest/rules/no-unreachable
+   */
+  'no-unreachable'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow loops with a body that allows only one iteration
+   * @see https://eslint.org/docs/latest/rules/no-unreachable-loop
+   */
+  'no-unreachable-loop'?: Linter.RuleEntry<NoUnreachableLoop>
+  /**
+   * Disallow control flow statements in `finally` blocks
+   * @see https://eslint.org/docs/latest/rules/no-unsafe-finally
+   */
+  'no-unsafe-finally'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow negating the left operand of relational operators
+   * @see https://eslint.org/docs/latest/rules/no-unsafe-negation
+   */
+  'no-unsafe-negation'?: Linter.RuleEntry<NoUnsafeNegation>
+  /**
+   * Disallow use of optional chaining in contexts where the `undefined` value is not allowed
+   * @see https://eslint.org/docs/latest/rules/no-unsafe-optional-chaining
+   */
+  'no-unsafe-optional-chaining'?: Linter.RuleEntry<NoUnsafeOptionalChaining>
+  /**
+   * Disallow unused expressions
+   * @see https://eslint.org/docs/latest/rules/no-unused-expressions
+   */
+  'no-unused-expressions'?: Linter.RuleEntry<NoUnusedExpressions>
+  /**
+   * Disallow unused labels
+   * @see https://eslint.org/docs/latest/rules/no-unused-labels
+   */
+  'no-unused-labels'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unused private class members
+   * @see https://eslint.org/docs/latest/rules/no-unused-private-class-members
+   */
+  'no-unused-private-class-members'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unused variables
+   * @see https://eslint.org/docs/latest/rules/no-unused-vars
+   */
+  'no-unused-vars'?: Linter.RuleEntry<NoUnusedVars>
+  /**
+   * Disallow the use of variables before they are defined
+   * @see https://eslint.org/docs/latest/rules/no-use-before-define
+   */
+  'no-use-before-define'?: Linter.RuleEntry<NoUseBeforeDefine>
+  /**
+   * Disallow variable assignments when the value is not used
+   * @see https://eslint.org/docs/latest/rules/no-useless-assignment
+   */
+  'no-useless-assignment'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow useless backreferences in regular expressions
+   * @see https://eslint.org/docs/latest/rules/no-useless-backreference
+   */
+  'no-useless-backreference'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unnecessary calls to `.call()` and `.apply()`
+   * @see https://eslint.org/docs/latest/rules/no-useless-call
+   */
+  'no-useless-call'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unnecessary `catch` clauses
+   * @see https://eslint.org/docs/latest/rules/no-useless-catch
+   */
+  'no-useless-catch'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unnecessary computed property keys in objects and classes
+   * @see https://eslint.org/docs/latest/rules/no-useless-computed-key
+   */
+  'no-useless-computed-key'?: Linter.RuleEntry<NoUselessComputedKey>
+  /**
+   * Disallow unnecessary concatenation of literals or template literals
+   * @see https://eslint.org/docs/latest/rules/no-useless-concat
+   */
+  'no-useless-concat'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unnecessary constructors
+   * @see https://eslint.org/docs/latest/rules/no-useless-constructor
+   */
+  'no-useless-constructor'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow unnecessary escape characters
+   * @see https://eslint.org/docs/latest/rules/no-useless-escape
+   */
+  'no-useless-escape'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow renaming import, export, and destructured assignments to the same name
+   * @see https://eslint.org/docs/latest/rules/no-useless-rename
+   */
+  'no-useless-rename'?: Linter.RuleEntry<NoUselessRename>
+  /**
+   * Disallow redundant return statements
+   * @see https://eslint.org/docs/latest/rules/no-useless-return
+   */
+  'no-useless-return'?: Linter.RuleEntry<[]>
+  /**
+   * Require `let` or `const` instead of `var`
+   * @see https://eslint.org/docs/latest/rules/no-var
+   */
+  'no-var'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `void` operators
+   * @see https://eslint.org/docs/latest/rules/no-void
+   */
+  'no-void'?: Linter.RuleEntry<NoVoid>
+  /**
+   * Disallow specified warning terms in comments
+   * @see https://eslint.org/docs/latest/rules/no-warning-comments
+   */
+  'no-warning-comments'?: Linter.RuleEntry<NoWarningComments>
+  /**
+   * Disallow whitespace before properties
+   * @see https://eslint.org/docs/latest/rules/no-whitespace-before-property
+   * @deprecated
+   */
+  'no-whitespace-before-property'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `with` statements
+   * @see https://eslint.org/docs/latest/rules/no-with
+   */
+  'no-with'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce the location of single-line statements
+   * @see https://eslint.org/docs/latest/rules/nonblock-statement-body-position
+   * @deprecated
+   */
+  'nonblock-statement-body-position'?: Linter.RuleEntry<NonblockStatementBodyPosition>
+  /**
+   * Enforce consistent line breaks after opening and before closing braces
+   * @see https://eslint.org/docs/latest/rules/object-curly-newline
+   * @deprecated
+   */
+  'object-curly-newline'?: Linter.RuleEntry<ObjectCurlyNewline>
+  /**
+   * Enforce consistent spacing inside braces
+   * @see https://eslint.org/docs/latest/rules/object-curly-spacing
+   * @deprecated
+   */
+  'object-curly-spacing'?: Linter.RuleEntry<ObjectCurlySpacing>
+  /**
+   * Enforce placing object properties on separate lines
+   * @see https://eslint.org/docs/latest/rules/object-property-newline
+   * @deprecated
+   */
+  'object-property-newline'?: Linter.RuleEntry<ObjectPropertyNewline>
+  /**
+   * Require or disallow method and property shorthand syntax for object literals
+   * @see https://eslint.org/docs/latest/rules/object-shorthand
+   */
+  'object-shorthand'?: Linter.RuleEntry<ObjectShorthand>
+  /**
+   * Enforce variables to be declared either together or separately in functions
+   * @see https://eslint.org/docs/latest/rules/one-var
+   */
+  'one-var'?: Linter.RuleEntry<OneVar>
+  /**
+   * Require or disallow newlines around variable declarations
+   * @see https://eslint.org/docs/latest/rules/one-var-declaration-per-line
+   * @deprecated
+   */
+  'one-var-declaration-per-line'?: Linter.RuleEntry<OneVarDeclarationPerLine>
+  /**
+   * Require or disallow assignment operator shorthand where possible
+   * @see https://eslint.org/docs/latest/rules/operator-assignment
+   */
+  'operator-assignment'?: Linter.RuleEntry<OperatorAssignment>
+  /**
+   * Enforce consistent linebreak style for operators
+   * @see https://eslint.org/docs/latest/rules/operator-linebreak
+   * @deprecated
+   */
+  'operator-linebreak'?: Linter.RuleEntry<OperatorLinebreak>
+  /**
+   * Require or disallow padding within blocks
+   * @see https://eslint.org/docs/latest/rules/padded-blocks
+   * @deprecated
+   */
+  'padded-blocks'?: Linter.RuleEntry<PaddedBlocks>
+  /**
+   * Require or disallow padding lines between statements
+   * @see https://eslint.org/docs/latest/rules/padding-line-between-statements
+   * @deprecated
+   */
+  'padding-line-between-statements'?: Linter.RuleEntry<PaddingLineBetweenStatements>
+  /**
+   * Enforce sorted arrays before include method.
+   * @see https://perfectionist.dev/rules/sort-array-includes
+   */
+  'perfectionist/sort-array-includes'?: Linter.RuleEntry<PerfectionistSortArrayIncludes>
+  /**
+   * Enforce sorted Astro attributes.
+   * @see https://perfectionist.dev/rules/sort-astro-attributes
+   */
+  'perfectionist/sort-astro-attributes'?: Linter.RuleEntry<PerfectionistSortAstroAttributes>
+  /**
+   * Enforce sorted classes.
+   * @see https://perfectionist.dev/rules/sort-classes
+   */
+  'perfectionist/sort-classes'?: Linter.RuleEntry<PerfectionistSortClasses>
+  /**
+   * Enforce sorted TypeScript enums.
+   * @see https://perfectionist.dev/rules/sort-enums
+   */
+  'perfectionist/sort-enums'?: Linter.RuleEntry<PerfectionistSortEnums>
+  /**
+   * Enforce sorted exports.
+   * @see https://perfectionist.dev/rules/sort-exports
+   */
+  'perfectionist/sort-exports'?: Linter.RuleEntry<PerfectionistSortExports>
+  /**
+   * Enforce sorted imports.
+   * @see https://perfectionist.dev/rules/sort-imports
+   */
+  'perfectionist/sort-imports'?: Linter.RuleEntry<PerfectionistSortImports>
+  /**
+   * Enforce sorted interface properties.
+   * @see https://perfectionist.dev/rules/sort-interfaces
+   */
+  'perfectionist/sort-interfaces'?: Linter.RuleEntry<PerfectionistSortInterfaces>
+  /**
+   * Enforce sorted intersection types.
+   * @see https://perfectionist.dev/rules/sort-intersection-types
+   */
+  'perfectionist/sort-intersection-types'?: Linter.RuleEntry<PerfectionistSortIntersectionTypes>
+  /**
+   * Enforce sorted JSX props.
+   * @see https://perfectionist.dev/rules/sort-jsx-props
+   */
+  'perfectionist/sort-jsx-props'?: Linter.RuleEntry<PerfectionistSortJsxProps>
+  /**
+   * Enforce sorted Map elements.
+   * @see https://perfectionist.dev/rules/sort-maps
+   */
+  'perfectionist/sort-maps'?: Linter.RuleEntry<PerfectionistSortMaps>
+  /**
+   * Enforce sorted named exports.
+   * @see https://perfectionist.dev/rules/sort-named-exports
+   */
+  'perfectionist/sort-named-exports'?: Linter.RuleEntry<PerfectionistSortNamedExports>
+  /**
+   * Enforce sorted named imports.
+   * @see https://perfectionist.dev/rules/sort-named-imports
+   */
+  'perfectionist/sort-named-imports'?: Linter.RuleEntry<PerfectionistSortNamedImports>
+  /**
+   * Enforce sorted object types.
+   * @see https://perfectionist.dev/rules/sort-object-types
+   */
+  'perfectionist/sort-object-types'?: Linter.RuleEntry<PerfectionistSortObjectTypes>
+  /**
+   * Enforce sorted objects.
+   * @see https://perfectionist.dev/rules/sort-objects
+   */
+  'perfectionist/sort-objects'?: Linter.RuleEntry<PerfectionistSortObjects>
+  /**
+   * Enforce sorted sets.
+   * @see https://perfectionist.dev/rules/sort-sets
+   */
+  'perfectionist/sort-sets'?: Linter.RuleEntry<PerfectionistSortSets>
+  /**
+   * Enforce sorted Svelte attributes.
+   * @see https://perfectionist.dev/rules/sort-svelte-attributes
+   */
+  'perfectionist/sort-svelte-attributes'?: Linter.RuleEntry<PerfectionistSortSvelteAttributes>
+  /**
+   * Enforce sorted switch cases.
+   * @see https://perfectionist.dev/rules/sort-switch-case
+   */
+  'perfectionist/sort-switch-case'?: Linter.RuleEntry<PerfectionistSortSwitchCase>
+  /**
+   * Enforce sorted union types.
+   * @see https://perfectionist.dev/rules/sort-union-types
+   */
+  'perfectionist/sort-union-types'?: Linter.RuleEntry<PerfectionistSortUnionTypes>
+  /**
+   * Enforce sorted variable declarations.
+   * @see https://perfectionist.dev/rules/sort-variable-declarations
+   */
+  'perfectionist/sort-variable-declarations'?: Linter.RuleEntry<PerfectionistSortVariableDeclarations>
+  /**
+   * Enforce sorted Vue attributes.
+   * @see https://perfectionist.dev/rules/sort-vue-attributes
+   */
+  'perfectionist/sort-vue-attributes'?: Linter.RuleEntry<PerfectionistSortVueAttributes>
+  /**
+   * Require using arrow functions for callbacks
+   * @see https://eslint.org/docs/latest/rules/prefer-arrow-callback
+   */
+  'prefer-arrow-callback'?: Linter.RuleEntry<PreferArrowCallback>
+  /**
+   * Require `const` declarations for variables that are never reassigned after declared
+   * @see https://eslint.org/docs/latest/rules/prefer-const
+   */
+  'prefer-const'?: Linter.RuleEntry<PreferConst>
+  /**
+   * Require destructuring from arrays and/or objects
+   * @see https://eslint.org/docs/latest/rules/prefer-destructuring
+   */
+  'prefer-destructuring'?: Linter.RuleEntry<PreferDestructuring>
+  /**
+   * Disallow the use of `Math.pow` in favor of the `**` operator
+   * @see https://eslint.org/docs/latest/rules/prefer-exponentiation-operator
+   */
+  'prefer-exponentiation-operator'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce using named capture group in regular expression
+   * @see https://eslint.org/docs/latest/rules/prefer-named-capture-group
+   */
+  'prefer-named-capture-group'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals
+   * @see https://eslint.org/docs/latest/rules/prefer-numeric-literals
+   */
+  'prefer-numeric-literals'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`
+   * @see https://eslint.org/docs/latest/rules/prefer-object-has-own
+   */
+  'prefer-object-has-own'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead
+   * @see https://eslint.org/docs/latest/rules/prefer-object-spread
+   */
+  'prefer-object-spread'?: Linter.RuleEntry<[]>
+  /**
+   * Require using Error objects as Promise rejection reasons
+   * @see https://eslint.org/docs/latest/rules/prefer-promise-reject-errors
+   */
+  'prefer-promise-reject-errors'?: Linter.RuleEntry<PreferPromiseRejectErrors>
+  /**
+   * Require `Reflect` methods where applicable
+   * @see https://eslint.org/docs/latest/rules/prefer-reflect
+   * @deprecated
+   */
+  'prefer-reflect'?: Linter.RuleEntry<PreferReflect>
+  /**
+   * Disallow use of the `RegExp` constructor in favor of regular expression literals
+   * @see https://eslint.org/docs/latest/rules/prefer-regex-literals
+   */
+  'prefer-regex-literals'?: Linter.RuleEntry<PreferRegexLiterals>
+  /**
+   * Require rest parameters instead of `arguments`
+   * @see https://eslint.org/docs/latest/rules/prefer-rest-params
+   */
+  'prefer-rest-params'?: Linter.RuleEntry<[]>
+  /**
+   * Require spread operators instead of `.apply()`
+   * @see https://eslint.org/docs/latest/rules/prefer-spread
+   */
+  'prefer-spread'?: Linter.RuleEntry<[]>
+  /**
+   * Require template literals instead of string concatenation
+   * @see https://eslint.org/docs/latest/rules/prefer-template
+   */
+  'prefer-template'?: Linter.RuleEntry<[]>
+  /**
+   * Require quotes around object literal property names
+   * @see https://eslint.org/docs/latest/rules/quote-props
+   * @deprecated
+   */
+  'quote-props'?: Linter.RuleEntry<QuoteProps>
+  /**
+   * Enforce the consistent use of either backticks, double, or single quotes
+   * @see https://eslint.org/docs/latest/rules/quotes
+   * @deprecated
+   */
+  'quotes'?: Linter.RuleEntry<Quotes>
+  /**
+   * Enforce the consistent use of the radix argument when using `parseInt()`
+   * @see https://eslint.org/docs/latest/rules/radix
+   */
+  'radix'?: Linter.RuleEntry<Radix>
+  /**
+   * Disallow assignments that can lead to race conditions due to usage of `await` or `yield`
+   * @see https://eslint.org/docs/latest/rules/require-atomic-updates
+   */
+  'require-atomic-updates'?: Linter.RuleEntry<RequireAtomicUpdates>
+  /**
+   * Disallow async functions which have no `await` expression
+   * @see https://eslint.org/docs/latest/rules/require-await
+   */
+  'require-await'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce the use of `u` or `v` flag on RegExp
+   * @see https://eslint.org/docs/latest/rules/require-unicode-regexp
+   */
+  'require-unicode-regexp'?: Linter.RuleEntry<RequireUnicodeRegexp>
+  /**
+   * Require generator functions to contain `yield`
+   * @see https://eslint.org/docs/latest/rules/require-yield
+   */
+  'require-yield'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce spacing between rest and spread operators and their expressions
+   * @see https://eslint.org/docs/latest/rules/rest-spread-spacing
+   * @deprecated
+   */
+  'rest-spread-spacing'?: Linter.RuleEntry<RestSpreadSpacing>
+  /**
+   * Require or disallow semicolons instead of ASI
+   * @see https://eslint.org/docs/latest/rules/semi
+   * @deprecated
+   */
+  'semi'?: Linter.RuleEntry<Semi>
+  /**
+   * Enforce consistent spacing before and after semicolons
+   * @see https://eslint.org/docs/latest/rules/semi-spacing
+   * @deprecated
+   */
+  'semi-spacing'?: Linter.RuleEntry<SemiSpacing>
+  /**
+   * Enforce location of semicolons
+   * @see https://eslint.org/docs/latest/rules/semi-style
+   * @deprecated
+   */
+  'semi-style'?: Linter.RuleEntry<SemiStyle>
+  /**
+   * Enforce sorted import declarations within modules
+   * @see https://eslint.org/docs/latest/rules/sort-imports
+   */
+  'sort-imports'?: Linter.RuleEntry<SortImports>
+  /**
+   * Require object keys to be sorted
+   * @see https://eslint.org/docs/latest/rules/sort-keys
+   */
+  'sort-keys'?: Linter.RuleEntry<SortKeys>
+  /**
+   * Require variables within the same declaration block to be sorted
+   * @see https://eslint.org/docs/latest/rules/sort-vars
+   */
+  'sort-vars'?: Linter.RuleEntry<SortVars>
+  /**
+   * Enforce consistent spacing before blocks
+   * @see https://eslint.org/docs/latest/rules/space-before-blocks
+   * @deprecated
+   */
+  'space-before-blocks'?: Linter.RuleEntry<SpaceBeforeBlocks>
+  /**
+   * Enforce consistent spacing before `function` definition opening parenthesis
+   * @see https://eslint.org/docs/latest/rules/space-before-function-paren
+   * @deprecated
+   */
+  'space-before-function-paren'?: Linter.RuleEntry<SpaceBeforeFunctionParen>
+  /**
+   * Enforce consistent spacing inside parentheses
+   * @see https://eslint.org/docs/latest/rules/space-in-parens
+   * @deprecated
+   */
+  'space-in-parens'?: Linter.RuleEntry<SpaceInParens>
+  /**
+   * Require spacing around infix operators
+   * @see https://eslint.org/docs/latest/rules/space-infix-ops
+   * @deprecated
+   */
+  'space-infix-ops'?: Linter.RuleEntry<SpaceInfixOps>
+  /**
+   * Enforce consistent spacing before or after unary operators
+   * @see https://eslint.org/docs/latest/rules/space-unary-ops
+   * @deprecated
+   */
+  'space-unary-ops'?: Linter.RuleEntry<SpaceUnaryOps>
+  /**
+   * Enforce consistent spacing after the `//` or `/*` in a comment
+   * @see https://eslint.org/docs/latest/rules/spaced-comment
+   * @deprecated
+   */
+  'spaced-comment'?: Linter.RuleEntry<SpacedComment>
+  /**
+   * Require or disallow strict mode directives
+   * @see https://eslint.org/docs/latest/rules/strict
+   */
+  'strict'?: Linter.RuleEntry<Strict>
+  /**
+   * Enforce spacing around colons of switch statements
+   * @see https://eslint.org/docs/latest/rules/switch-colon-spacing
+   * @deprecated
+   */
+  'switch-colon-spacing'?: Linter.RuleEntry<SwitchColonSpacing>
+  /**
+   * Require symbol descriptions
+   * @see https://eslint.org/docs/latest/rules/symbol-description
+   */
+  'symbol-description'?: Linter.RuleEntry<[]>
+  /**
+   * Require or disallow spacing around embedded expressions of template strings
+   * @see https://eslint.org/docs/latest/rules/template-curly-spacing
+   * @deprecated
+   */
+  'template-curly-spacing'?: Linter.RuleEntry<TemplateCurlySpacing>
+  /**
+   * Require or disallow spacing between template tags and their literals
+   * @see https://eslint.org/docs/latest/rules/template-tag-spacing
+   * @deprecated
+   */
+  'template-tag-spacing'?: Linter.RuleEntry<TemplateTagSpacing>
+  /**
+   * Require or disallow Unicode byte order mark (BOM)
+   * @see https://eslint.org/docs/latest/rules/unicode-bom
+   */
+  'unicode-bom'?: Linter.RuleEntry<UnicodeBom>
+  /**
+   * Disallow unused variables
+   * @see https://github.com/sweepline/eslint-plugin-unused-imports/blob/master/docs/rules/no-unused-imports.md
+   */
+  'unused-imports/no-unused-imports'?: Linter.RuleEntry<UnusedImportsNoUnusedImports>
+  /**
+   * Disallow unused variables
+   * @see https://github.com/sweepline/eslint-plugin-unused-imports/blob/master/docs/rules/no-unused-vars.md
+   */
+  'unused-imports/no-unused-vars'?: Linter.RuleEntry<UnusedImportsNoUnusedVars>
+  /**
+   * Require calls to `isNaN()` when checking for `NaN`
+   * @see https://eslint.org/docs/latest/rules/use-isnan
+   */
+  'use-isnan'?: Linter.RuleEntry<UseIsnan>
+  /**
+   * Enforce comparing `typeof` expressions against valid strings
+   * @see https://eslint.org/docs/latest/rules/valid-typeof
+   */
+  'valid-typeof'?: Linter.RuleEntry<ValidTypeof>
+  /**
+   * Require `var` declarations be placed at the top of their containing scope
+   * @see https://eslint.org/docs/latest/rules/vars-on-top
+   */
+  'vars-on-top'?: Linter.RuleEntry<[]>
+  /**
+   * require .spec test file pattern
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/consistent-test-filename.md
+   */
+  'vitest/consistent-test-filename'?: Linter.RuleEntry<VitestConsistentTestFilename>
+  /**
+   * enforce using test or it but not both
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/consistent-test-it.md
+   */
+  'vitest/consistent-test-it'?: Linter.RuleEntry<VitestConsistentTestIt>
+  /**
+   * enforce having expectation in test body
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/expect-expect.md
+   */
+  'vitest/expect-expect'?: Linter.RuleEntry<VitestExpectExpect>
+  /**
+   * enforce a maximum number of expect per test
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/max-expects.md
+   */
+  'vitest/max-expects'?: Linter.RuleEntry<VitestMaxExpects>
+  /**
+   * require describe block to be less than set max value or default value
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/max-nested-describe.md
+   */
+  'vitest/max-nested-describe'?: Linter.RuleEntry<VitestMaxNestedDescribe>
+  /**
+   * disallow alias methods
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-alias-methods.md
+   */
+  'vitest/no-alias-methods'?: Linter.RuleEntry<[]>
+  /**
+   * disallow commented out tests
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-commented-out-tests.md
+   */
+  'vitest/no-commented-out-tests'?: Linter.RuleEntry<[]>
+  /**
+   * disallow conditional expects
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-expect.md
+   */
+  'vitest/no-conditional-expect'?: Linter.RuleEntry<[]>
+  /**
+   * disallow conditional tests
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-in-test.md
+   */
+  'vitest/no-conditional-in-test'?: Linter.RuleEntry<[]>
+  /**
+   * disallow conditional tests
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-conditional-tests.md
+   */
+  'vitest/no-conditional-tests'?: Linter.RuleEntry<[]>
+  /**
+   * disallow disabled tests
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-disabled-tests.md
+   */
+  'vitest/no-disabled-tests'?: Linter.RuleEntry<[]>
+  /**
+   * disallow using a callback in asynchronous tests and hooks
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-done-callback.md
+   * @deprecated
+   */
+  'vitest/no-done-callback'?: Linter.RuleEntry<[]>
+  /**
+   * disallow duplicate hooks and teardown hooks
+   * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-duplicate-hooks.md
+   */
+  'vitest/no-duplicate-hooks'?: Linter.RuleEntry<[]>
   /**
    * disallow focused tests
    * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/no-focused-tests.md
@@ -1621,6 +3141,29 @@ export interface Rules {
    * @see https://github.com/vitest-dev/eslint-plugin-vitest/blob/main/docs/rules/valid-expect.md
    */
   'vitest/valid-expect'?: Linter.RuleEntry<VitestValidExpect>
+  /**
+   * Require parentheses around immediate `function` invocations
+   * @see https://eslint.org/docs/latest/rules/wrap-iife
+   * @deprecated
+   */
+  'wrap-iife'?: Linter.RuleEntry<WrapIife>
+  /**
+   * Require parenthesis around regex literals
+   * @see https://eslint.org/docs/latest/rules/wrap-regex
+   * @deprecated
+   */
+  'wrap-regex'?: Linter.RuleEntry<[]>
+  /**
+   * Require or disallow spacing around the `*` in `yield*` expressions
+   * @see https://eslint.org/docs/latest/rules/yield-star-spacing
+   * @deprecated
+   */
+  'yield-star-spacing'?: Linter.RuleEntry<YieldStarSpacing>
+  /**
+   * Require or disallow "Yoda" conditions
+   * @see https://eslint.org/docs/latest/rules/yoda
+   */
+  'yoda'?: Linter.RuleEntry<Yoda>
 }
 
 /* ======= Declarations ======= */
@@ -2713,6 +4256,146 @@ type TypescriptEslintUnifiedSignatures = []|[{
   
   ignoreDifferentlyNamedParameters?: boolean
 }]
+// ----- accessor-pairs -----
+type AccessorPairs = []|[{
+  getWithoutSet?: boolean
+  setWithoutGet?: boolean
+  enforceForClassMembers?: boolean
+}]
+// ----- array-bracket-newline -----
+type ArrayBracketNewline = []|[(("always" | "never" | "consistent") | {
+  multiline?: boolean
+  minItems?: (number | null)
+})]
+// ----- array-bracket-spacing -----
+type ArrayBracketSpacing = []|[("always" | "never")]|[("always" | "never"), {
+  singleValue?: boolean
+  objectsInArrays?: boolean
+  arraysInArrays?: boolean
+}]
+// ----- array-callback-return -----
+type ArrayCallbackReturn = []|[{
+  allowImplicit?: boolean
+  checkForEach?: boolean
+  allowVoid?: boolean
+}]
+// ----- array-element-newline -----
+type ArrayElementNewline = []|[(_ArrayElementNewlineBasicConfig | {
+  ArrayExpression?: _ArrayElementNewlineBasicConfig
+  ArrayPattern?: _ArrayElementNewlineBasicConfig
+})]
+type _ArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
+  multiline?: boolean
+  minItems?: (number | null)
+})
+// ----- arrow-body-style -----
+type ArrowBodyStyle = ([]|[("always" | "never")] | []|["as-needed"]|["as-needed", {
+  requireReturnForObjectLiteral?: boolean
+}])
+// ----- arrow-parens -----
+type ArrowParens = []|[("always" | "as-needed")]|[("always" | "as-needed"), {
+  requireForBlockBody?: boolean
+}]
+// ----- arrow-spacing -----
+type ArrowSpacing = []|[{
+  before?: boolean
+  after?: boolean
+}]
+// ----- block-spacing -----
+type BlockSpacing = []|[("always" | "never")]
+// ----- brace-style -----
+type BraceStyle = []|[("1tbs" | "stroustrup" | "allman")]|[("1tbs" | "stroustrup" | "allman"), {
+  allowSingleLine?: boolean
+}]
+// ----- callback-return -----
+type CallbackReturn = []|[string[]]
+// ----- camelcase -----
+type Camelcase = []|[{
+  ignoreDestructuring?: boolean
+  ignoreImports?: boolean
+  ignoreGlobals?: boolean
+  properties?: ("always" | "never")
+  
+  allow?: string[]
+}]
+// ----- capitalized-comments -----
+type CapitalizedComments = []|[("always" | "never")]|[("always" | "never"), ({
+  ignorePattern?: string
+  ignoreInlineComments?: boolean
+  ignoreConsecutiveComments?: boolean
+} | {
+  line?: {
+    ignorePattern?: string
+    ignoreInlineComments?: boolean
+    ignoreConsecutiveComments?: boolean
+  }
+  block?: {
+    ignorePattern?: string
+    ignoreInlineComments?: boolean
+    ignoreConsecutiveComments?: boolean
+  }
+})]
+// ----- class-methods-use-this -----
+type ClassMethodsUseThis = []|[{
+  exceptMethods?: string[]
+  enforceForClassFields?: boolean
+}]
+// ----- comma-dangle -----
+type CommaDangle = []|[(_CommaDangleValue | {
+  arrays?: _CommaDangleValueWithIgnore
+  objects?: _CommaDangleValueWithIgnore
+  imports?: _CommaDangleValueWithIgnore
+  exports?: _CommaDangleValueWithIgnore
+  functions?: _CommaDangleValueWithIgnore
+})]
+type _CommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline")
+type _CommaDangleValueWithIgnore = ("always-multiline" | "always" | "ignore" | "never" | "only-multiline")
+// ----- comma-spacing -----
+type CommaSpacing = []|[{
+  before?: boolean
+  after?: boolean
+}]
+// ----- comma-style -----
+type CommaStyle = []|[("first" | "last")]|[("first" | "last"), {
+  exceptions?: {
+    [k: string]: boolean | undefined
+  }
+}]
+// ----- complexity -----
+type Complexity = []|[(number | {
+  maximum?: number
+  max?: number
+  variant?: ("classic" | "modified")
+})]
+// ----- computed-property-spacing -----
+type ComputedPropertySpacing = []|[("always" | "never")]|[("always" | "never"), {
+  enforceForClassMembers?: boolean
+}]
+// ----- consistent-return -----
+type ConsistentReturn = []|[{
+  treatUndefinedAsUnspecified?: boolean
+}]
+// ----- consistent-this -----
+type ConsistentThis = string[]
+// ----- curly -----
+type Curly = ([]|["all"] | []|[("multi" | "multi-line" | "multi-or-nest")]|[("multi" | "multi-line" | "multi-or-nest"), "consistent"])
+// ----- default-case -----
+type DefaultCase = []|[{
+  commentPattern?: string
+}]
+// ----- dot-location -----
+type DotLocation = []|[("object" | "property")]
+// ----- dot-notation -----
+type DotNotation = []|[{
+  allowKeywords?: boolean
+  allowPattern?: string
+}]
+// ----- eol-last -----
+type EolLast = []|[("always" | "never" | "unix" | "windows")]
+// ----- eqeqeq -----
+type Eqeqeq = ([]|["always"]|["always", {
+  null?: ("always" | "never" | "ignore")
+}] | []|[("smart" | "allow-null")])
 // ----- eslint-comments/disable-enable-pair -----
 type EslintCommentsDisableEnablePair = []|[{
   allowWholeFile?: boolean
@@ -2727,6 +4410,82 @@ type EslintCommentsNoUse = []|[{
 type EslintCommentsRequireDescription = []|[{
   ignore?: ("eslint" | "eslint-disable" | "eslint-disable-line" | "eslint-disable-next-line" | "eslint-enable" | "eslint-env" | "exported" | "global" | "globals")[]
 }]
+// ----- func-call-spacing -----
+type FuncCallSpacing = ([]|["never"] | []|["always"]|["always", {
+  allowNewlines?: boolean
+}])
+// ----- func-name-matching -----
+type FuncNameMatching = ([]|[("always" | "never")]|[("always" | "never"), {
+  considerPropertyDescriptor?: boolean
+  includeCommonJSModuleExports?: boolean
+}] | []|[{
+  considerPropertyDescriptor?: boolean
+  includeCommonJSModuleExports?: boolean
+}])
+// ----- func-names -----
+type FuncNames = []|[_FuncNamesValue]|[_FuncNamesValue, {
+  generators?: _FuncNamesValue
+}]
+type _FuncNamesValue = ("always" | "as-needed" | "never")
+// ----- func-style -----
+type FuncStyle = []|[("declaration" | "expression")]|[("declaration" | "expression"), {
+  allowArrowFunctions?: boolean
+  overrides?: {
+    namedExports?: ("declaration" | "expression" | "ignore")
+  }
+}]
+// ----- function-call-argument-newline -----
+type FunctionCallArgumentNewline = []|[("always" | "never" | "consistent")]
+// ----- function-paren-newline -----
+type FunctionParenNewline = []|[(("always" | "never" | "consistent" | "multiline" | "multiline-arguments") | {
+  minItems?: number
+})]
+// ----- generator-star-spacing -----
+type GeneratorStarSpacing = []|[(("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
+  })
+})]
+// ----- getter-return -----
+type GetterReturn = []|[{
+  allowImplicit?: boolean
+}]
+// ----- grouped-accessor-pairs -----
+type GroupedAccessorPairs = []|[("anyOrder" | "getBeforeSet" | "setBeforeGet")]
+// ----- handle-callback-err -----
+type HandleCallbackErr = []|[string]
+// ----- id-blacklist -----
+type IdBlacklist = string[]
+// ----- id-denylist -----
+type IdDenylist = string[]
+// ----- id-length -----
+type IdLength = []|[{
+  min?: number
+  max?: number
+  exceptions?: string[]
+  exceptionPatterns?: string[]
+  properties?: ("always" | "never")
+}]
+// ----- id-match -----
+type IdMatch = []|[string]|[string, {
+  properties?: boolean
+  classFields?: boolean
+  onlyDeclarations?: boolean
+  ignoreDestructuring?: boolean
+}]
+// ----- implicit-arrow-linebreak -----
+type ImplicitArrowLinebreak = []|[("beside" | "below")]
 // ----- import-x/consistent-type-specifier-style -----
 type ImportXConsistentTypeSpecifierStyle = []|[("prefer-inline" | "prefer-top-level")]
 // ----- import-x/dynamic-import-chunkname -----
@@ -2957,6 +4716,70 @@ type ImportXOrder = []|[{
 type ImportXPreferDefaultExport = []|[{
   target?: ("single" | "any")
 }]
+// ----- indent -----
+type Indent = []|[("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
+  ignoredNodes?: string[]
+  ignoreComments?: boolean
+}]
+// ----- indent-legacy -----
+type IndentLegacy = []|[("tab" | number)]|[("tab" | number), {
+  SwitchCase?: number
+  VariableDeclarator?: (number | {
+    var?: number
+    let?: number
+    const?: number
+    [k: string]: unknown | undefined
+  })
+  outerIIFEBody?: number
+  MemberExpression?: number
+  FunctionDeclaration?: {
+    parameters?: (number | "first")
+    body?: number
+    [k: string]: unknown | undefined
+  }
+  FunctionExpression?: {
+    parameters?: (number | "first")
+    body?: number
+    [k: string]: unknown | undefined
+  }
+  CallExpression?: {
+    parameters?: (number | "first")
+    [k: string]: unknown | undefined
+  }
+  ArrayExpression?: (number | "first")
+  ObjectExpression?: (number | "first")
+}]
+// ----- init-declarations -----
+type InitDeclarations = ([]|["always"] | []|["never"]|["never", {
+  ignoreForLoopInit?: boolean
+}])
 // ----- jsdoc/check-examples -----
 type JsdocCheckExamples = []|[{
   allowInlineConfig?: boolean
@@ -3283,139 +5106,1123 @@ type JsdocRequireParam = []|[{
   unnamedRootBase?: string[]
   useDefaultObjectProperties?: boolean
 }]
-// ----- jsdoc/require-param-description -----
-type JsdocRequireParamDescription = []|[{
-  contexts?: (string | {
-    comment?: string
-    context?: string
-  })[]
-  defaultDestructuredRootDescription?: string
-  setDefaultDestructuredRootDescription?: boolean
+// ----- jsdoc/require-param-description -----
+type JsdocRequireParamDescription = []|[{
+  contexts?: (string | {
+    comment?: string
+    context?: string
+  })[]
+  defaultDestructuredRootDescription?: string
+  setDefaultDestructuredRootDescription?: boolean
+}]
+// ----- jsdoc/require-param-name -----
+type JsdocRequireParamName = []|[{
+  contexts?: (string | {
+    comment?: string
+    context?: string
+  })[]
+}]
+// ----- jsdoc/require-param-type -----
+type JsdocRequireParamType = []|[{
+  contexts?: (string | {
+    comment?: string
+    context?: string
+  })[]
+  defaultDestructuredRootType?: string
+  setDefaultDestructuredRootType?: boolean
+}]
+// ----- jsdoc/require-returns -----
+type JsdocRequireReturns = []|[{
+  checkConstructors?: boolean
+  checkGetters?: boolean
+  contexts?: (string | {
+    comment?: string
+    context?: string
+    forceRequireReturn?: boolean
+  })[]
+  enableFixer?: boolean
+  exemptedBy?: string[]
+  forceRequireReturn?: boolean
+  forceReturnsWithAsync?: boolean
+  publicOnly?: (boolean | {
+    ancestorsOnly?: boolean
+    cjs?: boolean
+    esm?: boolean
+    window?: boolean
+  })
+}]
+// ----- jsdoc/require-returns-check -----
+type JsdocRequireReturnsCheck = []|[{
+  exemptAsync?: boolean
+  exemptGenerators?: boolean
+  reportMissingReturnForUndefinedTypes?: boolean
+}]
+// ----- jsdoc/require-returns-description -----
+type JsdocRequireReturnsDescription = []|[{
+  contexts?: (string | {
+    comment?: string
+    context?: string
+  })[]
+}]
+// ----- jsdoc/require-returns-type -----
+type JsdocRequireReturnsType = []|[{
+  contexts?: (string | {
+    comment?: string
+    context?: string
+  })[]
+}]
+// ----- jsdoc/require-template -----
+type JsdocRequireTemplate = []|[{
+  requireSeparateTemplates?: boolean
+}]
+// ----- jsdoc/require-throws -----
+type JsdocRequireThrows = []|[{
+  contexts?: (string | {
+    comment?: string
+    context?: string
+  })[]
+  exemptedBy?: string[]
+}]
+// ----- jsdoc/require-yields -----
+type JsdocRequireYields = []|[{
+  contexts?: (string | {
+    comment?: string
+    context?: string
+  })[]
+  exemptedBy?: string[]
+  forceRequireNext?: boolean
+  forceRequireYields?: boolean
+  next?: boolean
+  nextWithGeneratorTag?: boolean
+  withGeneratorTag?: boolean
+}]
+// ----- jsdoc/require-yields-check -----
+type JsdocRequireYieldsCheck = []|[{
+  checkGeneratorsOnly?: boolean
+  contexts?: (string | {
+    comment?: string
+    context?: string
+  })[]
+  exemptedBy?: string[]
+  next?: boolean
+}]
+// ----- jsdoc/sort-tags -----
+type JsdocSortTags = []|[{
+  alphabetizeExtras?: boolean
+  linesBetween?: number
+  reportIntraTagGroupSpacing?: boolean
+  reportTagGroupSpacing?: boolean
+  tagSequence?: {
+    tags?: string[]
+    [k: string]: unknown | undefined
+  }[]
+}]
+// ----- jsdoc/tag-lines -----
+type JsdocTagLines = []|[("always" | "any" | "never")]|[("always" | "any" | "never"), {
+  applyToEndTag?: boolean
+  count?: number
+  endLines?: (number | null)
+  startLines?: (number | null)
+  tags?: {
+    [k: string]: {
+      count?: number
+      lines?: ("always" | "never" | "any")
+    }
+  }
+}]
+// ----- jsdoc/text-escaping -----
+type JsdocTextEscaping = []|[{
+  escapeHTML?: boolean
+  escapeMarkdown?: boolean
+}]
+// ----- jsdoc/valid-types -----
+type JsdocValidTypes = []|[{
+  allowEmptyNamepaths?: boolean
+}]
+// ----- jsx-quotes -----
+type JsxQuotes = []|[("prefer-single" | "prefer-double")]
+// ----- key-spacing -----
+type KeySpacing = []|[({
+  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?: {
+    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
+  }
+})]
+// ----- keyword-spacing -----
+type KeywordSpacing = []|[{
+  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
+    }
+    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
+    }
+  }
+}]
+// ----- line-comment-position -----
+type LineCommentPosition = []|[(("above" | "beside") | {
+  position?: ("above" | "beside")
+  ignorePattern?: string
+  applyDefaultPatterns?: boolean
+  applyDefaultIgnorePatterns?: boolean
+})]
+// ----- linebreak-style -----
+type LinebreakStyle = []|[("unix" | "windows")]
+// ----- lines-around-comment -----
+type LinesAroundComment = []|[{
+  beforeBlockComment?: boolean
+  afterBlockComment?: boolean
+  beforeLineComment?: boolean
+  afterLineComment?: boolean
+  allowBlockStart?: boolean
+  allowBlockEnd?: boolean
+  allowClassStart?: boolean
+  allowClassEnd?: boolean
+  allowObjectStart?: boolean
+  allowObjectEnd?: boolean
+  allowArrayStart?: boolean
+  allowArrayEnd?: boolean
+  ignorePattern?: string
+  applyDefaultIgnorePatterns?: boolean
+  afterHashbangComment?: boolean
+}]
+// ----- lines-around-directive -----
+type LinesAroundDirective = []|[(("always" | "never") | {
+  before?: ("always" | "never")
+  after?: ("always" | "never")
+})]
+// ----- lines-between-class-members -----
+type LinesBetweenClassMembers = []|[({
+  
+  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
+}]
+// ----- logical-assignment-operators -----
+type LogicalAssignmentOperators = (([]|["always"]|["always", {
+  enforceForIfStatements?: boolean
+}] | ["never"]) & unknown[])
+// ----- max-classes-per-file -----
+type MaxClassesPerFile = []|[(number | {
+  ignoreExpressions?: boolean
+  max?: number
+})]
+// ----- max-depth -----
+type MaxDepth = []|[(number | {
+  maximum?: number
+  max?: number
+})]
+// ----- max-len -----
+type MaxLen = []|[({
+  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
+}]
+// ----- max-lines -----
+type MaxLines = []|[(number | {
+  max?: number
+  skipComments?: boolean
+  skipBlankLines?: boolean
+})]
+// ----- max-lines-per-function -----
+type MaxLinesPerFunction = []|[({
+  max?: number
+  skipComments?: boolean
+  skipBlankLines?: boolean
+  IIFEs?: boolean
+} | number)]
+// ----- max-nested-callbacks -----
+type MaxNestedCallbacks = []|[(number | {
+  maximum?: number
+  max?: number
+})]
+// ----- max-params -----
+type MaxParams = []|[(number | {
+  maximum?: number
+  max?: number
+})]
+// ----- max-statements -----
+type MaxStatements = []|[(number | {
+  maximum?: number
+  max?: number
+})]|[(number | {
+  maximum?: number
+  max?: number
+}), {
+  ignoreTopLevelFunctions?: boolean
+}]
+// ----- max-statements-per-line -----
+type MaxStatementsPerLine = []|[{
+  max?: number
+}]
+// ----- multiline-comment-style -----
+type MultilineCommentStyle = ([]|[("starred-block" | "bare-block")] | []|["separate-lines"]|["separate-lines", {
+  checkJSDoc?: boolean
+}])
+// ----- multiline-ternary -----
+type MultilineTernary = []|[("always" | "always-multiline" | "never")]
+// ----- new-cap -----
+type NewCap = []|[{
+  newIsCap?: boolean
+  capIsNew?: boolean
+  newIsCapExceptions?: string[]
+  newIsCapExceptionPattern?: string
+  capIsNewExceptions?: string[]
+  capIsNewExceptionPattern?: string
+  properties?: boolean
+}]
+// ----- new-parens -----
+type NewParens = []|[("always" | "never")]
+// ----- newline-after-var -----
+type NewlineAfterVar = []|[("never" | "always")]
+// ----- newline-per-chained-call -----
+type NewlinePerChainedCall = []|[{
+  ignoreChainWithDepth?: number
+}]
+// ----- no-bitwise -----
+type NoBitwise = []|[{
+  allow?: ("^" | "|" | "&" | "<<" | ">>" | ">>>" | "^=" | "|=" | "&=" | "<<=" | ">>=" | ">>>=" | "~")[]
+  int32Hint?: boolean
+}]
+// ----- no-cond-assign -----
+type NoCondAssign = []|[("except-parens" | "always")]
+// ----- no-confusing-arrow -----
+type NoConfusingArrow = []|[{
+  allowParens?: boolean
+  onlyOneSimpleParam?: boolean
+}]
+// ----- no-console -----
+type NoConsole = []|[{
+  
+  allow?: [string, ...(string)[]]
+}]
+// ----- no-constant-condition -----
+type NoConstantCondition = []|[{
+  checkLoops?: ("all" | "allExceptWhileTrue" | "none" | true | false)
+}]
+// ----- no-duplicate-imports -----
+type NoDuplicateImports = []|[{
+  includeExports?: boolean
+}]
+// ----- no-else-return -----
+type NoElseReturn = []|[{
+  allowElseIf?: boolean
+}]
+// ----- no-empty -----
+type NoEmpty = []|[{
+  allowEmptyCatch?: boolean
+}]
+// ----- no-empty-function -----
+type NoEmptyFunction = []|[{
+  allow?: ("functions" | "arrowFunctions" | "generatorFunctions" | "methods" | "generatorMethods" | "getters" | "setters" | "constructors" | "asyncFunctions" | "asyncMethods")[]
+}]
+// ----- no-empty-pattern -----
+type NoEmptyPattern = []|[{
+  allowObjectPatternsAsParameters?: boolean
+}]
+// ----- no-eval -----
+type NoEval = []|[{
+  allowIndirect?: boolean
+}]
+// ----- no-extend-native -----
+type NoExtendNative = []|[{
+  exceptions?: string[]
+}]
+// ----- no-extra-boolean-cast -----
+type NoExtraBooleanCast = []|[({
+  enforceForInnerExpressions?: boolean
+} | {
+  enforceForLogicalOperands?: boolean
+})]
+// ----- no-extra-parens -----
+type NoExtraParens = ([]|["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
+}])
+// ----- no-fallthrough -----
+type NoFallthrough = []|[{
+  commentPattern?: string
+  allowEmptyCase?: boolean
+  reportUnusedFallthroughComment?: boolean
+}]
+// ----- no-global-assign -----
+type NoGlobalAssign = []|[{
+  exceptions?: string[]
+}]
+// ----- no-implicit-coercion -----
+type NoImplicitCoercion = []|[{
+  boolean?: boolean
+  number?: boolean
+  string?: boolean
+  disallowTemplateShorthand?: boolean
+  allow?: ("~" | "!!" | "+" | "- -" | "-" | "*")[]
+}]
+// ----- no-implicit-globals -----
+type NoImplicitGlobals = []|[{
+  lexicalBindings?: boolean
+}]
+// ----- no-inline-comments -----
+type NoInlineComments = []|[{
+  ignorePattern?: string
+}]
+// ----- no-inner-declarations -----
+type NoInnerDeclarations = []|[("functions" | "both")]|[("functions" | "both"), {
+  blockScopedFunctions?: ("allow" | "disallow")
+}]
+// ----- no-invalid-regexp -----
+type NoInvalidRegexp = []|[{
+  allowConstructorFlags?: string[]
+}]
+// ----- no-invalid-this -----
+type NoInvalidThis = []|[{
+  capIsConstructor?: boolean
+}]
+// ----- no-irregular-whitespace -----
+type NoIrregularWhitespace = []|[{
+  skipComments?: boolean
+  skipStrings?: boolean
+  skipTemplates?: boolean
+  skipRegExps?: boolean
+  skipJSXText?: boolean
+}]
+// ----- no-labels -----
+type NoLabels = []|[{
+  allowLoop?: boolean
+  allowSwitch?: boolean
+}]
+// ----- no-magic-numbers -----
+type NoMagicNumbers = []|[{
+  detectObjects?: boolean
+  enforceConst?: boolean
+  ignore?: (number | string)[]
+  ignoreArrayIndexes?: boolean
+  ignoreDefaultValues?: boolean
+  ignoreClassFieldInitialValues?: boolean
+}]
+// ----- no-misleading-character-class -----
+type NoMisleadingCharacterClass = []|[{
+  allowEscape?: boolean
 }]
-// ----- jsdoc/require-param-name -----
-type JsdocRequireParamName = []|[{
-  contexts?: (string | {
-    comment?: string
-    context?: string
-  })[]
+// ----- no-mixed-operators -----
+type NoMixedOperators = []|[{
+  groups?: [("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ...(("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"))[]][]
+  allowSamePrecedence?: boolean
 }]
-// ----- jsdoc/require-param-type -----
-type JsdocRequireParamType = []|[{
-  contexts?: (string | {
-    comment?: string
-    context?: string
-  })[]
-  defaultDestructuredRootType?: string
-  setDefaultDestructuredRootType?: boolean
+// ----- no-mixed-requires -----
+type NoMixedRequires = []|[(boolean | {
+  grouping?: boolean
+  allowCall?: boolean
+})]
+// ----- no-mixed-spaces-and-tabs -----
+type NoMixedSpacesAndTabs = []|[("smart-tabs" | true | false)]
+// ----- no-multi-assign -----
+type NoMultiAssign = []|[{
+  ignoreNonDeclaration?: boolean
+}]
+// ----- no-multi-spaces -----
+type NoMultiSpaces = []|[{
+  exceptions?: {
+    [k: string]: boolean
+  }
+  ignoreEOLComments?: boolean
 }]
-// ----- jsdoc/require-returns -----
-type JsdocRequireReturns = []|[{
-  checkConstructors?: boolean
-  checkGetters?: boolean
-  contexts?: (string | {
-    comment?: string
-    context?: string
-    forceRequireReturn?: boolean
-  })[]
-  enableFixer?: boolean
-  exemptedBy?: string[]
-  forceRequireReturn?: boolean
-  forceReturnsWithAsync?: boolean
-  publicOnly?: (boolean | {
-    ancestorsOnly?: boolean
-    cjs?: boolean
-    esm?: boolean
-    window?: boolean
-  })
+// ----- no-multiple-empty-lines -----
+type NoMultipleEmptyLines = []|[{
+  max: number
+  maxEOF?: number
+  maxBOF?: number
 }]
-// ----- jsdoc/require-returns-check -----
-type JsdocRequireReturnsCheck = []|[{
-  exemptAsync?: boolean
-  exemptGenerators?: boolean
-  reportMissingReturnForUndefinedTypes?: boolean
+// ----- no-native-reassign -----
+type NoNativeReassign = []|[{
+  exceptions?: string[]
 }]
-// ----- jsdoc/require-returns-description -----
-type JsdocRequireReturnsDescription = []|[{
-  contexts?: (string | {
-    comment?: string
-    context?: string
-  })[]
+// ----- no-param-reassign -----
+type NoParamReassign = []|[({
+  props?: false
+} | {
+  props?: true
+  ignorePropertyModificationsFor?: string[]
+  ignorePropertyModificationsForRegex?: string[]
+})]
+// ----- no-plusplus -----
+type NoPlusplus = []|[{
+  allowForLoopAfterthoughts?: boolean
 }]
-// ----- jsdoc/require-returns-type -----
-type JsdocRequireReturnsType = []|[{
-  contexts?: (string | {
-    comment?: string
-    context?: string
-  })[]
+// ----- no-promise-executor-return -----
+type NoPromiseExecutorReturn = []|[{
+  allowVoid?: boolean
 }]
-// ----- jsdoc/require-template -----
-type JsdocRequireTemplate = []|[{
-  requireSeparateTemplates?: boolean
+// ----- no-redeclare -----
+type NoRedeclare = []|[{
+  builtinGlobals?: boolean
 }]
-// ----- jsdoc/require-throws -----
-type JsdocRequireThrows = []|[{
-  contexts?: (string | {
-    comment?: string
-    context?: string
+// ----- no-restricted-exports -----
+type NoRestrictedExports = []|[({
+  restrictedNamedExports?: string[]
+  restrictedNamedExportsPattern?: string
+} | {
+  restrictedNamedExports?: string[]
+  restrictedNamedExportsPattern?: string
+  restrictDefaultExports?: {
+    direct?: boolean
+    named?: boolean
+    defaultFrom?: boolean
+    namedFrom?: boolean
+    namespaceFrom?: boolean
+  }
+})]
+// ----- no-restricted-globals -----
+type NoRestrictedGlobals = (string | {
+  name: string
+  message?: string
+})[]
+// ----- no-restricted-imports -----
+type NoRestrictedImports = ((string | {
+  name: string
+  message?: string
+  importNames?: string[]
+  allowImportNames?: string[]
+})[] | []|[{
+  paths?: (string | {
+    name: string
+    message?: string
+    importNames?: string[]
+    allowImportNames?: string[]
   })[]
-  exemptedBy?: string[]
-}]
-// ----- jsdoc/require-yields -----
-type JsdocRequireYields = []|[{
-  contexts?: (string | {
-    comment?: string
-    context?: string
+  patterns?: (string[] | ({
+    [k: string]: unknown | undefined
+  } | {
+    [k: string]: unknown | undefined
+  })[])
+}])
+// ----- no-restricted-modules -----
+type NoRestrictedModules = ((string | {
+  name: string
+  message?: string
+})[] | {
+  paths?: (string | {
+    name: string
+    message?: string
   })[]
-  exemptedBy?: string[]
-  forceRequireNext?: boolean
-  forceRequireYields?: boolean
-  next?: boolean
-  nextWithGeneratorTag?: boolean
-  withGeneratorTag?: boolean
+  patterns?: string[]
+}[])
+// ----- no-restricted-properties -----
+type NoRestrictedProperties = ({
+  object: string
+  property?: string
+  message?: string
+} | {
+  object?: string
+  property: string
+  message?: string
+})[]
+// ----- no-restricted-syntax -----
+type NoRestrictedSyntax = (string | {
+  selector: string
+  message?: string
+})[]
+// ----- no-return-assign -----
+type NoReturnAssign = []|[("except-parens" | "always")]
+// ----- no-self-assign -----
+type NoSelfAssign = []|[{
+  props?: boolean
+}]
+// ----- no-sequences -----
+type NoSequences = []|[{
+  allowInParentheses?: boolean
+}]
+// ----- no-shadow -----
+type NoShadow = []|[{
+  builtinGlobals?: boolean
+  hoist?: ("all" | "functions" | "never")
+  allow?: string[]
+  ignoreOnInitialization?: boolean
 }]
-// ----- jsdoc/require-yields-check -----
-type JsdocRequireYieldsCheck = []|[{
-  checkGeneratorsOnly?: boolean
-  contexts?: (string | {
-    comment?: string
-    context?: string
-  })[]
-  exemptedBy?: string[]
-  next?: boolean
+// ----- no-sync -----
+type NoSync = []|[{
+  allowAtRootLevel?: boolean
 }]
-// ----- jsdoc/sort-tags -----
-type JsdocSortTags = []|[{
-  alphabetizeExtras?: boolean
-  linesBetween?: number
-  reportIntraTagGroupSpacing?: boolean
-  reportTagGroupSpacing?: boolean
-  tagSequence?: {
-    tags?: string[]
-    [k: string]: unknown | undefined
-  }[]
+// ----- no-tabs -----
+type NoTabs = []|[{
+  allowIndentationTabs?: boolean
 }]
-// ----- jsdoc/tag-lines -----
-type JsdocTagLines = []|[("always" | "any" | "never")]|[("always" | "any" | "never"), {
-  applyToEndTag?: boolean
-  count?: number
-  endLines?: (number | null)
-  startLines?: (number | null)
-  tags?: {
-    [k: string]: {
-      count?: number
-      lines?: ("always" | "never" | "any")
-    }
-  }
+// ----- no-trailing-spaces -----
+type NoTrailingSpaces = []|[{
+  skipBlankLines?: boolean
+  ignoreComments?: boolean
 }]
-// ----- jsdoc/text-escaping -----
-type JsdocTextEscaping = []|[{
-  escapeHTML?: boolean
-  escapeMarkdown?: boolean
+// ----- no-undef -----
+type NoUndef = []|[{
+  typeof?: boolean
 }]
-// ----- jsdoc/valid-types -----
-type JsdocValidTypes = []|[{
-  allowEmptyNamepaths?: boolean
+// ----- no-underscore-dangle -----
+type NoUnderscoreDangle = []|[{
+  allow?: string[]
+  allowAfterThis?: boolean
+  allowAfterSuper?: boolean
+  allowAfterThisConstructor?: boolean
+  enforceInMethodNames?: boolean
+  allowFunctionParams?: boolean
+  enforceInClassFields?: boolean
+  allowInArrayDestructuring?: boolean
+  allowInObjectDestructuring?: boolean
+}]
+// ----- no-unneeded-ternary -----
+type NoUnneededTernary = []|[{
+  defaultAssignment?: boolean
+}]
+// ----- no-unreachable-loop -----
+type NoUnreachableLoop = []|[{
+  ignore?: ("WhileStatement" | "DoWhileStatement" | "ForStatement" | "ForInStatement" | "ForOfStatement")[]
+}]
+// ----- no-unsafe-negation -----
+type NoUnsafeNegation = []|[{
+  enforceForOrderingRelations?: boolean
+}]
+// ----- no-unsafe-optional-chaining -----
+type NoUnsafeOptionalChaining = []|[{
+  disallowArithmeticOperators?: boolean
+}]
+// ----- no-unused-expressions -----
+type NoUnusedExpressions = []|[{
+  allowShortCircuit?: boolean
+  allowTernary?: boolean
+  allowTaggedTemplates?: boolean
+  enforceForJSX?: boolean
+}]
+// ----- no-unused-vars -----
+type NoUnusedVars = []|[(("all" | "local") | {
+  vars?: ("all" | "local")
+  varsIgnorePattern?: string
+  args?: ("all" | "after-used" | "none")
+  ignoreRestSiblings?: boolean
+  argsIgnorePattern?: string
+  caughtErrors?: ("all" | "none")
+  caughtErrorsIgnorePattern?: string
+  destructuredArrayIgnorePattern?: string
+  ignoreClassWithStaticInitBlock?: boolean
+  reportUsedIgnorePattern?: boolean
+})]
+// ----- no-use-before-define -----
+type NoUseBeforeDefine = []|[("nofunc" | {
+  functions?: boolean
+  classes?: boolean
+  variables?: boolean
+  allowNamedExports?: boolean
+})]
+// ----- no-useless-computed-key -----
+type NoUselessComputedKey = []|[{
+  enforceForClassMembers?: boolean
+}]
+// ----- no-useless-rename -----
+type NoUselessRename = []|[{
+  ignoreDestructuring?: boolean
+  ignoreImport?: boolean
+  ignoreExport?: boolean
+}]
+// ----- no-void -----
+type NoVoid = []|[{
+  allowAsStatement?: boolean
+}]
+// ----- no-warning-comments -----
+type NoWarningComments = []|[{
+  terms?: string[]
+  location?: ("start" | "anywhere")
+  
+  decoration?: [string, ...(string)[]]
+}]
+// ----- nonblock-statement-body-position -----
+type NonblockStatementBodyPosition = []|[("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")
+  }
+}]
+// ----- object-curly-newline -----
+type ObjectCurlyNewline = []|[((("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
+  })
+})]
+// ----- object-curly-spacing -----
+type ObjectCurlySpacing = []|[("always" | "never")]|[("always" | "never"), {
+  arraysInObjects?: boolean
+  objectsInObjects?: boolean
+}]
+// ----- object-property-newline -----
+type ObjectPropertyNewline = []|[{
+  allowAllPropertiesOnSameLine?: boolean
+  allowMultiplePropertiesPerLine?: boolean
+}]
+// ----- object-shorthand -----
+type ObjectShorthand = ([]|[("always" | "methods" | "properties" | "never" | "consistent" | "consistent-as-needed")] | []|[("always" | "methods" | "properties")]|[("always" | "methods" | "properties"), {
+  avoidQuotes?: boolean
+}] | []|[("always" | "methods")]|[("always" | "methods"), {
+  ignoreConstructors?: boolean
+  methodsIgnorePattern?: string
+  avoidQuotes?: boolean
+  avoidExplicitReturnArrows?: boolean
+}])
+// ----- one-var -----
+type OneVar = []|[(("always" | "never" | "consecutive") | {
+  separateRequires?: boolean
+  var?: ("always" | "never" | "consecutive")
+  let?: ("always" | "never" | "consecutive")
+  const?: ("always" | "never" | "consecutive")
+} | {
+  initialized?: ("always" | "never" | "consecutive")
+  uninitialized?: ("always" | "never" | "consecutive")
+})]
+// ----- one-var-declaration-per-line -----
+type OneVarDeclarationPerLine = []|[("always" | "initializations")]
+// ----- operator-assignment -----
+type OperatorAssignment = []|[("always" | "never")]
+// ----- operator-linebreak -----
+type OperatorLinebreak = []|[("after" | "before" | "none" | null)]|[("after" | "before" | "none" | null), {
+  overrides?: {
+    [k: string]: ("after" | "before" | "none" | "ignore") | undefined
+  }
 }]
+// ----- padded-blocks -----
+type PaddedBlocks = []|[(("always" | "never") | {
+  blocks?: ("always" | "never")
+  switches?: ("always" | "never")
+  classes?: ("always" | "never")
+})]|[(("always" | "never") | {
+  blocks?: ("always" | "never")
+  switches?: ("always" | "never")
+  classes?: ("always" | "never")
+}), {
+  allowSingleLineBlocks?: boolean
+}]
+// ----- padding-line-between-statements -----
+type _PaddingLineBetweenStatementsPaddingType = ("any" | "never" | "always")
+type _PaddingLineBetweenStatementsStatementType = (("*" | "block-like" | "cjs-export" | "cjs-import" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with") | [("*" | "block-like" | "cjs-export" | "cjs-import" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with"), ...(("*" | "block-like" | "cjs-export" | "cjs-import" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with"))[]])
+type PaddingLineBetweenStatements = {
+  blankLine: _PaddingLineBetweenStatementsPaddingType
+  prev: _PaddingLineBetweenStatementsStatementType
+  next: _PaddingLineBetweenStatementsStatementType
+}[]
 // ----- perfectionist/sort-array-includes -----
 type PerfectionistSortArrayIncludes = []|[{
   
@@ -3831,6 +6638,168 @@ type PerfectionistSortVueAttributes = []|[{
     [k: string]: (string | string[]) | undefined
   }
 }]
+// ----- prefer-arrow-callback -----
+type PreferArrowCallback = []|[{
+  allowNamedFunctions?: boolean
+  allowUnboundThis?: boolean
+}]
+// ----- prefer-const -----
+type PreferConst = []|[{
+  destructuring?: ("any" | "all")
+  ignoreReadBeforeAssign?: boolean
+}]
+// ----- prefer-destructuring -----
+type PreferDestructuring = []|[({
+  VariableDeclarator?: {
+    array?: boolean
+    object?: boolean
+  }
+  AssignmentExpression?: {
+    array?: boolean
+    object?: boolean
+  }
+} | {
+  array?: boolean
+  object?: boolean
+})]|[({
+  VariableDeclarator?: {
+    array?: boolean
+    object?: boolean
+  }
+  AssignmentExpression?: {
+    array?: boolean
+    object?: boolean
+  }
+} | {
+  array?: boolean
+  object?: boolean
+}), {
+  enforceForRenamedProperties?: boolean
+}]
+// ----- prefer-promise-reject-errors -----
+type PreferPromiseRejectErrors = []|[{
+  allowEmptyReject?: boolean
+}]
+// ----- prefer-reflect -----
+type PreferReflect = []|[{
+  exceptions?: ("apply" | "call" | "delete" | "defineProperty" | "getOwnPropertyDescriptor" | "getPrototypeOf" | "setPrototypeOf" | "isExtensible" | "getOwnPropertyNames" | "preventExtensions")[]
+}]
+// ----- prefer-regex-literals -----
+type PreferRegexLiterals = []|[{
+  disallowRedundantWrapping?: boolean
+}]
+// ----- quote-props -----
+type QuoteProps = ([]|[("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
+}])
+// ----- quotes -----
+type Quotes = []|[("single" | "double" | "backtick")]|[("single" | "double" | "backtick"), ("avoid-escape" | {
+  avoidEscape?: boolean
+  allowTemplateLiterals?: boolean
+})]
+// ----- radix -----
+type Radix = []|[("always" | "as-needed")]
+// ----- require-atomic-updates -----
+type RequireAtomicUpdates = []|[{
+  allowProperties?: boolean
+}]
+// ----- require-unicode-regexp -----
+type RequireUnicodeRegexp = []|[{
+  requireFlag?: ("u" | "v")
+}]
+// ----- rest-spread-spacing -----
+type RestSpreadSpacing = []|[("always" | "never")]
+// ----- semi -----
+type Semi = ([]|["never"]|["never", {
+  beforeStatementContinuationChars?: ("always" | "any" | "never")
+}] | []|["always"]|["always", {
+  omitLastInOneLineBlock?: boolean
+  omitLastInOneLineClassBody?: boolean
+}])
+// ----- semi-spacing -----
+type SemiSpacing = []|[{
+  before?: boolean
+  after?: boolean
+}]
+// ----- semi-style -----
+type SemiStyle = []|[("last" | "first")]
+// ----- sort-imports -----
+type SortImports = []|[{
+  ignoreCase?: boolean
+  
+  memberSyntaxSortOrder?: [("none" | "all" | "multiple" | "single"), ("none" | "all" | "multiple" | "single"), ("none" | "all" | "multiple" | "single"), ("none" | "all" | "multiple" | "single")]
+  ignoreDeclarationSort?: boolean
+  ignoreMemberSort?: boolean
+  allowSeparatedGroups?: boolean
+}]
+// ----- sort-keys -----
+type SortKeys = []|[("asc" | "desc")]|[("asc" | "desc"), {
+  caseSensitive?: boolean
+  natural?: boolean
+  minKeys?: number
+  allowLineSeparatedGroups?: boolean
+}]
+// ----- sort-vars -----
+type SortVars = []|[{
+  ignoreCase?: boolean
+}]
+// ----- space-before-blocks -----
+type SpaceBeforeBlocks = []|[(("always" | "never") | {
+  keywords?: ("always" | "never" | "off")
+  functions?: ("always" | "never" | "off")
+  classes?: ("always" | "never" | "off")
+})]
+// ----- space-before-function-paren -----
+type SpaceBeforeFunctionParen = []|[(("always" | "never") | {
+  anonymous?: ("always" | "never" | "ignore")
+  named?: ("always" | "never" | "ignore")
+  asyncArrow?: ("always" | "never" | "ignore")
+})]
+// ----- space-in-parens -----
+type SpaceInParens = []|[("always" | "never")]|[("always" | "never"), {
+  exceptions?: ("{}" | "[]" | "()" | "empty")[]
+}]
+// ----- space-infix-ops -----
+type SpaceInfixOps = []|[{
+  int32Hint?: boolean
+}]
+// ----- space-unary-ops -----
+type SpaceUnaryOps = []|[{
+  words?: boolean
+  nonwords?: boolean
+  overrides?: {
+    [k: string]: boolean | undefined
+  }
+}]
+// ----- spaced-comment -----
+type SpacedComment = []|[("always" | "never")]|[("always" | "never"), {
+  exceptions?: string[]
+  markers?: string[]
+  line?: {
+    exceptions?: string[]
+    markers?: string[]
+  }
+  block?: {
+    exceptions?: string[]
+    markers?: string[]
+    balanced?: boolean
+  }
+}]
+// ----- strict -----
+type Strict = []|[("never" | "global" | "function" | "safe")]
+// ----- switch-colon-spacing -----
+type SwitchColonSpacing = []|[{
+  before?: boolean
+  after?: boolean
+}]
+// ----- template-curly-spacing -----
+type TemplateCurlySpacing = []|[("always" | "never")]
+// ----- template-tag-spacing -----
+type TemplateTagSpacing = []|[("always" | "never")]
+// ----- unicode-bom -----
+type UnicodeBom = []|[("always" | "never")]
 // ----- unused-imports/no-unused-imports -----
 type UnusedImportsNoUnusedImports = []|[(("all" | "local") | {
   
@@ -3877,6 +6846,15 @@ type UnusedImportsNoUnusedVars = []|[(("all" | "local") | {
   
   reportUsedIgnorePattern?: boolean
 })]
+// ----- use-isnan -----
+type UseIsnan = []|[{
+  enforceForSwitchCase?: boolean
+  enforceForIndexOf?: boolean
+}]
+// ----- valid-typeof -----
+type ValidTypeof = []|[{
+  requireStringLiterals?: boolean
+}]
 // ----- vitest/consistent-test-filename -----
 type VitestConsistentTestFilename = []|[{
   pattern?: string
@@ -3966,6 +6944,20 @@ type VitestValidExpect = []|[{
   minArgs?: number
   maxArgs?: number
 }]
+// ----- wrap-iife -----
+type WrapIife = []|[("outside" | "inside" | "any")]|[("outside" | "inside" | "any"), {
+  functionPrototypeMethods?: boolean
+}]
+// ----- yield-star-spacing -----
+type YieldStarSpacing = []|[(("before" | "after" | "both" | "neither") | {
+  before?: boolean
+  after?: boolean
+})]
+// ----- yoda -----
+type Yoda = []|[("always" | "never")]|[("always" | "never"), {
+  exceptRange?: boolean
+  onlyEquality?: boolean
+}]
 
 export type {Awaitable} from 'eslint-flat-config-utils'
 
@@ -3978,7 +6970,7 @@ export type Config = Linter.Config<Linter.RulesRecord & Rules>
 /**
  * Contains the names of all the configurations in this package.
  */
-export type ConfigNames = '@bfra.me/gitignore' | '@bfra.me/ignores' | '@bfra.me/javascript/options' | '@bfra.me/javascript/rules' | '@bfra.me/eslint-comments/rules' | '@bfra.me/jsdoc' | '@bfra.me/imports' | '@bfra.me/command' | '@bfra.me/perfectionist' | '@bfra.me/typescript/plugins' | '@bfra.me/typescript/parser' | '@bfra.me/typescript/rules' | '@bfra.me/vitest/plugin' | '@bfra.me/vitest/rules' | '@bfra.me/epilogue/dts'
+export type ConfigNames = '@bfra.me/gitignore' | '@bfra.me/ignores' | '@bfra.me/javascript/options' | '@bfra.me/javascript/rules' | '@bfra.me/eslint-comments/rules' | '@bfra.me/jsdoc' | '@bfra.me/imports' | '@bfra.me/command' | '@bfra.me/perfectionist' | '@bfra.me/typescript/plugins' | '@bfra.me/typescript/parser' | '@bfra.me/typescript/rules' | '@bfra.me/vitest/plugin' | '@bfra.me/vitest/rules' | '@bfra.me/epilogue/commonjs' | '@bfra.me/epilogue/configs' | '@bfra.me/epilogue/dts' | '@bfra.me/epilogue/scripts'
 
 export type * from './define-config'