@yunarch/config-web/dist/linters/eslint.config.d.ts

Shared configurations for web projects.

import { FlatConfigComposer } from 'eslint-flat-config-utils';
import { ParserOptions } from '@typescript-eslint/parser';
import { Linter } from 'eslint';
import { FlatGitignoreOptions } from 'eslint-config-flat-gitignore';

/* eslint-disable */
/* prettier-ignore */


interface RuleOptions {
  /**
   * Enforces explicit boolean values for boolean attributes.
   * @see https://eslint-react.xyz/docs/rules/avoid-shorthand-boolean
   */
  '@eslint-react/avoid-shorthand-boolean'?: Linter.RuleEntry<[]>
  /**
   * Enforces explicit `<Fragment>` components instead of the shorthand `<>` or `</>` syntax.
   * @see https://eslint-react.xyz/docs/rules/avoid-shorthand-fragment
   */
  '@eslint-react/avoid-shorthand-fragment'?: Linter.RuleEntry<[]>
  /**
   * Disallow `children` in void DOM elements.
   * @see https://eslint-react.xyz/docs/rules/dom-no-void-elements-with-children
   */
  '@eslint-react/dom/no-children-in-void-dom-elements'?: Linter.RuleEntry<[]>
  /**
   * Disallow `dangerouslySetInnerHTML`.
   * @see https://eslint-react.xyz/docs/rules/dom-no-dangerously-set-innerhtml
   */
  '@eslint-react/dom/no-dangerously-set-innerhtml'?: Linter.RuleEntry<[]>
  /**
   * Disallow `dangerouslySetInnerHTML` and `children` at the same time.
   * @see https://eslint-react.xyz/docs/rules/dom-no-dangerously-set-innerhtml-with-children
   */
  '@eslint-react/dom/no-dangerously-set-innerhtml-with-children'?: Linter.RuleEntry<[]>
  /**
   * Disallow `findDOMNode`.
   * @see https://eslint-react.xyz/docs/rules/dom-no-find-dom-node
   */
  '@eslint-react/dom/no-find-dom-node'?: Linter.RuleEntry<[]>
  /**
   * Disallow `flushSync`.
   * @see https://eslint-react.xyz/docs/rules/dom-no-flush-sync
   */
  '@eslint-react/dom/no-flush-sync'?: Linter.RuleEntry<[]>
  /**
   * Replaces usages of `ReactDom.hydrate()` with `hydrateRoot()`.
   * @see https://eslint-react.xyz/docs/rules/dom-no-hydrate
   */
  '@eslint-react/dom/no-hydrate'?: Linter.RuleEntry<[]>
  /**
   * Enforces explicit `type` attribute for `button` elements.
   * @see https://eslint-react.xyz/docs/rules/dom-no-missing-button-type
   */
  '@eslint-react/dom/no-missing-button-type'?: Linter.RuleEntry<[]>
  /**
   * Enforces explicit `sandbox` attribute for `iframe` elements.
   * @see https://eslint-react.xyz/docs/rules/dom-no-missing-iframe-sandbox
   */
  '@eslint-react/dom/no-missing-iframe-sandbox'?: Linter.RuleEntry<[]>
  /**
   * Enforces the absence of a `namespace` in React elements.
   * @see https://eslint-react.xyz/docs/rules/dom-no-namespace
   */
  '@eslint-react/dom/no-namespace'?: Linter.RuleEntry<[]>
  /**
   * Replaces usages of `ReactDom.render()` with `createRoot(node).render()`.
   * @see https://eslint-react.xyz/docs/rules/dom-no-render
   */
  '@eslint-react/dom/no-render'?: Linter.RuleEntry<[]>
  /**
   * Disallow the return value of `ReactDOM.render`.
   * @see https://eslint-react.xyz/docs/rules/dom-no-render-return-value
   */
  '@eslint-react/dom/no-render-return-value'?: Linter.RuleEntry<[]>
  /**
   * Disallow `javascript:` URLs as attribute values.
   * @see https://eslint-react.xyz/docs/rules/dom-no-script-url
   */
  '@eslint-react/dom/no-script-url'?: Linter.RuleEntry<[]>
  /**
   * Disallow unknown `DOM` property.
   * @see https://eslint-react.xyz/docs/rules/dom-no-unknown-property
   */
  '@eslint-react/dom/no-unknown-property'?: Linter.RuleEntry<EslintReactDomNoUnknownProperty>
  /**
   * Enforces `sandbox` attribute for `iframe` elements is not set to unsafe combinations.
   * @see https://eslint-react.xyz/docs/rules/dom-no-unsafe-iframe-sandbox
   */
  '@eslint-react/dom/no-unsafe-iframe-sandbox'?: Linter.RuleEntry<[]>
  /**
   * Disallow `target="_blank"` without `rel="noreferrer noopener"`.
   * @see https://eslint-react.xyz/docs/rules/dom-no-unsafe-target-blank
   */
  '@eslint-react/dom/no-unsafe-target-blank'?: Linter.RuleEntry<[]>
  /**
   * Replaces usages of `useFormState` with `useActionState`.
   * @see https://eslint-react.xyz/docs/rules/dom-no-use-form-state
   */
  '@eslint-react/dom/no-use-form-state'?: Linter.RuleEntry<[]>
  /**
   * Disallow `children` in void DOM elements.
   * @see https://eslint-react.xyz/docs/rules/dom-no-void-elements-with-children
   */
  '@eslint-react/dom/no-void-elements-with-children'?: Linter.RuleEntry<[]>
  /**
   * Disallow useless `forwardRef` calls on components that don't use `ref`s.
   * @see https://eslint-react.xyz/docs/rules/no-useless-forward-ref
   */
  '@eslint-react/ensure-forward-ref-using-ref'?: Linter.RuleEntry<[]>
  /**
   * Enforces that a function with the `use` prefix should use at least one Hook inside of it.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-unnecessary-use-prefix
   */
  '@eslint-react/hooks-extra/ensure-custom-hooks-using-other-hooks'?: Linter.RuleEntry<[]>
  /**
   * Disallow unnecessary usage of `useCallback`.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-unnecessary-use-callback
   */
  '@eslint-react/hooks-extra/ensure-use-callback-has-non-empty-deps'?: Linter.RuleEntry<[]>
  /**
   * Disallow unnecessary usage of `useMemo`.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-unnecessary-use-memo
   */
  '@eslint-react/hooks-extra/ensure-use-memo-has-non-empty-deps'?: Linter.RuleEntry<[]>
  /**
   * Disallow direct calls to the `set` function of `useState` in `useEffect`.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-direct-set-state-in-use-effect
   */
  '@eslint-react/hooks-extra/no-direct-set-state-in-use-effect'?: Linter.RuleEntry<[]>
  /**
   * Disallow direct calls to the `set` function of `useState` in `useLayoutEffect`.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-direct-set-state-in-use-layout-effect
   */
  '@eslint-react/hooks-extra/no-direct-set-state-in-use-layout-effect'?: Linter.RuleEntry<[]>
  /**
   * Enforces that a function with the `use` prefix should use at least one Hook inside of it.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-unnecessary-use-prefix
   */
  '@eslint-react/hooks-extra/no-redundant-custom-hook'?: Linter.RuleEntry<[]>
  /**
   * Disallow unnecessary usage of `useCallback`.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-unnecessary-use-callback
   */
  '@eslint-react/hooks-extra/no-unnecessary-use-callback'?: Linter.RuleEntry<[]>
  /**
   * Disallow unnecessary usage of `useMemo`.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-unnecessary-use-memo
   */
  '@eslint-react/hooks-extra/no-unnecessary-use-memo'?: Linter.RuleEntry<[]>
  /**
   * Enforces that a function with the `use` prefix should use at least one Hook inside of it.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-unnecessary-use-prefix
   */
  '@eslint-react/hooks-extra/no-unnecessary-use-prefix'?: Linter.RuleEntry<[]>
  /**
   * Enforces that a function with the `use` prefix should use at least one Hook inside of it.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-unnecessary-use-prefix
   */
  '@eslint-react/hooks-extra/no-useless-custom-hooks'?: Linter.RuleEntry<[]>
  /**
   * Enforces function calls made inside `useState` to be wrapped in an `initializer function`.
   * @see https://eslint-react.xyz/docs/rules/hooks-extra-prefer-use-state-lazy-initialization
   */
  '@eslint-react/hooks-extra/prefer-use-state-lazy-initialization'?: Linter.RuleEntry<[]>
  /**
   * Enforces that the 'key' attribute is placed before the spread attribute in JSX elements.
   * @see https://eslint-react.xyz/docs/rules/jsx-key-before-spread
   */
  '@eslint-react/jsx-key-before-spread'?: Linter.RuleEntry<[]>
  /**
   * Disallow duplicate props in JSX elements.
   * @see https://eslint-react.xyz/docs/rules/jsx-no-duplicate-props
   */
  '@eslint-react/jsx-no-duplicate-props'?: Linter.RuleEntry<[]>
  /**
   * Disallows 'IIFE' in JSX elements.
   * @see https://eslint-react.xyz/docs/rules/jsx-no-iife
   */
  '@eslint-react/jsx-no-iife'?: Linter.RuleEntry<[]>
  /**
   * Disallow undefined variables in JSX.
   * @see https://eslint-react.xyz/docs/rules/jsx-no-undef
   */
  '@eslint-react/jsx-no-undef'?: Linter.RuleEntry<[]>
  /**
   * Marks React variables as used when JSX is used.
   * @see https://eslint-react.xyz/docs/rules/jsx-uses-react
   */
  '@eslint-react/jsx-uses-react'?: Linter.RuleEntry<[]>
  /**
   * Marks variables used in JSX elements as used.
   * @see https://eslint-react.xyz/docs/rules/jsx-uses-vars
   */
  '@eslint-react/jsx-uses-vars'?: Linter.RuleEntry<[]>
  /**
   * Enforces naming conventions for components.
   * @see https://eslint-react.xyz/docs/rules/naming-convention-component-name
   */
  '@eslint-react/naming-convention/component-name'?: Linter.RuleEntry<EslintReactNamingConventionComponentName>
  /**
   * Enforces context name to be a valid component name with the suffix `Context`.
   * @see https://eslint-react.xyz/docs/rules/naming-convention-context-name
   */
  '@eslint-react/naming-convention/context-name'?: Linter.RuleEntry<[]>
  /**
   * Enforces consistent file naming conventions.
   * @see https://eslint-react.xyz/docs/rules/naming-convention-filename
   */
  '@eslint-react/naming-convention/filename'?: Linter.RuleEntry<EslintReactNamingConventionFilename>
  /**
   * Enforces consistent file naming conventions.
   * @see https://eslint-react.xyz/docs/rules/naming-convention-filename-extension
   */
  '@eslint-react/naming-convention/filename-extension'?: Linter.RuleEntry<EslintReactNamingConventionFilenameExtension>
  /**
   * Enforces destructuring and symmetric naming of `useState` hook value and setter.
   * @see https://eslint-react.xyz/docs/rules/naming-convention-use-state
   */
  '@eslint-react/naming-convention/use-state'?: Linter.RuleEntry<[]>
  /**
   * Disallow accessing `this.state` inside `setState` calls.
   * @see https://eslint-react.xyz/docs/rules/no-access-state-in-setstate
   */
  '@eslint-react/no-access-state-in-setstate'?: Linter.RuleEntry<[]>
  /**
   * Disallow an item's index in the array as its key.
   * @see https://eslint-react.xyz/docs/rules/no-array-index-key
   */
  '@eslint-react/no-array-index-key'?: Linter.RuleEntry<[]>
  /**
   * Disallow `Children.count`.
   * @see https://eslint-react.xyz/docs/rules/no-children-count
   */
  '@eslint-react/no-children-count'?: Linter.RuleEntry<[]>
  /**
   * Disallow 'Children.forEach'.
   * @see https://eslint-react.xyz/docs/rules/no-children-for-each
   */
  '@eslint-react/no-children-for-each'?: Linter.RuleEntry<[]>
  /**
   * Disallow `Children.map`.
   * @see https://eslint-react.xyz/docs/rules/no-children-map
   */
  '@eslint-react/no-children-map'?: Linter.RuleEntry<[]>
  /**
   * Disallow `Children.only`.
   * @see https://eslint-react.xyz/docs/rules/no-children-only
   */
  '@eslint-react/no-children-only'?: Linter.RuleEntry<[]>
  /**
   * Disallow passing `children` as a prop.
   * @see https://eslint-react.xyz/docs/rules/no-children-prop
   */
  '@eslint-react/no-children-prop'?: Linter.RuleEntry<[]>
  /**
   * Disallow `Children.toArray`.
   * @see https://eslint-react.xyz/docs/rules/no-children-to-array
   */
  '@eslint-react/no-children-to-array'?: Linter.RuleEntry<[]>
  /**
   * Disallow class components except for error boundaries.
   * @see https://eslint-react.xyz/docs/rules/no-class-component
   */
  '@eslint-react/no-class-component'?: Linter.RuleEntry<[]>
  /**
   * Disallow `cloneElement`.
   * @see https://eslint-react.xyz/docs/rules/no-clone-element
   */
  '@eslint-react/no-clone-element'?: Linter.RuleEntry<[]>
  /**
   * Prevents comments from being inserted as text nodes.
   * @see https://eslint-react.xyz/docs/rules/no-comment-textnodes
   */
  '@eslint-react/no-comment-textnodes'?: Linter.RuleEntry<[]>
  /**
   * Disallow complex conditional rendering in JSX expressions.
   * @see https://eslint-react.xyz/docs/rules/no-complex-conditional-rendering
   */
  '@eslint-react/no-complex-conditional-rendering'?: Linter.RuleEntry<[]>
  /**
   * Disallow complex conditional rendering in JSX expressions.
   * @see https://eslint-react.xyz/docs/rules/no-complex-conditional-rendering
   */
  '@eslint-react/no-complicated-conditional-rendering'?: Linter.RuleEntry<[]>
  /**
   * Replace usages of `componentWillMount` with `UNSAFE_componentWillMount`.
   * @see https://eslint-react.xyz/docs/rules/no-component-will-mount
   */
  '@eslint-react/no-component-will-mount'?: Linter.RuleEntry<[]>
  /**
   * Replace usages of `componentWillReceiveProps` with `UNSAFE_componentWillReceiveProps`.
   * @see https://eslint-react.xyz/docs/rules/no-component-will-receive-props
   */
  '@eslint-react/no-component-will-receive-props'?: Linter.RuleEntry<[]>
  /**
   * Replace usages of `componentWillUpdate` with `UNSAFE_componentWillUpdate`.
   * @see https://eslint-react.xyz/docs/rules/no-component-will-update
   */
  '@eslint-react/no-component-will-update'?: Linter.RuleEntry<[]>
  /**
   * Replace usages of `<Context.Provider>` with `<Context>`.
   * @see https://eslint-react.xyz/docs/rules/no-context-provider
   */
  '@eslint-react/no-context-provider'?: Linter.RuleEntry<[]>
  /**
   * Disallow `createRef` in function components.
   * @see https://eslint-react.xyz/docs/rules/no-create-ref
   */
  '@eslint-react/no-create-ref'?: Linter.RuleEntry<[]>
  /**
   * Disallow `defaultProps` property in favor of ES6 default parameters.
   * @see https://eslint-react.xyz/docs/rules/no-default-props
   */
  '@eslint-react/no-default-props'?: Linter.RuleEntry<[]>
  /**
   * Disallow direct mutation of `this.state`.
   * @see https://eslint-react.xyz/docs/rules/no-direct-mutation-state
   */
  '@eslint-react/no-direct-mutation-state'?: Linter.RuleEntry<[]>
  /**
   * Disallow duplicate props in JSX elements.
   * @see https://eslint-react.xyz/docs/rules/jsx-no-duplicate-props
   */
  '@eslint-react/no-duplicate-jsx-props'?: Linter.RuleEntry<[]>
  /**
   * Disallow duplicate `key` on elements in the same array or a list of `children`.
   * @see https://eslint-react.xyz/docs/rules/no-duplicate-key
   */
  '@eslint-react/no-duplicate-key'?: Linter.RuleEntry<[]>
  /**
   * Replaces usages of `forwardRef` with passing `ref` as a prop.
   * @see https://eslint-react.xyz/docs/rules/no-forward-ref
   */
  '@eslint-react/no-forward-ref'?: Linter.RuleEntry<[]>
  /**
   * Prevents `key` from not being explicitly specified (e.g. spreading `key` from objects).
   * @see https://eslint-react.xyz/docs/rules/no-implicit-key
   */
  '@eslint-react/no-implicit-key'?: Linter.RuleEntry<[]>
  /**
   * Prevents problematic leaked values from being rendered.
   * @see https://eslint-react.xyz/docs/rules/no-leaked-conditional-rendering
   */
  '@eslint-react/no-leaked-conditional-rendering'?: Linter.RuleEntry<[]>
  /**
   * Enforces that all components have a `displayName` which can be used in devtools.
   * @see https://eslint-react.xyz/docs/rules/no-missing-component-display-name
   */
  '@eslint-react/no-missing-component-display-name'?: Linter.RuleEntry<[]>
  /**
   * Enforces that all contexts have a `displayName` which can be used in devtools.
   * @see https://eslint-react.xyz/docs/rules/no-missing-context-display-name
   */
  '@eslint-react/no-missing-context-display-name'?: Linter.RuleEntry<[]>
  /**
   * Disallow missing `key` on items in list rendering.
   * @see https://eslint-react.xyz/docs/rules/no-missing-key
   */
  '@eslint-react/no-missing-key'?: Linter.RuleEntry<[]>
  /**
   * Prevents incorrect usage of `captureOwnerStack`.
   * @see https://eslint-react.xyz/docs/rules/no-misused-capture-owner-stack
   */
  '@eslint-react/no-misused-capture-owner-stack'?: Linter.RuleEntry<[]>
  /**
   * Disallow nesting component definitions inside other components.
   * @see https://eslint-react.xyz/docs/rules/no-nested-component-definitions
   */
  '@eslint-react/no-nested-component-definitions'?: Linter.RuleEntry<[]>
  /**
   * Disallow nesting component definitions inside other components.
   * @see https://eslint-react.xyz/docs/rules/no-nested-component-definitions
   */
  '@eslint-react/no-nested-components'?: Linter.RuleEntry<[]>
  /**
   * Disallow nesting lazy component declarations inside other components.
   * @see https://eslint-react.xyz/docs/rules/no-nested-component-definitions
   */
  '@eslint-react/no-nested-lazy-component-declarations'?: Linter.RuleEntry<[]>
  /**
   * Disallow `propTypes` in favor of TypeScript or another type-checking solution.
   * @see https://eslint-react.xyz/docs/rules/no-prop-types
   */
  '@eslint-react/no-prop-types'?: Linter.RuleEntry<[]>
  /**
   * Disallow `shouldComponentUpdate` when extending `React.PureComponent`.
   * @see https://eslint-react.xyz/docs/rules/no-redundant-should-component-update
   */
  '@eslint-react/no-redundant-should-component-update'?: Linter.RuleEntry<[]>
  /**
   * Disallow calling `this.setState` in `componentDidMount` outside of functions, such as callbacks.
   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-did-mount
   */
  '@eslint-react/no-set-state-in-component-did-mount'?: Linter.RuleEntry<[]>
  /**
   * Disallow calling `this.setState` in `componentDidUpdate` outside of functions, such as callbacks.
   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-did-update
   */
  '@eslint-react/no-set-state-in-component-did-update'?: Linter.RuleEntry<[]>
  /**
   * Disallows calling `this.setState` in `componentWillUpdate` outside of functions, such as callbacks.
   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-will-update
   */
  '@eslint-react/no-set-state-in-component-will-update'?: Linter.RuleEntry<[]>
  /**
   * Replaces string refs with callback refs.
   * @see https://eslint-react.xyz/docs/rules/no-string-refs
   */
  '@eslint-react/no-string-refs'?: Linter.RuleEntry<[]>
  /**
   * Warns the usage of `UNSAFE_componentWillMount` in class components.
   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-mount
   */
  '@eslint-react/no-unsafe-component-will-mount'?: Linter.RuleEntry<[]>
  /**
   * Warns the usage of `UNSAFE_componentWillReceiveProps` in class components.
   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-receive-props
   */
  '@eslint-react/no-unsafe-component-will-receive-props'?: Linter.RuleEntry<[]>
  /**
   * Warns the usage of `UNSAFE_componentWillUpdate` in class components.
   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-update
   */
  '@eslint-react/no-unsafe-component-will-update'?: Linter.RuleEntry<[]>
  /**
   * Prevents non-stable values (i.e. object literals) from being used as a value for `Context.Provider`.
   * @see https://eslint-react.xyz/docs/rules/no-unstable-context-value
   */
  '@eslint-react/no-unstable-context-value'?: Linter.RuleEntry<[]>
  /**
   * Prevents using referential-type values as default props in object destructuring.
   * @see https://eslint-react.xyz/docs/rules/no-unstable-default-props
   */
  '@eslint-react/no-unstable-default-props'?: Linter.RuleEntry<[]>
  /**
   * Warns unused class component methods and properties.
   * @see https://eslint-react.xyz/docs/rules/no-unused-class-component-members
   */
  '@eslint-react/no-unused-class-component-members'?: Linter.RuleEntry<[]>
  /**
   * Warns unused class component state.
   * @see https://eslint-react.xyz/docs/rules/no-unused-state
   */
  '@eslint-react/no-unused-state'?: Linter.RuleEntry<[]>
  /**
   * Replaces usages of `useContext` with `use`.
   * @see https://eslint-react.xyz/docs/rules/no-use-context
   */
  '@eslint-react/no-use-context'?: Linter.RuleEntry<[]>
  /**
   * Disallow useless `forwardRef` calls on components that don't use `ref`s.
   * @see https://eslint-react.xyz/docs/rules/no-useless-forward-ref
   */
  '@eslint-react/no-useless-forward-ref'?: Linter.RuleEntry<[]>
  /**
   * Disallow useless fragment elements.
   * @see https://eslint-react.xyz/docs/rules/no-useless-fragment
   */
  '@eslint-react/no-useless-fragment'?: Linter.RuleEntry<EslintReactNoUselessFragment>
  /**
   * Enforces destructuring assignment for component props and context.
   * @see https://eslint-react.xyz/docs/rules/prefer-destructuring-assignment
   */
  '@eslint-react/prefer-destructuring-assignment'?: Linter.RuleEntry<[]>
  /**
   * Enforces React is imported via a namespace import.
   * @see https://eslint-react.xyz/docs/rules/prefer-react-namespace-import
   */
  '@eslint-react/prefer-react-namespace-import'?: Linter.RuleEntry<[]>
  /**
   * Enforces read-only props in components.
   * @see https://eslint-react.xyz/docs/rules/prefer-read-only-props
   */
  '@eslint-react/prefer-read-only-props'?: Linter.RuleEntry<[]>
  /**
   * Enforces shorthand syntax for boolean attributes.
   * @see https://eslint-react.xyz/docs/rules/prefer-shorthand-boolean
   */
  '@eslint-react/prefer-shorthand-boolean'?: Linter.RuleEntry<[]>
  /**
   * Enforces shorthand syntax for fragments.
   * @see https://eslint-react.xyz/docs/rules/prefer-shorthand-fragment
   */
  '@eslint-react/prefer-shorthand-fragment'?: Linter.RuleEntry<[]>
  /**
   * Marks variables used in JSX elements as used.
   * @see https://eslint-react.xyz/docs/rules/jsx-uses-vars
   */
  '@eslint-react/use-jsx-vars'?: Linter.RuleEntry<[]>
  /**
   * Prevents leaked `addEventListener` in a component or custom Hook.
   * @see https://eslint-react.xyz/docs/rules/web-api-no-leaked-event-listener
   */
  '@eslint-react/web-api/no-leaked-event-listener'?: Linter.RuleEntry<[]>
  /**
   * Prevents leaked `setInterval` in a component or custom Hook.
   * @see https://eslint-react.xyz/docs/rules/web-api-no-leaked-interval
   */
  '@eslint-react/web-api/no-leaked-interval'?: Linter.RuleEntry<[]>
  /**
   * Prevents leaked `ResizeObserver` in a component or custom Hook.
   * @see https://eslint-react.xyz/docs/rules/web-api-no-leaked-resize-observer
   */
  '@eslint-react/web-api/no-leaked-resize-observer'?: Linter.RuleEntry<[]>
  /**
   * Prevents leaked `setTimeout` in a component or custom Hook.
   * @see https://eslint-react.xyz/docs/rules/web-api-no-leaked-timeout
   */
  '@eslint-react/web-api/no-leaked-timeout'?: Linter.RuleEntry<[]>
  /**
   * Exhaustive deps rule for useQuery
   * @see https://tanstack.com/query/latest/docs/eslint/exhaustive-deps
   */
  '@tanstack/query/exhaustive-deps'?: Linter.RuleEntry<[]>
  /**
   * Ensure correct order of inference sensitive properties for infinite queries
   * @see https://tanstack.com/query/latest/docs/eslint/infinite-query-property-order
   */
  '@tanstack/query/infinite-query-property-order'?: Linter.RuleEntry<[]>
  /**
   * Ensure correct order of inference-sensitive properties in useMutation()
   * @see https://tanstack.com/query/latest/docs/eslint/mutation-property-order
   */
  '@tanstack/query/mutation-property-order'?: Linter.RuleEntry<[]>
  /**
   * Disallows rest destructuring in queries
   * @see https://tanstack.com/query/latest/docs/eslint/no-rest-destructuring
   */
  '@tanstack/query/no-rest-destructuring'?: Linter.RuleEntry<[]>
  /**
   * Disallow putting the result of query hooks directly in a React hook dependency array
   * @see https://tanstack.com/query/latest/docs/eslint/no-unstable-deps
   */
  '@tanstack/query/no-unstable-deps'?: Linter.RuleEntry<[]>
  /**
   * Ensures queryFn returns a non-undefined value
   * @see https://tanstack.com/query/latest/docs/eslint/no-void-query-fn
   */
  '@tanstack/query/no-void-query-fn'?: Linter.RuleEntry<[]>
  /**
   * Makes sure that QueryClient is stable
   * @see https://tanstack.com/query/latest/docs/eslint/stable-query-client
   */
  '@tanstack/query/stable-query-client'?: Linter.RuleEntry<[]>
  /**
   * Ensure correct order of inference sensitive properties for createRoute functions
   * @see https://tanstack.com/router/latest/docs/eslint/create-route-property-order
   */
  '@tanstack/router/create-route-property-order'?: Linter.RuleEntry<[]>
  /**
   * Require that function overload signatures be consecutive
   * @see https://typescript-eslint.io/rules/adjacent-overload-signatures
   */
  '@typescript-eslint/adjacent-overload-signatures'?: Linter.RuleEntry<[]>
  /**
   * Require consistently using either `T[]` or `Array<T>` for arrays
   * @see https://typescript-eslint.io/rules/array-type
   */
  '@typescript-eslint/array-type'?: Linter.RuleEntry<TypescriptEslintArrayType>
  /**
   * Disallow awaiting a value that is not a Thenable
   * @see https://typescript-eslint.io/rules/await-thenable
   */
  '@typescript-eslint/await-thenable'?: Linter.RuleEntry<[]>
  /**
   * Disallow `@ts-<directive>` comments or require descriptions after directives
   * @see https://typescript-eslint.io/rules/ban-ts-comment
   */
  '@typescript-eslint/ban-ts-comment'?: Linter.RuleEntry<TypescriptEslintBanTsComment>
  /**
   * Disallow `// tslint:<rule-flag>` comments
   * @see https://typescript-eslint.io/rules/ban-tslint-comment
   */
  '@typescript-eslint/ban-tslint-comment'?: Linter.RuleEntry<[]>
  /**
   * Enforce that literals on classes are exposed in a consistent style
   * @see https://typescript-eslint.io/rules/class-literal-property-style
   */
  '@typescript-eslint/class-literal-property-style'?: Linter.RuleEntry<TypescriptEslintClassLiteralPropertyStyle>
  /**
   * Enforce that class methods utilize `this`
   * @see https://typescript-eslint.io/rules/class-methods-use-this
   */
  '@typescript-eslint/class-methods-use-this'?: Linter.RuleEntry<TypescriptEslintClassMethodsUseThis>
  /**
   * Enforce specifying generic type arguments on type annotation or constructor name of a constructor call
   * @see https://typescript-eslint.io/rules/consistent-generic-constructors
   */
  '@typescript-eslint/consistent-generic-constructors'?: Linter.RuleEntry<TypescriptEslintConsistentGenericConstructors>
  /**
   * Require or disallow the `Record` type
   * @see https://typescript-eslint.io/rules/consistent-indexed-object-style
   */
  '@typescript-eslint/consistent-indexed-object-style'?: Linter.RuleEntry<TypescriptEslintConsistentIndexedObjectStyle>
  /**
   * Require `return` statements to either always or never specify values
   * @see https://typescript-eslint.io/rules/consistent-return
   */
  '@typescript-eslint/consistent-return'?: Linter.RuleEntry<TypescriptEslintConsistentReturn>
  /**
   * Enforce consistent usage of type assertions
   * @see https://typescript-eslint.io/rules/consistent-type-assertions
   */
  '@typescript-eslint/consistent-type-assertions'?: Linter.RuleEntry<TypescriptEslintConsistentTypeAssertions>
  /**
   * Enforce type definitions to consistently use either `interface` or `type`
   * @see https://typescript-eslint.io/rules/consistent-type-definitions
   */
  '@typescript-eslint/consistent-type-definitions'?: Linter.RuleEntry<TypescriptEslintConsistentTypeDefinitions>
  /**
   * Enforce consistent usage of type exports
   * @see https://typescript-eslint.io/rules/consistent-type-exports
   */
  '@typescript-eslint/consistent-type-exports'?: Linter.RuleEntry<TypescriptEslintConsistentTypeExports>
  /**
   * Enforce consistent usage of type imports
   * @see https://typescript-eslint.io/rules/consistent-type-imports
   */
  '@typescript-eslint/consistent-type-imports'?: Linter.RuleEntry<TypescriptEslintConsistentTypeImports>
  /**
   * Enforce default parameters to be last
   * @see https://typescript-eslint.io/rules/default-param-last
   */
  '@typescript-eslint/default-param-last'?: Linter.RuleEntry<[]>
  /**
   * Enforce dot notation whenever possible
   * @see https://typescript-eslint.io/rules/dot-notation
   */
  '@typescript-eslint/dot-notation'?: Linter.RuleEntry<TypescriptEslintDotNotation>
  /**
   * Require explicit return types on functions and class methods
   * @see https://typescript-eslint.io/rules/explicit-function-return-type
   */
  '@typescript-eslint/explicit-function-return-type'?: Linter.RuleEntry<TypescriptEslintExplicitFunctionReturnType>
  /**
   * Require explicit accessibility modifiers on class properties and methods
   * @see https://typescript-eslint.io/rules/explicit-member-accessibility
   */
  '@typescript-eslint/explicit-member-accessibility'?: Linter.RuleEntry<TypescriptEslintExplicitMemberAccessibility>
  /**
   * Require explicit return and argument types on exported functions' and classes' public class methods
   * @see https://typescript-eslint.io/rules/explicit-module-boundary-types
   */
  '@typescript-eslint/explicit-module-boundary-types'?: Linter.RuleEntry<TypescriptEslintExplicitModuleBoundaryTypes>
  /**
   * Require or disallow initialization in variable declarations
   * @see https://typescript-eslint.io/rules/init-declarations
   */
  '@typescript-eslint/init-declarations'?: Linter.RuleEntry<TypescriptEslintInitDeclarations>
  /**
   * Enforce a maximum number of parameters in function definitions
   * @see https://typescript-eslint.io/rules/max-params
   */
  '@typescript-eslint/max-params'?: Linter.RuleEntry<TypescriptEslintMaxParams>
  /**
   * Require a consistent member declaration order
   * @see https://typescript-eslint.io/rules/member-ordering
   */
  '@typescript-eslint/member-ordering'?: Linter.RuleEntry<TypescriptEslintMemberOrdering>
  /**
   * Enforce using a particular method signature syntax
   * @see https://typescript-eslint.io/rules/method-signature-style
   */
  '@typescript-eslint/method-signature-style'?: Linter.RuleEntry<TypescriptEslintMethodSignatureStyle>
  /**
   * Enforce naming conventions for everything across a codebase
   * @see https://typescript-eslint.io/rules/naming-convention
   */
  '@typescript-eslint/naming-convention'?: Linter.RuleEntry<TypescriptEslintNamingConvention>
  /**
   * Disallow generic `Array` constructors
   * @see https://typescript-eslint.io/rules/no-array-constructor
   */
  '@typescript-eslint/no-array-constructor'?: Linter.RuleEntry<[]>
  /**
   * Disallow using the `delete` operator on array values
   * @see https://typescript-eslint.io/rules/no-array-delete
   */
  '@typescript-eslint/no-array-delete'?: Linter.RuleEntry<[]>
  /**
   * Require `.toString()` and `.toLocaleString()` to only be called on objects which provide useful information when stringified
   * @see https://typescript-eslint.io/rules/no-base-to-string
   */
  '@typescript-eslint/no-base-to-string'?: Linter.RuleEntry<TypescriptEslintNoBaseToString>
  /**
   * Disallow non-null assertion in locations that may be confusing
   * @see https://typescript-eslint.io/rules/no-confusing-non-null-assertion
   */
  '@typescript-eslint/no-confusing-non-null-assertion'?: Linter.RuleEntry<[]>
  /**
   * Require expressions of type void to appear in statement position
   * @see https://typescript-eslint.io/rules/no-confusing-void-expression
   */
  '@typescript-eslint/no-confusing-void-expression'?: Linter.RuleEntry<TypescriptEslintNoConfusingVoidExpression>
  /**
   * Disallow using code marked as `@deprecated`
   * @see https://typescript-eslint.io/rules/no-deprecated
   */
  '@typescript-eslint/no-deprecated'?: Linter.RuleEntry<TypescriptEslintNoDeprecated>
  /**
   * Disallow duplicate class members
   * @see https://typescript-eslint.io/rules/no-dupe-class-members
   */
  '@typescript-eslint/no-dupe-class-members'?: Linter.RuleEntry<[]>
  /**
   * Disallow duplicate enum member values
   * @see https://typescript-eslint.io/rules/no-duplicate-enum-values
   */
  '@typescript-eslint/no-duplicate-enum-values'?: Linter.RuleEntry<[]>
  /**
   * Disallow duplicate constituents of union or intersection types
   * @see https://typescript-eslint.io/rules/no-duplicate-type-constituents
   */
  '@typescript-eslint/no-duplicate-type-constituents'?: Linter.RuleEntry<TypescriptEslintNoDuplicateTypeConstituents>
  /**
   * Disallow using the `delete` operator on computed key expressions
   * @see https://typescript-eslint.io/rules/no-dynamic-delete
   */
  '@typescript-eslint/no-dynamic-delete'?: Linter.RuleEntry<[]>
  /**
   * Disallow empty functions
   * @see https://typescript-eslint.io/rules/no-empty-function
   */
  '@typescript-eslint/no-empty-function'?: Linter.RuleEntry<TypescriptEslintNoEmptyFunction>
  /**
   * Disallow the declaration of empty interfaces
   * @see https://typescript-eslint.io/rules/no-empty-interface
   * @deprecated
   */
  '@typescript-eslint/no-empty-interface'?: Linter.RuleEntry<TypescriptEslintNoEmptyInterface>
  /**
   * Disallow accidentally using the "empty object" type
   * @see https://typescript-eslint.io/rules/no-empty-object-type
   */
  '@typescript-eslint/no-empty-object-type'?: Linter.RuleEntry<TypescriptEslintNoEmptyObjectType>
  /**
   * Disallow the `any` type
   * @see https://typescript-eslint.io/rules/no-explicit-any
   */
  '@typescript-eslint/no-explicit-any'?: Linter.RuleEntry<TypescriptEslintNoExplicitAny>
  /**
   * Disallow extra non-null assertions
   * @see https://typescript-eslint.io/rules/no-extra-non-null-assertion
   */
  '@typescript-eslint/no-extra-non-null-assertion'?: Linter.RuleEntry<[]>
  /**
   * Disallow classes used as namespaces
   * @see https://typescript-eslint.io/rules/no-extraneous-class
   */
  '@typescript-eslint/no-extraneous-class'?: Linter.RuleEntry<TypescriptEslintNoExtraneousClass>
  /**
   * Require Promise-like statements to be handled appropriately
   * @see https://typescript-eslint.io/rules/no-floating-promises
   */
  '@typescript-eslint/no-floating-promises'?: Linter.RuleEntry<TypescriptEslintNoFloatingPromises>
  /**
   * Disallow iterating over an array with a for-in loop
   * @see https://typescript-eslint.io/rules/no-for-in-array
   */
  '@typescript-eslint/no-for-in-array'?: Linter.RuleEntry<[]>
  /**
   * Disallow the use of `eval()`-like functions
   * @see https://typescript-eslint.io/rules/no-implied-eval
   */
  '@typescript-eslint/no-implied-eval'?: Linter.RuleEntry<[]>
  /**
   * Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers
   * @see https://typescript-eslint.io/rules/no-import-type-side-effects
   */
  '@typescript-eslint/no-import-type-side-effects'?: Linter.RuleEntry<[]>
  /**
   * Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean
   * @see https://typescript-eslint.io/rules/no-inferrable-types
   */
  '@typescript-eslint/no-inferrable-types'?: Linter.RuleEntry<TypescriptEslintNoInferrableTypes>
  /**
   * Disallow `this` keywords outside of classes or class-like objects
   * @see https://typescript-eslint.io/rules/no-invalid-this
   */
  '@typescript-eslint/no-invalid-this'?: Linter.RuleEntry<TypescriptEslintNoInvalidThis>
  /**
   * Disallow `void` type outside of generic or return types
   * @see https://typescript-eslint.io/rules/no-invalid-void-type
   */
  '@typescript-eslint/no-invalid-void-type'?: Linter.RuleEntry<TypescriptEslintNoInvalidVoidType>
  /**
   * Disallow function declarations that contain unsafe references inside loop statements
   * @see https://typescript-eslint.io/rules/no-loop-func
   */
  '@typescript-eslint/no-loop-func'?: Linter.RuleEntry<[]>
  /**
   * Disallow literal numbers that lose precision
   * @see https://typescript-eslint.io/rules/no-loss-of-precision
   * @deprecated
   */
  '@typescript-eslint/no-loss-of-precision'?: Linter.RuleEntry<[]>
  /**
   * Disallow magic numbers
   * @see https://typescript-eslint.io/rules/no-magic-numbers
   */
  '@typescript-eslint/no-magic-numbers'?: Linter.RuleEntry<TypescriptEslintNoMagicNumbers>
  /**
   * Disallow the `void` operator except when used to discard a value
   * @see https://typescript-eslint.io/rules/no-meaningless-void-operator
   */
  '@typescript-eslint/no-meaningless-void-operator'?: Linter.RuleEntry<TypescriptEslintNoMeaninglessVoidOperator>
  /**
   * Enforce valid definition of `new` and `constructor`
   * @see https://typescript-eslint.io/rules/no-misused-new
   */
  '@typescript-eslint/no-misused-new'?: Linter.RuleEntry<[]>
  /**
   * Disallow Promises in places not designed to handle them
   * @see https://typescript-eslint.io/rules/no-misused-promises
   */
  '@typescript-eslint/no-misused-promises'?: Linter.RuleEntry<TypescriptEslintNoMisusedPromises>
  /**
   * Disallow using the spread operator when it might cause unexpected behavior
   * @see https://typescript-eslint.io/rules/no-misused-spread
   */
  '@typescript-eslint/no-misused-spread'?: Linter.RuleEntry<TypescriptEslintNoMisusedSpread>
  /**
   * Disallow enums from having both number and string members
   * @see https://typescript-eslint.io/rules/no-mixed-enums
   */
  '@typescript-eslint/no-mixed-enums'?: Linter.RuleEntry<[]>
  /**
   * Disallow TypeScript namespaces
   * @see https://typescript-eslint.io/rules/no-namespace
   */
  '@typescript-eslint/no-namespace'?: Linter.RuleEntry<TypescriptEslintNoNamespace>
  /**
   * Disallow non-null assertions in the left operand of a nullish coalescing operator
   * @see https://typescript-eslint.io/rules/no-non-null-asserted-nullish-coalescing
   */
  '@typescript-eslint/no-non-null-asserted-nullish-coalescing'?: Linter.RuleEntry<[]>
  /**
   * Disallow non-null assertions after an optional chain expression
   * @see https://typescript-eslint.io/rules/no-non-null-asserted-optional-chain
   */
  '@typescript-eslint/no-non-null-asserted-optional-chain'?: Linter.RuleEntry<[]>
  /**
   * Disallow non-null assertions using the `!` postfix operator
   * @see https://typescript-eslint.io/rules/no-non-null-assertion
   */
  '@typescript-eslint/no-non-null-assertion'?: Linter.RuleEntry<[]>
  /**
   * Disallow variable redeclaration
   * @see https://typescript-eslint.io/rules/no-redeclare
   */
  '@typescript-eslint/no-redeclare'?: Linter.RuleEntry<TypescriptEslintNoRedeclare>
  /**
   * Disallow members of unions and intersections that do nothing or override type information
   * @see https://typescript-eslint.io/rules/no-redundant-type-constituents
   */
  '@typescript-eslint/no-redundant-type-constituents'?: Linter.RuleEntry<[]>
  /**
   * Disallow invocation of `require()`
   * @see https://typescript-eslint.io/rules/no-require-imports
   */
  '@typescript-eslint/no-require-imports'?: Linter.RuleEntry<TypescriptEslintNoRequireImports>
  /**
   * Disallow specified modules when loaded by `import`
   * @see https://typescript-eslint.io/rules/no-restricted-imports
   */
  '@typescript-eslint/no-restricted-imports'?: Linter.RuleEntry<TypescriptEslintNoRestrictedImports>
  /**
   * Disallow certain types
   * @see https://typescript-eslint.io/rules/no-restricted-types
   */
  '@typescript-eslint/no-restricted-types'?: Linter.RuleEntry<TypescriptEslintNoRestrictedTypes>
  /**
   * Disallow variable declarations from shadowing variables declared in the outer scope
   * @see https://typescript-eslint.io/rules/no-shadow
   */
  '@typescript-eslint/no-shadow'?: Linter.RuleEntry<TypescriptEslintNoShadow>
  /**
   * Disallow aliasing `this`
   * @see https://typescript-eslint.io/rules/no-this-alias
   */
  '@typescript-eslint/no-this-alias'?: Linter.RuleEntry<TypescriptEslintNoThisAlias>
  /**
   * Disallow type aliases
   * @see https://typescript-eslint.io/rules/no-type-alias
   * @deprecated
   */
  '@typescript-eslint/no-type-alias'?: Linter.RuleEntry<TypescriptEslintNoTypeAlias>
  /**
   * Disallow unnecessary equality comparisons against boolean literals
   * @see https://typescript-eslint.io/rules/no-unnecessary-boolean-literal-compare
   */
  '@typescript-eslint/no-unnecessary-boolean-literal-compare'?: Linter.RuleEntry<TypescriptEslintNoUnnecessaryBooleanLiteralCompare>
  /**
   * Disallow conditionals where the type is always truthy or always falsy
   * @see https://typescript-eslint.io/rules/no-unnecessary-condition
   */
  '@typescript-eslint/no-unnecessary-condition'?: Linter.RuleEntry<TypescriptEslintNoUnnecessaryCondition>
  /**
   * Disallow unnecessary assignment of constructor property parameter
   * @see https://typescript-eslint.io/rules/no-unnecessary-parameter-property-assignment
   */
  '@typescript-eslint/no-unnecessary-parameter-property-assignment'?: Linter.RuleEntry<[]>
  /**
   * Disallow unnecessary namespace qualifiers
   * @see https://typescript-eslint.io/rules/no-unnecessary-qualifier
   */
  '@typescript-eslint/no-unnecessary-qualifier'?: Linter.RuleEntry<[]>
  /**
   * Disallow unnecessary template expressions
   * @see https://typescript-eslint.io/rules/no-unnecessary-template-expression
   */
  '@typescript-eslint/no-unnecessary-template-expression'?: Linter.RuleEntry<[]>
  /**
   * Disallow type arguments that are equal to the default
   * @see https://typescript-eslint.io/rules/no-unnecessary-type-arguments
   */
  '@typescript-eslint/no-unnecessary-type-arguments'?: Linter.RuleEntry<[]>
  /**
   * Disallow type assertions that do not change the type of an expression
   * @see https://typescript-eslint.io/rules/no-unnecessary-type-assertion
   */
  '@typescript-eslint/no-unnecessary-type-assertion'?: Linter.RuleEntry<TypescriptEslintNoUnnecessaryTypeAssertion>
  /**
   * Disallow unnecessary constraints on generic types
   * @see https://typescript-eslint.io/rules/no-unnecessary-type-constraint
   */
  '@typescript-eslint/no-unnecessary-type-constraint'?: Linter.RuleEntry<[]>
  /**
   * Disallow conversion idioms when they do not change the type or value of the expression
   * @see https://typescript-eslint.io/rules/no-unnecessary-type-conversion
   */
  '@typescript-eslint/no-unnecessary-type-conversion'?: Linter.RuleEntry<[]>
  /**
   * Disallow type parameters that aren't used multiple times
   * @see https://typescript-eslint.io/rules/no-unnecessary-type-parameters
   */
  '@typescript-eslint/no-unnecessary-type-parameters'?: Linter.RuleEntry<[]>
  /**
   * Disallow calling a function with a value with type `any`
   * @see https://typescript-eslint.io/rules/no-unsafe-argument
   */
  '@typescript-eslint/no-unsafe-argument'?: Linter.RuleEntry<[]>
  /**
   * Disallow assigning a value with type `any` to variables and properties
   * @see https://typescript-eslint.io/rules/no-unsafe-assignment
   */
  '@typescript-eslint/no-unsafe-assignment'?: Linter.RuleEntry<[]>
  /**
   * Disallow calling a value with type `any`
   * @see https://typescript-eslint.io/rules/no-unsafe-call
   */
  '@typescript-eslint/no-unsafe-call'?: Linter.RuleEntry<[]>
  /**
   * Disallow unsafe declaration merging
   * @see https://typescript-eslint.io/rules/no-unsafe-declaration-merging
   */
  '@typescript-eslint/no-unsafe-declaration-merging'?: Linter.RuleEntry<[]>
  /**
   * Disallow comparing an enum value with a non-enum value
   * @see https://typescript-eslint.io/rules/no-unsafe-enum-comparison
   */
  '@typescript-eslint/no-unsafe-enum-comparison'?: Linter.RuleEntry<[]>
  /**
   * Disallow using the unsafe built-in Function type
   * @see https://typescript-eslint.io/rules/no-unsafe-function-type
   */
  '@typescript-eslint/no-unsafe-function-type'?: Linter.RuleEntry<[]>
  /**
   * Disallow member access on a value with type `any`
   * @see https://typescript-eslint.io/rules/no-unsafe-member-access
   */
  '@typescript-eslint/no-unsafe-member-access'?: Linter.RuleEntry<[]>
  /**
   * Disallow returning a value with type `any` from a function
   * @see https://typescript-eslint.io/rules/no-unsafe-return
   */
  '@typescript-eslint/no-unsafe-return'?: Linter.RuleEntry<[]>
  /**
   * Disallow type assertions that narrow a type
   * @see https://typescript-eslint.io/rules/no-unsafe-type-assertion
   */
  '@typescript-eslint/no-unsafe-type-assertion'?: Linter.RuleEntry<[]>
  /**
   * Require unary negation to take a number
   * @see https://typescript-eslint.io/rules/no-unsafe-unary-minus
   */
  '@typescript-eslint/no-unsafe-unary-minus'?: Linter.RuleEntry<[]>
  /**
   * Disallow unused expressions
   * @see https://typescript-eslint.io/rules/no-unused-expressions
   */
  '@typescript-eslint/no-unused-expressions'?: Linter.RuleEntry<TypescriptEslintNoUnusedExpressions>
  /**
   * Disallow unused variables
   * @see https://typescript-eslint.io/rules/no-unused-vars
   */
  '@typescript-eslint/no-unused-vars'?: Linter.RuleEntry<TypescriptEslintNoUnusedVars>
  /**
   * Disallow the use of variables before they are defined
   * @see https://typescript-eslint.io/rules/no-use-before-define
   */
  '@typescript-eslint/no-use-before-define'?: Linter.RuleEntry<TypescriptEslintNoUseBeforeDefine>
  /**
   * Disallow unnecessary constructors
   * @see https://typescript-eslint.io/rules/no-useless-constructor
   */
  '@typescript-eslint/no-useless-constructor'?: Linter.RuleEntry<[]>
  /**
   * Disallow empty exports that don't change anything in a module file
   * @see https://typescript-eslint.io/rules/no-useless-empty-export
   */
  '@typescript-eslint/no-useless-empty-export'?: Linter.RuleEntry<[]>
  /**
   * Disallow `require` statements except in import statements
   * @see https://typescript-eslint.io/rules/no-var-requires
   * @deprecated
   */
  '@typescript-eslint/no-var-requires'?: Linter.RuleEntry<TypescriptEslintNoVarRequires>
  /**
   * Disallow using confusing built-in primitive class wrappers
   * @see https://typescript-eslint.io/rules/no-wrapper-object-types
   */
  '@typescript-eslint/no-wrapper-object-types'?: Linter.RuleEntry<[]>
  /**
   * Enforce non-null assertions over explicit type assertions
   * @see https://typescript-eslint.io/rules/non-nullable-type-assertion-style
   */
  '@typescript-eslint/non-nullable-type-assertion-style'?: Linter.RuleEntry<[]>
  /**
   * Disallow throwing non-`Error` values as exceptions
   * @see https://typescript-eslint.io/rules/only-throw-error
   */
  '@typescript-eslint/only-throw-error'?: Linter.RuleEntry<TypescriptEslintOnlyThrowError>
  /**
   * Require or disallow parameter properties in class constructors
   * @see https://typescript-eslint.io/rules/parameter-properties
   */
  '@typescript-eslint/parameter-properties'?: Linter.RuleEntry<TypescriptEslintParameterProperties>
  /**
   * Enforce the use of `as const` over literal type
   * @see https://typescript-eslint.io/rules/prefer-as-const
   */
  '@typescript-eslint/prefer-as-const'?: Linter.RuleEntry<[]>
  /**
   * Require destructuring from arrays and/or objects
   * @see https://typescript-eslint.io/rules/prefer-destructuring
   */
  '@typescript-eslint/prefer-destructuring'?: Linter.RuleEntry<TypescriptEslintPreferDestructuring>
  /**
   * Require each enum member value to be explicitly initialized
   * @see https://typescript-eslint.io/rules/prefer-enum-initializers
   */
  '@typescript-eslint/prefer-enum-initializers'?: Linter.RuleEntry<[]>
  /**
   * Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result
   * @see https://typescript-eslint.io/rules/prefer-find
   */
  '@typescript-eslint/prefer-find'?: Linter.RuleEntry<[]>
  /**
   * Enforce the use of `for-of` loop over the standard `for` loop where possible
   * @see https://typescript-eslint.io/rules/prefer-for-of
   */
  '@typescript-eslint/prefer-for-of'?: Linter.RuleEntry<[]>
  /**
   * Enforce using function types instead of interfaces with call signatures
   * @see https://typescript-eslint.io/rules/prefer-function-type
   */
  '@typescript-eslint/prefer-function-type'?: Linter.RuleEntry<[]>
  /**
   * Enforce `includes` method over `indexOf` method
   * @see https://typescript-eslint.io/rules/prefer-includes
   */
  '@typescript-eslint/prefer-includes'?: Linter.RuleEntry<[]>
  /**
   * Require all enum members to be literal values
   * @see https://typescript-eslint.io/rules/prefer-literal-enum-member
   */
  '@typescript-eslint/prefer-literal-enum-member'?: Linter.RuleEntry<TypescriptEslintPreferLiteralEnumMember>
  /**
   * Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules
   * @see https://typescript-eslint.io/rules/prefer-namespace-keyword
   */
  '@typescript-eslint/prefer-namespace-keyword'?: Linter.RuleEntry<[]>
  /**
   * Enforce using the nullish coalescing operator instead of logical assignments or chaining
   * @see https://typescript-eslint.io/rules/prefer-nullish-coalescing
   */
  '@typescript-eslint/prefer-nullish-coalescing'?: Linter.RuleEntry<TypescriptEslintPreferNullishCoalescing>
  /**
   * Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects
   * @see https://typescript-eslint.io/rules/prefer-optional-chain
   */
  '@typescript-eslint/prefer-optional-chain'?: Linter.RuleEntry<TypescriptEslintPreferOptionalChain>
  /**
   * Require using Error objects as Promise rejection reasons
   * @see https://typescript-eslint.io/rules/prefer-promise-reject-errors
   */
  '@typescript-eslint/prefer-promise-reject-errors'?: Linter.RuleEntry<TypescriptEslintPreferPromiseRejectErrors>
  /**
   * Require private members to be marked as `readonly` if they're never modified outside of the constructor
   * @see https://typescript-eslint.io/rules/prefer-readonly
   */
  '@typescript-eslint/prefer-readonly'?: Linter.RuleEntry<TypescriptEslintPreferReadonly>
  /**
   * Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs
   * @see https://typescript-eslint.io/rules/prefer-readonly-parameter-types
   */
  '@typescript-eslint/prefer-readonly-parameter-types'?: Linter.RuleEntry<TypescriptEslintPreferReadonlyParameterTypes>
  /**
   * Enforce using type parameter when calling `Array#reduce` instead of using a type assertion
   * @see https://typescript-eslint.io/rules/prefer-reduce-type-parameter
   */
  '@typescript-eslint/prefer-reduce-type-parameter'?: Linter.RuleEntry<[]>
  /**
   * Enforce `RegExp#exec` over `String#match` if no global flag is provided
   * @see https://typescript-eslint.io/rules/prefer-regexp-exec
   */
  '@typescript-eslint/prefer-regexp-exec'?: Linter.RuleEntry<[]>
  /**
   * Enforce that `this` is used when only `this` type is returned
   * @see https://typescript-eslint.io/rules/prefer-return-this-type
   */
  '@typescript-eslint/prefer