@ncontiero/eslint-config 7.2.0 → 7.3.0-beta.0

package/dist/index.d.mts

@@ -4207,642 +4207,742 @@ interface RuleOptions {
    * @see https://eslint.org/docs/latest/rules/radix
    */
   'radix'?: Linter.RuleEntry<Radix>;
+  'react-refresh/only-export-components'?: Linter.RuleEntry<ReactRefreshOnlyExportComponents>;
+  /**
+   * Disallows higher order functions that define components or hooks inside them.
+   * @see https://eslint-react.xyz/docs/rules/component-hook-factories
+   */
+  'react/component-hook-factories'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallows DOM elements from using 'dangerouslySetInnerHTML'.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-dangerously-set-innerhtml
+   */
+  'react/dom-no-dangerously-set-innerhtml'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallows DOM elements from using 'dangerouslySetInnerHTML' and 'children' at the same time.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-dangerously-set-innerhtml-with-children
+   */
+  'react/dom-no-dangerously-set-innerhtml-with-children'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallows 'findDOMNode'.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-find-dom-node
+   */
+  'react/dom-no-find-dom-node'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallows 'flushSync'.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-flush-sync
+   */
+  'react/dom-no-flush-sync'?: Linter.RuleEntry<[]>;
   /**
-   * Verifies that automatic effect dependencies are compiled if opted-in
+   * Replaces usage of 'ReactDOM.hydrate()' with 'hydrateRoot()'.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-hydrate
    */
-  'react-hooks/automatic-effect-dependencies'?: Linter.RuleEntry<ReactHooksAutomaticEffectDependencies>;
+  'react/dom-no-hydrate'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against calling capitalized functions/methods instead of using JSX
+   * Enforces an explicit 'type' attribute for 'button' elements.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-missing-button-type
    */
-  'react-hooks/capitalized-calls'?: Linter.RuleEntry<ReactHooksCapitalizedCalls>;
+  'react/dom-no-missing-button-type'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against higher order functions defining nested components or hooks. Components and hooks should be defined at the module level
+   * Enforces an explicit 'sandbox' attribute for 'iframe' elements.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-missing-iframe-sandbox
    */
-  'react-hooks/component-hook-factories'?: Linter.RuleEntry<ReactHooksComponentHookFactories>;
+  'react/dom-no-missing-iframe-sandbox'?: Linter.RuleEntry<[]>;
   /**
-   * Validates the compiler configuration options
+   * Replaces usage of 'ReactDOM.render()' with 'createRoot(node).render()'.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-render
    */
-  'react-hooks/config'?: Linter.RuleEntry<ReactHooksConfig>;
+  'react/dom-no-render'?: Linter.RuleEntry<[]>;
   /**
-   * Validates usage of error boundaries instead of try/catch for errors in child components
+   * Disallows the return value of 'ReactDOM.render'.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-render-return-value
    */
-  'react-hooks/error-boundaries'?: Linter.RuleEntry<ReactHooksErrorBoundaries>;
+  'react/dom-no-render-return-value'?: Linter.RuleEntry<[]>;
   /**
-   * verifies the list of dependencies for Hooks like useEffect and similar
+   * Disallows 'javascript:' URLs as attribute values.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-script-url
+   */
+  'react/dom-no-script-url'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallows the use of string style prop in JSX. Use an object instead.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-string-style-prop
+   */
+  'react/dom-no-string-style-prop'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallows unknown 'DOM' properties.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-unknown-property
+   */
+  'react/dom-no-unknown-property'?: Linter.RuleEntry<ReactDomNoUnknownProperty>;
+  /**
+   * Enforces that the 'sandbox' attribute for 'iframe' elements is not set to unsafe combinations.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-unsafe-iframe-sandbox
+   */
+  'react/dom-no-unsafe-iframe-sandbox'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallows 'target="_blank"' without 'rel="noreferrer noopener"'.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-unsafe-target-blank
+   */
+  'react/dom-no-unsafe-target-blank'?: Linter.RuleEntry<[]>;
+  /**
+   * Replaces usage of 'useFormState' with 'useActionState'.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-use-form-state
+   */
+  'react/dom-no-use-form-state'?: Linter.RuleEntry<[]>;
+  /**
+   * Disallows 'children' in void DOM elements.
+   * @see https://eslint-react.xyz/docs/rules/dom-no-void-elements-with-children
+   */
+  'react/dom-no-void-elements-with-children'?: Linter.RuleEntry<[]>;
+  /**
+   * Enforces importing React DOM via a namespace import.
+   * @see https://eslint-react.xyz/docs/rules/dom-prefer-namespace-import
+   */
+  'react/dom-prefer-namespace-import'?: Linter.RuleEntry<[]>;
+  /**
+   * Validates usage of Error Boundaries instead of try/catch for errors in child components.
+   * @see https://eslint-react.xyz/docs/rules/error-boundaries
+   */
+  'react/error-boundaries'?: Linter.RuleEntry<[]>;
+  /**
+   * Verifies the list of dependencies for Hooks like 'useEffect' and similar.
    * @see https://github.com/facebook/react/issues/14920
    */
-  'react-hooks/exhaustive-deps'?: Linter.RuleEntry<ReactHooksExhaustiveDeps>;
+  'react/exhaustive-deps'?: Linter.RuleEntry<ReactExhaustiveDeps>;
   /**
-   * Validates usage of fbt
+   * Validates against mutating props, state, and other values that are immutable.
+   * @see https://eslint-react.xyz/docs/rules/immutability
    */
-  'react-hooks/fbt'?: Linter.RuleEntry<ReactHooksFbt>;
+  'react/immutability'?: Linter.RuleEntry<[]>;
   /**
-   * Validates usage of `fire`
+   * Disallows passing 'children' as a prop.
+   * @see https://eslint-react.xyz/docs/rules/no-children-prop
    */
-  'react-hooks/fire'?: Linter.RuleEntry<ReactHooksFire>;
+  'react/jsx-no-children-prop'?: Linter.RuleEntry<[]>;
   /**
-   * Validates configuration of [gating mode](https://react.dev/reference/react-compiler/gating)
+   * Disallows passing 'children' as a prop when children are also passed as nested content.
+   * @see https://eslint-react.xyz/docs/rules/no-children-prop-with-children
    */
-  'react-hooks/gating'?: Linter.RuleEntry<ReactHooksGating>;
+  'react/jsx-no-children-prop-with-children'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against assignment/mutation of globals during render, part of ensuring that [side effects must render outside of render](https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
+   * Prevents comment strings from being accidentally inserted into a JSX element's text nodes.
+   * @see https://eslint-react.xyz/docs/rules/no-comment-textnodes
    */
-  'react-hooks/globals'?: Linter.RuleEntry<ReactHooksGlobals>;
+  'react/jsx-no-comment-textnodes'?: Linter.RuleEntry<[]>;
   /**
-   * Validates the rules of hooks
+   * Prevent patterns that cause deoptimization when using the automatic JSX runtime.
+   * @see https://eslint-react.xyz/docs/rules/no-key-after-spread
    */
-  'react-hooks/hooks'?: Linter.RuleEntry<ReactHooksHooks>;
+  'react/jsx-no-key-after-spread'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against mutating props, state, and other values that [are immutable](https://react.dev/reference/rules/components-and-hooks-must-be-pure#props-and-state-are-immutable)
+   * Catches `$` before `{expr}` in JSX — typically from template literal `${expr}` being copy-pasted into JSX without removing the `$`. The `$` "leaks" into the rendered output.
+   * @see https://eslint-react.xyz/docs/rules/no-leaked-dollar
    */
-  'react-hooks/immutability'?: Linter.RuleEntry<ReactHooksImmutability>;
+  'react/jsx-no-leaked-dollar'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against usage of libraries which are incompatible with memoization (manual or automatic)
+   * Catches `;` at the start of JSX text nodes — typically from accidentally placing a statement-ending `;` inside JSX. The `;` "leaks" into the rendered output.
+   * @see https://eslint-react.xyz/docs/rules/no-leaked-semicolon
    */
-  'react-hooks/incompatible-library'?: Linter.RuleEntry<ReactHooksIncompatibleLibrary>;
+  'react/jsx-no-leaked-semicolon'?: Linter.RuleEntry<[]>;
   /**
-   * Internal invariants
+   * Disallow JSX namespace syntax, as React does not support them.
+   * @see https://eslint-react.xyz/docs/rules/no-namespace
    */
-  'react-hooks/invariant'?: Linter.RuleEntry<ReactHooksInvariant>;
+  'react/jsx-no-namespace'?: Linter.RuleEntry<[]>;
   /**
-   * Validates that effect dependencies are memoized
+   * Disallows useless fragment elements.
+   * @see https://eslint-react.xyz/docs/rules/no-useless-fragment
    */
-  'react-hooks/memoized-effect-dependencies'?: Linter.RuleEntry<ReactHooksMemoizedEffectDependencies>;
+  'react/jsx-no-useless-fragment'?: Linter.RuleEntry<ReactJsxNoUselessFragment>;
   /**
-   * Validates against deriving values from state in an effect
+   * Enforces the context name to be a valid component name with the suffix 'Context'.
+   * @see https://eslint-react.xyz/docs/rules/naming-convention-context-name
    */
-  'react-hooks/no-deriving-state-in-effects'?: Linter.RuleEntry<ReactHooksNoDerivingStateInEffects>;
+  'react/naming-convention-context-name'?: Linter.RuleEntry<[]>;
   /**
-   * Validates that existing manual memoized is preserved by the compiler. React Compiler will only compile components and hooks if its inference [matches or exceeds the existing manual memoization](https://react.dev/learn/react-compiler/introduction#what-should-i-do-about-usememo-usecallback-and-reactmemo)
+   * Enforces identifier names assigned from 'useId' calls to be either 'id' or end with 'Id'.
+   * @see https://eslint-react.xyz/docs/rules/naming-convention-id-name
    */
-  'react-hooks/preserve-manual-memoization'?: Linter.RuleEntry<ReactHooksPreserveManualMemoization>;
+  'react/naming-convention-id-name'?: Linter.RuleEntry<[]>;
   /**
-   * Validates that [components/hooks are pure](https://react.dev/reference/rules/components-and-hooks-must-be-pure) by checking that they do not call known-impure functions
+   * Enforces identifier names assigned from 'useRef' calls to be either 'ref' or end with 'Ref'.
+   * @see https://eslint-react.xyz/docs/rules/naming-convention-ref-name
    */
-  'react-hooks/purity'?: Linter.RuleEntry<ReactHooksPurity>;
+  'react/naming-convention-ref-name'?: Linter.RuleEntry<[]>;
   /**
-   * Validates correct usage of refs, not reading/writing during render. See the "pitfalls" section in [`useRef()` usage](https://react.dev/reference/react/useRef#usage)
+   * Disallows accessing 'this.state' inside 'setState' calls.
+   * @see https://eslint-react.xyz/docs/rules/no-access-state-in-setstate
    */
-  'react-hooks/refs'?: Linter.RuleEntry<ReactHooksRefs>;
+  'react/no-access-state-in-setstate'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against suppression of other rules
+   * Disallows using an item's index in the array as its key.
+   * @see https://eslint-react.xyz/docs/rules/no-array-index-key
    */
-  'react-hooks/rule-suppression'?: Linter.RuleEntry<ReactHooksRuleSuppression>;
+  'react/no-array-index-key'?: Linter.RuleEntry<[]>;
   /**
-   * enforces the Rules of Hooks
-   * @see https://react.dev/reference/rules/rules-of-hooks
+   * Disallows the use of 'Children.count' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-count
    */
-  'react-hooks/rules-of-hooks'?: Linter.RuleEntry<ReactHooksRulesOfHooks>;
+  'react/no-children-count'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against calling setState synchronously in an effect, which can lead to re-renders that degrade performance
+   * Disallows the use of 'Children.forEach' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-for-each
    */
-  'react-hooks/set-state-in-effect'?: Linter.RuleEntry<ReactHooksSetStateInEffect>;
+  'react/no-children-for-each'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against setting state during render, which can trigger additional renders and potential infinite render loops
+   * Disallows the use of 'Children.map' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-map
    */
-  'react-hooks/set-state-in-render'?: Linter.RuleEntry<ReactHooksSetStateInRender>;
+  'react/no-children-map'?: Linter.RuleEntry<[]>;
   /**
-   * Validates that components are static, not recreated every render. Components that are recreated dynamically can reset state and trigger excessive re-rendering
+   * Disallows the use of 'Children.only' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-only
    */
-  'react-hooks/static-components'?: Linter.RuleEntry<ReactHooksStaticComponents>;
+  'react/no-children-only'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against invalid syntax
+   * Disallows the use of 'Children.toArray' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-to-array
    */
-  'react-hooks/syntax'?: Linter.RuleEntry<ReactHooksSyntax>;
+  'react/no-children-to-array'?: Linter.RuleEntry<[]>;
   /**
-   * Unimplemented features
+   * Disallows class components except for error boundaries.
+   * @see https://eslint-react.xyz/docs/rules/no-class-component
    */
-  'react-hooks/todo'?: Linter.RuleEntry<ReactHooksTodo>;
+  'react/no-class-component'?: Linter.RuleEntry<[]>;
   /**
-   * Validates against syntax that we do not plan to support in React Compiler
+   * Disallows 'cloneElement'.
+   * @see https://eslint-react.xyz/docs/rules/no-clone-element
    */
-  'react-hooks/unsupported-syntax'?: Linter.RuleEntry<ReactHooksUnsupportedSyntax>;
+  'react/no-clone-element'?: Linter.RuleEntry<[]>;
   /**
-   * Validates usage of the useMemo() hook against common mistakes. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.
+   * Replaces usage of 'componentWillMount' with 'UNSAFE_componentWillMount'.
+   * @see https://eslint-react.xyz/docs/rules/no-component-will-mount
    */
-  'react-hooks/use-memo'?: Linter.RuleEntry<ReactHooksUseMemo>;
+  'react/no-component-will-mount'?: Linter.RuleEntry<[]>;
   /**
-   * Validates that useMemos always return a value and that the result of the useMemo is used by the component/hook. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.
+   * Replaces usage of 'componentWillReceiveProps' with 'UNSAFE_componentWillReceiveProps'.
+   * @see https://eslint-react.xyz/docs/rules/no-component-will-receive-props
    */
-  'react-hooks/void-use-memo'?: Linter.RuleEntry<ReactHooksVoidUseMemo>;
-  'react-refresh/only-export-components'?: Linter.RuleEntry<ReactRefreshOnlyExportComponents>;
+  'react/no-component-will-receive-props'?: Linter.RuleEntry<[]>;
   /**
-   * Enforces consistent naming for boolean props
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/boolean-prop-naming.md
+   * Replaces usage of 'componentWillUpdate' with 'UNSAFE_componentWillUpdate'.
+   * @see https://eslint-react.xyz/docs/rules/no-component-will-update
    */
-  'react/boolean-prop-naming'?: Linter.RuleEntry<ReactBooleanPropNaming>;
+  'react/no-component-will-update'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of `button` elements without an explicit `type` attribute
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/button-has-type.md
+   * Replaces usage of '<Context.Provider>' with '<Context>'.
+   * @see https://eslint-react.xyz/docs/rules/no-context-provider
    */
-  'react/button-has-type'?: Linter.RuleEntry<ReactButtonHasType>;
+  'react/no-context-provider'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce using `onChange` or `readonly` attribute when `checked` is used
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/checked-requires-onchange-or-readonly.md
+   * Disallows 'createRef' in function components.
+   * @see https://eslint-react.xyz/docs/rules/no-create-ref
    */
-  'react/checked-requires-onchange-or-readonly'?: Linter.RuleEntry<ReactCheckedRequiresOnchangeOrReadonly>;
+  'react/no-create-ref'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce all defaultProps have a corresponding non-required PropType
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/default-props-match-prop-types.md
+   * Disallows direct mutation of 'this.state'.
+   * @see https://eslint-react.xyz/docs/rules/no-direct-mutation-state
    */
-  'react/default-props-match-prop-types'?: Linter.RuleEntry<ReactDefaultPropsMatchPropTypes>;
+  'react/no-direct-mutation-state'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce consistent usage of destructuring assignment of props, state, and context
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/destructuring-assignment.md
+   * Prevents duplicate 'key' props on sibling elements when rendering lists.
+   * @see https://eslint-react.xyz/docs/rules/no-duplicate-key
    */
-  'react/destructuring-assignment'?: Linter.RuleEntry<ReactDestructuringAssignment>;
+  'react/no-duplicate-key'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow missing displayName in a React component definition
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/display-name.md
+   * Replaces usage of 'forwardRef' with passing 'ref' as a prop.
+   * @see https://eslint-react.xyz/docs/rules/no-forward-ref
    */
-  'react/display-name'?: Linter.RuleEntry<ReactDisplayName>;
+  'react/no-forward-ref'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow certain props on components
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-component-props.md
+   * Prevents implicitly passing the 'children' prop to components.
+   * @see https://eslint-react.xyz/docs/rules/no-implicit-children
    */
-  'react/forbid-component-props'?: Linter.RuleEntry<ReactForbidComponentProps>;
+  'react/no-implicit-children'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow certain props on DOM Nodes
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-dom-props.md
+   * Prevents implicitly passing the 'key' prop to components.
+   * @see https://eslint-react.xyz/docs/rules/no-implicit-key
    */
-  'react/forbid-dom-props'?: Linter.RuleEntry<ReactForbidDomProps>;
+  'react/no-implicit-key'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow certain elements
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-elements.md
+   * Prevents implicitly passing the 'ref' prop to components.
+   * @see https://eslint-react.xyz/docs/rules/no-implicit-ref
    */
-  'react/forbid-elements'?: Linter.RuleEntry<ReactForbidElements>;
+  'react/no-implicit-ref'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow using another component's propTypes
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-foreign-prop-types.md
+   * Prevents problematic leaked values from being rendered.
+   * @see https://eslint-react.xyz/docs/rules/no-leaked-conditional-rendering
    */
-  'react/forbid-foreign-prop-types'?: Linter.RuleEntry<ReactForbidForeignPropTypes>;
+  'react/no-leaked-conditional-rendering'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow certain propTypes
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-prop-types.md
+   * Enforces that all components have a 'displayName' that can be used in DevTools.
+   * @see https://eslint-react.xyz/docs/rules/no-missing-component-display-name
    */
-  'react/forbid-prop-types'?: Linter.RuleEntry<ReactForbidPropTypes>;
+  'react/no-missing-component-display-name'?: Linter.RuleEntry<[]>;
   /**
-   * Require all forwardRef components include a ref parameter
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forward-ref-uses-ref.md
+   * Enforces that all contexts have a 'displayName' that can be used in DevTools.
+   * @see https://eslint-react.xyz/docs/rules/no-missing-context-display-name
    */
-  'react/forward-ref-uses-ref'?: Linter.RuleEntry<[]>;
+  'react/no-missing-context-display-name'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce a specific function type for function components
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/function-component-definition.md
+   * Disallows missing 'key' on items in list rendering.
+   * @see https://eslint-react.xyz/docs/rules/no-missing-key
    */
-  'react/function-component-definition'?: Linter.RuleEntry<ReactFunctionComponentDefinition>;
+  'react/no-missing-key'?: Linter.RuleEntry<[]>;
   /**
-   * Ensure destructuring and symmetric naming of useState hook value and setter variables
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/hook-use-state.md
+   * Prevents incorrect usage of 'captureOwnerStack'.
+   * @see https://eslint-react.xyz/docs/rules/no-misused-capture-owner-stack
    */
-  'react/hook-use-state'?: Linter.RuleEntry<ReactHookUseState>;
+  'react/no-misused-capture-owner-stack'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce sandbox attribute on iframe elements
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/iframe-missing-sandbox.md
+   * Disallows nesting component definitions inside other components.
+   * @see https://eslint-react.xyz/docs/rules/no-nested-component-definitions
    */
-  'react/iframe-missing-sandbox'?: Linter.RuleEntry<[]>;
+  'react/no-nested-component-definitions'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce boolean attributes notation in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-boolean-value.md
+   * Disallows nesting lazy component declarations inside other components or hooks.
+   * @see https://eslint-react.xyz/docs/rules/no-nested-lazy-component-declarations
    */
-  'react/jsx-boolean-value'?: Linter.RuleEntry<ReactJsxBooleanValue>;
+  'react/no-nested-lazy-component-declarations'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-child-element-spacing.md
+   * Disallows 'shouldComponentUpdate' when extending 'React.PureComponent'.
+   * @see https://eslint-react.xyz/docs/rules/no-redundant-should-component-update
    */
-  'react/jsx-child-element-spacing'?: Linter.RuleEntry<[]>;
+  'react/no-redundant-should-component-update'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce closing bracket location in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-closing-bracket-location.md
+   * Disallows calling 'this.setState' in 'componentDidMount' outside functions such as callbacks.
+   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-did-mount
    */
-  'react/jsx-closing-bracket-location'?: Linter.RuleEntry<ReactJsxClosingBracketLocation>;
+  'react/no-set-state-in-component-did-mount'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce closing tag location for multiline JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-closing-tag-location.md
+   * Disallows calling 'this.setState' in 'componentDidUpdate' outside functions such as callbacks.
+   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-did-update
    */
-  'react/jsx-closing-tag-location'?: Linter.RuleEntry<ReactJsxClosingTagLocation>;
+  'react/no-set-state-in-component-did-update'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-curly-brace-presence.md
+   * Disallows calling 'this.setState' in 'componentWillUpdate' outside functions such as callbacks.
+   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-will-update
    */
-  'react/jsx-curly-brace-presence'?: Linter.RuleEntry<ReactJsxCurlyBracePresence>;
+  'react/no-set-state-in-component-will-update'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce consistent linebreaks in curly braces in JSX attributes and expressions
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-curly-newline.md
+   * Disallows unnecessary usage of 'useCallback'.
+   * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-callback
    */
-  'react/jsx-curly-newline'?: Linter.RuleEntry<ReactJsxCurlyNewline>;
+  'react/no-unnecessary-use-callback'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-curly-spacing.md
+   * Disallows unnecessary usage of 'useMemo'.
+   * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-memo
    */
-  'react/jsx-curly-spacing'?: Linter.RuleEntry<ReactJsxCurlySpacing>;
+  'react/no-unnecessary-use-memo'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce or disallow spaces around equal signs in JSX attributes
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-equals-spacing.md
+   * Enforces that a function with the 'use' prefix uses at least one Hook inside it.
+   * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-prefix
    */
-  'react/jsx-equals-spacing'?: Linter.RuleEntry<ReactJsxEqualsSpacing>;
+  'react/no-unnecessary-use-prefix'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow file extensions that may contain JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-filename-extension.md
+   * Warns about the use of 'UNSAFE_componentWillMount' in class components.
+   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-mount
    */
-  'react/jsx-filename-extension'?: Linter.RuleEntry<ReactJsxFilenameExtension>;
+  'react/no-unsafe-component-will-mount'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce proper position of the first property in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-first-prop-new-line.md
+   * Warns about the use of 'UNSAFE_componentWillReceiveProps' in class components.
+   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-receive-props
    */
-  'react/jsx-first-prop-new-line'?: Linter.RuleEntry<ReactJsxFirstPropNewLine>;
+  'react/no-unsafe-component-will-receive-props'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce shorthand or standard form for React fragments
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-fragments.md
+   * Warns about the use of 'UNSAFE_componentWillUpdate' in class components.
+   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-update
    */
-  'react/jsx-fragments'?: Linter.RuleEntry<ReactJsxFragments>;
+  'react/no-unsafe-component-will-update'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce event handler naming conventions in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-handler-names.md
+   * 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
    */
-  'react/jsx-handler-names'?: Linter.RuleEntry<ReactJsxHandlerNames>;
+  'react/no-unstable-context-value'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce JSX indentation
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-indent.md
+   * Prevents using referential-type values as default props in object destructuring.
+   * @see https://eslint-react.xyz/docs/rules/no-unstable-default-props
    */
-  'react/jsx-indent'?: Linter.RuleEntry<ReactJsxIndent>;
+  'react/no-unstable-default-props'?: Linter.RuleEntry<ReactNoUnstableDefaultProps>;
   /**
-   * Enforce props indentation in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-indent-props.md
+   * Warns about unused class component methods and properties.
+   * @see https://eslint-react.xyz/docs/rules/no-unused-class-component-members
    */
-  'react/jsx-indent-props'?: Linter.RuleEntry<ReactJsxIndentProps>;
+  'react/no-unused-class-component-members'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow missing `key` props in iterators/collection literals
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-key.md
+   * Warns about component props that are defined but never used.
+   * @see https://eslint-react.xyz/docs/rules/no-unused-props
    */
-  'react/jsx-key'?: Linter.RuleEntry<ReactJsxKey>;
+  'react/no-unused-props'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce JSX maximum depth
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-max-depth.md
+   * Warns about unused class component state.
+   * @see https://eslint-react.xyz/docs/rules/no-unused-state
    */
-  'react/jsx-max-depth'?: Linter.RuleEntry<ReactJsxMaxDepth>;
+  'react/no-unused-state'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce maximum of props on a single line in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-max-props-per-line.md
+   * Replaces usage of 'useContext' with 'use'.
+   * @see https://eslint-react.xyz/docs/rules/no-use-context
    */
-  'react/jsx-max-props-per-line'?: Linter.RuleEntry<ReactJsxMaxPropsPerLine>;
+  'react/no-use-context'?: Linter.RuleEntry<[]>;
   /**
-   * Require or prevent a new line after jsx elements and expressions.
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-newline.md
+   * Enforces destructuring assignment for component props and context.
+   * @see https://eslint-react.xyz/docs/rules/prefer-destructuring-assignment
    */
-  'react/jsx-newline'?: Linter.RuleEntry<ReactJsxNewline>;
+  'react/prefer-destructuring-assignment'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow `.bind()` or arrow functions in JSX props
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-bind.md
+   * Enforces importing React via a namespace import.
+   * @see https://eslint-react.xyz/docs/rules/prefer-namespace-import
    */
-  'react/jsx-no-bind'?: Linter.RuleEntry<ReactJsxNoBind>;
+  'react/prefer-namespace-import'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow comments from being inserted as text nodes
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-comment-textnodes.md
+   * Validates that components and hooks are pure by checking that they do not call known-impure functions during render.
+   * @see https://eslint-react.xyz/docs/rules/purity
    */
-  'react/jsx-no-comment-textnodes'?: Linter.RuleEntry<[]>;
+  'react/purity'?: Linter.RuleEntry<[]>;
   /**
-   * Disallows JSX context provider values from taking values that will cause needless rerenders
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-constructed-context-values.md
+   * Validates correct usage of refs by checking that 'ref.current' is not read or written during render.
+   * @see https://eslint-react.xyz/docs/rules/refs
    */
-  'react/jsx-no-constructed-context-values'?: Linter.RuleEntry<[]>;
+  'react/refs'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow duplicate properties in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-duplicate-props.md
+   * Validates and transforms React Client/Server Function definitions.
+   * @see https://eslint-react.xyz/docs/rules/function-definition
    */
-  'react/jsx-no-duplicate-props'?: Linter.RuleEntry<ReactJsxNoDuplicateProps>;
+  'react/rsc-function-definition'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow problematic leaked values from being rendered
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-leaked-render.md
+   * Enforces the Rules of Hooks.
+   * @see https://react.dev/reference/rules/rules-of-hooks
    */
-  'react/jsx-no-leaked-render'?: Linter.RuleEntry<ReactJsxNoLeakedRender>;
+  'react/rules-of-hooks'?: Linter.RuleEntry<ReactRulesOfHooks>;
   /**
-   * Disallow usage of string literals in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-literals.md
+   * Validates against setting state synchronously in an effect, which can lead to re-renders that degrade performance.
+   * @see https://eslint-react.xyz/docs/rules/set-state-in-effect
    */
-  'react/jsx-no-literals'?: Linter.RuleEntry<ReactJsxNoLiterals>;
+  'react/set-state-in-effect'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of `javascript:` URLs
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-script-url.md
+   * Validates against unconditionally setting state during render, which can trigger additional renders and potential infinite render loops.
+   * @see https://eslint-react.xyz/docs/rules/set-state-in-render
    */
-  'react/jsx-no-script-url'?: Linter.RuleEntry<ReactJsxNoScriptUrl>;
+  'react/set-state-in-render'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow `target="_blank"` attribute without `rel="noreferrer"`
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-target-blank.md
+   * Validates against syntax that React Compiler does not support.
+   * @see https://eslint-react.xyz/docs/rules/unsupported-syntax
    */
-  'react/jsx-no-target-blank'?: Linter.RuleEntry<ReactJsxNoTargetBlank>;
+  'react/unsupported-syntax'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow undeclared variables in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-undef.md
+   * Validates that 'useMemo' is called with a callback that returns a value.
+   * @see https://eslint-react.xyz/docs/rules/use-memo
    */
-  'react/jsx-no-undef'?: Linter.RuleEntry<ReactJsxNoUndef>;
+  'react/use-memo'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow unnecessary fragments
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-useless-fragment.md
+   * Enforces correct usage of 'useState', including destructuring, symmetric naming of the value and setter, and wrapping expensive initializers in a lazy initializer function.
+   * @see https://eslint-react.xyz/docs/rules/use-state
    */
-  'react/jsx-no-useless-fragment'?: Linter.RuleEntry<ReactJsxNoUselessFragment>;
+  'react/use-state'?: Linter.RuleEntry<ReactUseState>;
   /**
-   * Require one JSX element per line
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-one-expression-per-line.md
+   * Enforces that every 'addEventListener' in a component or custom hook has a corresponding 'removeEventListener'.
+   * @see https://eslint-react.xyz/docs/rules/web-api-no-leaked-event-listener
    */
-  'react/jsx-one-expression-per-line'?: Linter.RuleEntry<ReactJsxOneExpressionPerLine>;
+  'react/web-api-no-leaked-event-listener'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce PascalCase for user-defined JSX components
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-pascal-case.md
+   * Enforces that every 'setInterval' in a component or custom hook has a corresponding 'clearInterval'.
+   * @see https://eslint-react.xyz/docs/rules/web-api-no-leaked-interval
    */
-  'react/jsx-pascal-case'?: Linter.RuleEntry<ReactJsxPascalCase>;
+  'react/web-api-no-leaked-interval'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow multiple spaces between inline JSX props
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-props-no-multi-spaces.md
+   * Enforces that every 'ResizeObserver' created in a component or custom hook has a corresponding 'ResizeObserver.disconnect()'.
+   * @see https://eslint-react.xyz/docs/rules/web-api-no-leaked-resize-observer
    */
-  'react/jsx-props-no-multi-spaces'?: Linter.RuleEntry<[]>;
+  'react/web-api-no-leaked-resize-observer'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow JSX prop spreading the same identifier multiple times
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-props-no-spread-multi.md
+   * Enforces that every 'setTimeout' in a component or custom hook has a corresponding 'clearTimeout'.
+   * @see https://eslint-react.xyz/docs/rules/web-api-no-leaked-timeout
    */
-  'react/jsx-props-no-spread-multi'?: Linter.RuleEntry<[]>;
+  'react/web-api-no-leaked-timeout'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow JSX prop spreading
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-props-no-spreading.md
+   * Disallows higher order functions that define components or hooks inside them.
+   * @see https://eslint-react.xyz/docs/rules/component-hook-factories
    */
-  'react/jsx-props-no-spreading'?: Linter.RuleEntry<ReactJsxPropsNoSpreading>;
+  'react/x-component-hook-factories'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce defaultProps declarations alphabetical sorting
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-sort-default-props.md
-   * @deprecated
+   * Validates usage of Error Boundaries instead of try/catch for errors in child components.
+   * @see https://eslint-react.xyz/docs/rules/error-boundaries
    */
-  'react/jsx-sort-default-props'?: Linter.RuleEntry<ReactJsxSortDefaultProps>;
+  'react/x-error-boundaries'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce props alphabetical sorting
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-sort-props.md
+   * Verifies the list of dependencies for Hooks like 'useEffect' and similar.
+   * @see https://github.com/facebook/react/issues/14920
    */
-  'react/jsx-sort-props'?: Linter.RuleEntry<ReactJsxSortProps>;
+  'react/x-exhaustive-deps'?: Linter.RuleEntry<ReactXExhaustiveDeps>;
   /**
-   * Enforce spacing before closing bracket in JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-space-before-closing.md
-   * @deprecated
+   * Validates against mutating props, state, and other values that are immutable.
+   * @see https://eslint-react.xyz/docs/rules/immutability
    */
-  'react/jsx-space-before-closing'?: Linter.RuleEntry<ReactJsxSpaceBeforeClosing>;
+  'react/x-immutability'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce whitespace in and around the JSX opening and closing brackets
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-tag-spacing.md
+   * Disallows accessing 'this.state' inside 'setState' calls.
+   * @see https://eslint-react.xyz/docs/rules/no-access-state-in-setstate
    */
-  'react/jsx-tag-spacing'?: Linter.RuleEntry<ReactJsxTagSpacing>;
+  'react/x-no-access-state-in-setstate'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow React to be incorrectly marked as unused
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-uses-react.md
+   * Disallows using an item's index in the array as its key.
+   * @see https://eslint-react.xyz/docs/rules/no-array-index-key
    */
-  'react/jsx-uses-react'?: Linter.RuleEntry<[]>;
+  'react/x-no-array-index-key'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow variables used in JSX to be incorrectly marked as unused
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-uses-vars.md
+   * Disallows the use of 'Children.count' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-count
    */
-  'react/jsx-uses-vars'?: Linter.RuleEntry<[]>;
+  'react/x-no-children-count'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow missing parentheses around multiline JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-wrap-multilines.md
+   * Disallows the use of 'Children.forEach' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-for-each
    */
-  'react/jsx-wrap-multilines'?: Linter.RuleEntry<ReactJsxWrapMultilines>;
+  'react/x-no-children-for-each'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow when this.state is accessed within setState
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-access-state-in-setstate.md
+   * Disallows the use of 'Children.map' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-map
    */
-  'react/no-access-state-in-setstate'?: Linter.RuleEntry<[]>;
+  'react/x-no-children-map'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow adjacent inline elements not separated by whitespace.
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-adjacent-inline-elements.md
+   * Disallows the use of 'Children.only' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-only
    */
-  'react/no-adjacent-inline-elements'?: Linter.RuleEntry<[]>;
+  'react/x-no-children-only'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of Array index in keys
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-array-index-key.md
+   * Disallows the use of 'Children.toArray' from the 'react' package.
+   * @see https://eslint-react.xyz/docs/rules/no-children-to-array
    */
-  'react/no-array-index-key'?: Linter.RuleEntry<[]>;
+  'react/x-no-children-to-array'?: Linter.RuleEntry<[]>;
   /**
-   * Lifecycle methods should be methods on the prototype, not class fields
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-arrow-function-lifecycle.md
+   * Disallows class components except for error boundaries.
+   * @see https://eslint-react.xyz/docs/rules/no-class-component
    */
-  'react/no-arrow-function-lifecycle'?: Linter.RuleEntry<[]>;
+  'react/x-no-class-component'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow passing of children as props
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-children-prop.md
+   * Disallows 'cloneElement'.
+   * @see https://eslint-react.xyz/docs/rules/no-clone-element
    */
-  'react/no-children-prop'?: Linter.RuleEntry<ReactNoChildrenProp>;
+  'react/x-no-clone-element'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of dangerous JSX properties
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-danger.md
+   * Replaces usage of 'componentWillMount' with 'UNSAFE_componentWillMount'.
+   * @see https://eslint-react.xyz/docs/rules/no-component-will-mount
    */
-  'react/no-danger'?: Linter.RuleEntry<ReactNoDanger>;
+  'react/x-no-component-will-mount'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow when a DOM element is using both children and dangerouslySetInnerHTML
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-danger-with-children.md
+   * Replaces usage of 'componentWillReceiveProps' with 'UNSAFE_componentWillReceiveProps'.
+   * @see https://eslint-react.xyz/docs/rules/no-component-will-receive-props
    */
-  'react/no-danger-with-children'?: Linter.RuleEntry<[]>;
+  'react/x-no-component-will-receive-props'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of deprecated methods
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-deprecated.md
+   * Replaces usage of 'componentWillUpdate' with 'UNSAFE_componentWillUpdate'.
+   * @see https://eslint-react.xyz/docs/rules/no-component-will-update
    */
-  'react/no-deprecated'?: Linter.RuleEntry<[]>;
+  'react/x-no-component-will-update'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of setState in componentDidMount
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-did-mount-set-state.md
+   * Replaces usage of '<Context.Provider>' with '<Context>'.
+   * @see https://eslint-react.xyz/docs/rules/no-context-provider
    */
-  'react/no-did-mount-set-state'?: Linter.RuleEntry<ReactNoDidMountSetState>;
+  'react/x-no-context-provider'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of setState in componentDidUpdate
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-did-update-set-state.md
+   * Disallows 'createRef' in function components.
+   * @see https://eslint-react.xyz/docs/rules/no-create-ref
    */
-  'react/no-did-update-set-state'?: Linter.RuleEntry<ReactNoDidUpdateSetState>;
+  'react/x-no-create-ref'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow direct mutation of this.state
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-direct-mutation-state.md
+   * Disallows direct mutation of 'this.state'.
+   * @see https://eslint-react.xyz/docs/rules/no-direct-mutation-state
    */
-  'react/no-direct-mutation-state'?: Linter.RuleEntry<[]>;
+  'react/x-no-direct-mutation-state'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of findDOMNode
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-find-dom-node.md
+   * Prevents duplicate 'key' props on sibling elements when rendering lists.
+   * @see https://eslint-react.xyz/docs/rules/no-duplicate-key
    */
-  'react/no-find-dom-node'?: Linter.RuleEntry<[]>;
+  'react/x-no-duplicate-key'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of invalid attributes
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-invalid-html-attribute.md
+   * Replaces usage of 'forwardRef' with passing 'ref' as a prop.
+   * @see https://eslint-react.xyz/docs/rules/no-forward-ref
    */
-  'react/no-invalid-html-attribute'?: Linter.RuleEntry<ReactNoInvalidHtmlAttribute>;
+  'react/x-no-forward-ref'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of isMounted
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-is-mounted.md
+   * Prevents implicitly passing the 'children' prop to components.
+   * @see https://eslint-react.xyz/docs/rules/no-implicit-children
    */
-  'react/no-is-mounted'?: Linter.RuleEntry<[]>;
+  'react/x-no-implicit-children'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow multiple component definition per file
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-multi-comp.md
+   * Prevents implicitly passing the 'key' prop to components.
+   * @see https://eslint-react.xyz/docs/rules/no-implicit-key
    */
-  'react/no-multi-comp'?: Linter.RuleEntry<ReactNoMultiComp>;
+  'react/x-no-implicit-key'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce that namespaces are not used in React elements
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-namespace.md
+   * Prevents implicitly passing the 'ref' prop to components.
+   * @see https://eslint-react.xyz/docs/rules/no-implicit-ref
    */
-  'react/no-namespace'?: Linter.RuleEntry<[]>;
+  'react/x-no-implicit-ref'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of referential-type variables as default param in functional component
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-object-type-as-default-prop.md
+   * Prevents problematic leaked values from being rendered.
+   * @see https://eslint-react.xyz/docs/rules/no-leaked-conditional-rendering
    */
-  'react/no-object-type-as-default-prop'?: Linter.RuleEntry<[]>;
+  'react/x-no-leaked-conditional-rendering'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of shouldComponentUpdate when extending React.PureComponent
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-redundant-should-component-update.md
+   * Enforces that all components have a 'displayName' that can be used in DevTools.
+   * @see https://eslint-react.xyz/docs/rules/no-missing-component-display-name
    */
-  'react/no-redundant-should-component-update'?: Linter.RuleEntry<[]>;
+  'react/x-no-missing-component-display-name'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of the return value of ReactDOM.render
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-render-return-value.md
+   * Enforces that all contexts have a 'displayName' that can be used in DevTools.
+   * @see https://eslint-react.xyz/docs/rules/no-missing-context-display-name
    */
-  'react/no-render-return-value'?: Linter.RuleEntry<[]>;
+  'react/x-no-missing-context-display-name'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of setState
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-set-state.md
+   * Disallows missing 'key' on items in list rendering.
+   * @see https://eslint-react.xyz/docs/rules/no-missing-key
    */
-  'react/no-set-state'?: Linter.RuleEntry<[]>;
+  'react/x-no-missing-key'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow using string references
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-string-refs.md
+   * Prevents incorrect usage of 'captureOwnerStack'.
+   * @see https://eslint-react.xyz/docs/rules/no-misused-capture-owner-stack
    */
-  'react/no-string-refs'?: Linter.RuleEntry<ReactNoStringRefs>;
+  'react/x-no-misused-capture-owner-stack'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow `this` from being used in stateless functional components
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-this-in-sfc.md
+   * Disallows nesting component definitions inside other components.
+   * @see https://eslint-react.xyz/docs/rules/no-nested-component-definitions
    */
-  'react/no-this-in-sfc'?: Linter.RuleEntry<[]>;
+  'react/x-no-nested-component-definitions'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow common typos
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-typos.md
+   * Disallows nesting lazy component declarations inside other components or hooks.
+   * @see https://eslint-react.xyz/docs/rules/no-nested-lazy-component-declarations
    */
-  'react/no-typos'?: Linter.RuleEntry<[]>;
+  'react/x-no-nested-lazy-component-declarations'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow unescaped HTML entities from appearing in markup
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unescaped-entities.md
+   * Disallows 'shouldComponentUpdate' when extending 'React.PureComponent'.
+   * @see https://eslint-react.xyz/docs/rules/no-redundant-should-component-update
    */
-  'react/no-unescaped-entities'?: Linter.RuleEntry<ReactNoUnescapedEntities>;
+  'react/x-no-redundant-should-component-update'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of unknown DOM property
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unknown-property.md
+   * Disallows calling 'this.setState' in 'componentDidMount' outside functions such as callbacks.
+   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-did-mount
    */
-  'react/no-unknown-property'?: Linter.RuleEntry<ReactNoUnknownProperty>;
+  'react/x-no-set-state-in-component-did-mount'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of unsafe lifecycle methods
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unsafe.md
+   * Disallows calling 'this.setState' in 'componentDidUpdate' outside functions such as callbacks.
+   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-did-update
    */
-  'react/no-unsafe'?: Linter.RuleEntry<ReactNoUnsafe>;
+  'react/x-no-set-state-in-component-did-update'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow creating unstable components inside components
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unstable-nested-components.md
+   * Disallows calling 'this.setState' in 'componentWillUpdate' outside functions such as callbacks.
+   * @see https://eslint-react.xyz/docs/rules/no-set-state-in-component-will-update
    */
-  'react/no-unstable-nested-components'?: Linter.RuleEntry<ReactNoUnstableNestedComponents>;
+  'react/x-no-set-state-in-component-will-update'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow declaring unused methods of component class
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unused-class-component-methods.md
+   * Disallows unnecessary usage of 'useCallback'.
+   * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-callback
    */
-  'react/no-unused-class-component-methods'?: Linter.RuleEntry<[]>;
+  'react/x-no-unnecessary-use-callback'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow definitions of unused propTypes
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unused-prop-types.md
+   * Disallows unnecessary usage of 'useMemo'.
+   * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-memo
    */
-  'react/no-unused-prop-types'?: Linter.RuleEntry<ReactNoUnusedPropTypes>;
+  'react/x-no-unnecessary-use-memo'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow definitions of unused state
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unused-state.md
+   * Enforces that a function with the 'use' prefix uses at least one Hook inside it.
+   * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-prefix
    */
-  'react/no-unused-state'?: Linter.RuleEntry<[]>;
+  'react/x-no-unnecessary-use-prefix'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow usage of setState in componentWillUpdate
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-will-update-set-state.md
+   * Warns about the use of 'UNSAFE_componentWillMount' in class components.
+   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-mount
    */
-  'react/no-will-update-set-state'?: Linter.RuleEntry<ReactNoWillUpdateSetState>;
+  'react/x-no-unsafe-component-will-mount'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce ES5 or ES6 class for React Components
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-es6-class.md
+   * Warns about the use of 'UNSAFE_componentWillReceiveProps' in class components.
+   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-receive-props
    */
-  'react/prefer-es6-class'?: Linter.RuleEntry<ReactPreferEs6Class>;
+  'react/x-no-unsafe-component-will-receive-props'?: Linter.RuleEntry<[]>;
   /**
-   * Prefer exact proptype definitions
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-exact-props.md
+   * Warns about the use of 'UNSAFE_componentWillUpdate' in class components.
+   * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-update
    */
-  'react/prefer-exact-props'?: Linter.RuleEntry<[]>;
+  'react/x-no-unsafe-component-will-update'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce that props are read-only
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-read-only-props.md
+   * 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
    */
-  'react/prefer-read-only-props'?: Linter.RuleEntry<[]>;
+  'react/x-no-unstable-context-value'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce stateless components to be written as a pure function
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-stateless-function.md
+   * Prevents using referential-type values as default props in object destructuring.
+   * @see https://eslint-react.xyz/docs/rules/no-unstable-default-props
    */
-  'react/prefer-stateless-function'?: Linter.RuleEntry<ReactPreferStatelessFunction>;
+  'react/x-no-unstable-default-props'?: Linter.RuleEntry<ReactXNoUnstableDefaultProps>;
   /**
-   * Disallow missing props validation in a React component definition
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prop-types.md
+   * Warns about unused class component methods and properties.
+   * @see https://eslint-react.xyz/docs/rules/no-unused-class-component-members
    */
-  'react/prop-types'?: Linter.RuleEntry<ReactPropTypes>;
+  'react/x-no-unused-class-component-members'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow missing React when using JSX
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/react-in-jsx-scope.md
+   * Warns about component props that are defined but never used.
+   * @see https://eslint-react.xyz/docs/rules/no-unused-props
    */
-  'react/react-in-jsx-scope'?: Linter.RuleEntry<[]>;
+  'react/x-no-unused-props'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce a defaultProps definition for every prop that is not a required prop
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/require-default-props.md
+   * Warns about unused class component state.
+   * @see https://eslint-react.xyz/docs/rules/no-unused-state
    */
-  'react/require-default-props'?: Linter.RuleEntry<ReactRequireDefaultProps>;
+  'react/x-no-unused-state'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce React components to have a shouldComponentUpdate method
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/require-optimization.md
+   * Replaces usage of 'useContext' with 'use'.
+   * @see https://eslint-react.xyz/docs/rules/no-use-context
    */
-  'react/require-optimization'?: Linter.RuleEntry<ReactRequireOptimization>;
+  'react/x-no-use-context'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce ES5 or ES6 class for returning value in render function
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/require-render-return.md
+   * Enforces destructuring assignment for component props and context.
+   * @see https://eslint-react.xyz/docs/rules/prefer-destructuring-assignment
    */
-  'react/require-render-return'?: Linter.RuleEntry<[]>;
+  'react/x-prefer-destructuring-assignment'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow extra closing tags for components without children
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/self-closing-comp.md
+   * Enforces importing React via a namespace import.
+   * @see https://eslint-react.xyz/docs/rules/prefer-namespace-import
    */
-  'react/self-closing-comp'?: Linter.RuleEntry<ReactSelfClosingComp>;
+  'react/x-prefer-namespace-import'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce component methods order
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-comp.md
+   * Validates that components and hooks are pure by checking that they do not call known-impure functions during render.
+   * @see https://eslint-react.xyz/docs/rules/purity
    */
-  'react/sort-comp'?: Linter.RuleEntry<ReactSortComp>;
+  'react/x-purity'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce defaultProps declarations alphabetical sorting
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-default-props.md
+   * Validates correct usage of refs by checking that 'ref.current' is not read or written during render.
+   * @see https://eslint-react.xyz/docs/rules/refs
    */
-  'react/sort-default-props'?: Linter.RuleEntry<ReactSortDefaultProps>;
+  'react/x-refs'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce propTypes declarations alphabetical sorting
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-prop-types.md
+   * Enforces the Rules of Hooks.
+   * @see https://react.dev/reference/rules/rules-of-hooks
+   */
+  'react/x-rules-of-hooks'?: Linter.RuleEntry<ReactXRulesOfHooks>;
+  /**
+   * Validates against setting state synchronously in an effect, which can lead to re-renders that degrade performance.
+   * @see https://eslint-react.xyz/docs/rules/set-state-in-effect
    */
-  'react/sort-prop-types'?: Linter.RuleEntry<ReactSortPropTypes>;
+  'react/x-set-state-in-effect'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce class component state initialization style
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/state-in-constructor.md
+   * Validates against unconditionally setting state during render, which can trigger additional renders and potential infinite render loops.
+   * @see https://eslint-react.xyz/docs/rules/set-state-in-render
    */
-  'react/state-in-constructor'?: Linter.RuleEntry<ReactStateInConstructor>;
+  'react/x-set-state-in-render'?: Linter.RuleEntry<[]>;
   /**
-   * Enforces where React component static properties should be positioned.
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/static-property-placement.md
+   * Validates against syntax that React Compiler does not support.
+   * @see https://eslint-react.xyz/docs/rules/unsupported-syntax
    */
-  'react/static-property-placement'?: Linter.RuleEntry<ReactStaticPropertyPlacement>;
+  'react/x-unsupported-syntax'?: Linter.RuleEntry<[]>;
   /**
-   * Enforce style prop value is an object
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/style-prop-object.md
+   * Validates that 'useMemo' is called with a callback that returns a value.
+   * @see https://eslint-react.xyz/docs/rules/use-memo
    */
-  'react/style-prop-object'?: Linter.RuleEntry<ReactStylePropObject>;
+  'react/x-use-memo'?: Linter.RuleEntry<[]>;
   /**
-   * Disallow void DOM elements (e.g. `<img />`, `<br />`) from receiving children
-   * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/void-dom-elements-no-children.md
+   * Enforces correct usage of 'useState', including destructuring, symmetric naming of the value and setter, and wrapping expensive initializers in a lazy initializer function.
+   * @see https://eslint-react.xyz/docs/rules/use-state
    */
-  'react/void-dom-elements-no-children'?: Linter.RuleEntry<[]>;
+  'react/x-use-state'?: Linter.RuleEntry<ReactXUseState>;
   /**
    * disallow confusing quantifiers
    * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/confusing-quantifier.html
@@ -10444,6 +10544,7 @@ type PerfectionistSortClasses = {
     matchesAstSelector?: string;
   };
   useExperimentalDependencyDetection?: boolean;
+  newlinesBetweenOverloadSignatures?: ("ignore" | number);
   ignoreCallbackDependenciesPatterns?: (({
     pattern: string;
     flags?: string;
@@ -11807,6 +11908,7 @@ type PerfectionistSortModules = [] | [{
   })[];
   newlinesBetween?: ("ignore" | number);
   useExperimentalDependencyDetection?: boolean;
+  newlinesBetweenOverloadSignatures?: ("ignore" | number);
   partitionByComment?: (boolean | (({
     pattern: string;
     flags?: string;
@@ -12806,492 +12908,54 @@ type Quotes = [] | [("single" | "double" | "backtick")] | [("single" | "double"
   avoidEscape?: boolean;
   allowTemplateLiterals?: boolean;
 })]; // ----- radix -----
-type Radix = [] | [("always" | "as-needed")]; // ----- react-hooks/automatic-effect-dependencies -----
-type ReactHooksAutomaticEffectDependencies = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/capitalized-calls -----
-type ReactHooksCapitalizedCalls = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/component-hook-factories -----
-type ReactHooksComponentHookFactories = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/config -----
-type ReactHooksConfig = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/error-boundaries -----
-type ReactHooksErrorBoundaries = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/exhaustive-deps -----
-type ReactHooksExhaustiveDeps = [] | [{
-  additionalHooks?: string;
-  enableDangerousAutofixThisMayCauseInfiniteLoops?: boolean;
-  experimental_autoDependenciesHooks?: string[];
-  requireExplicitEffectDeps?: boolean;
-}]; // ----- react-hooks/fbt -----
-type ReactHooksFbt = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/fire -----
-type ReactHooksFire = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/gating -----
-type ReactHooksGating = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/globals -----
-type ReactHooksGlobals = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/hooks -----
-type ReactHooksHooks = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/immutability -----
-type ReactHooksImmutability = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/incompatible-library -----
-type ReactHooksIncompatibleLibrary = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/invariant -----
-type ReactHooksInvariant = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/memoized-effect-dependencies -----
-type ReactHooksMemoizedEffectDependencies = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/no-deriving-state-in-effects -----
-type ReactHooksNoDerivingStateInEffects = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/preserve-manual-memoization -----
-type ReactHooksPreserveManualMemoization = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/purity -----
-type ReactHooksPurity = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/refs -----
-type ReactHooksRefs = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/rule-suppression -----
-type ReactHooksRuleSuppression = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/rules-of-hooks -----
-type ReactHooksRulesOfHooks = [] | [{
-  additionalHooks?: string;
-}]; // ----- react-hooks/set-state-in-effect -----
-type ReactHooksSetStateInEffect = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/set-state-in-render -----
-type ReactHooksSetStateInRender = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/static-components -----
-type ReactHooksStaticComponents = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/syntax -----
-type ReactHooksSyntax = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/todo -----
-type ReactHooksTodo = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/unsupported-syntax -----
-type ReactHooksUnsupportedSyntax = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/use-memo -----
-type ReactHooksUseMemo = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-hooks/void-use-memo -----
-type ReactHooksVoidUseMemo = [] | [{
-  [k: string]: unknown | undefined;
-}]; // ----- react-refresh/only-export-components -----
+type Radix = [] | [("always" | "as-needed")]; // ----- react-refresh/only-export-components -----
 type ReactRefreshOnlyExportComponents = [] | [{
   extraHOCs?: string[];
   allowExportNames?: string[];
   allowConstantExport?: boolean;
   checkJS?: boolean;
-}]; // ----- react/boolean-prop-naming -----
-type ReactBooleanPropNaming = [] | [{
-  propTypeNames?: [string, ...(string)[]];
-  rule?: string;
-  message?: string;
-  validateNested?: boolean;
-}]; // ----- react/button-has-type -----
-type ReactButtonHasType = [] | [{
-  button?: boolean;
-  submit?: boolean;
-  reset?: boolean;
-}]; // ----- react/checked-requires-onchange-or-readonly -----
-type ReactCheckedRequiresOnchangeOrReadonly = [] | [{
-  ignoreMissingProperties?: boolean;
-  ignoreExclusiveCheckedAttribute?: boolean;
-}]; // ----- react/default-props-match-prop-types -----
-type ReactDefaultPropsMatchPropTypes = [] | [{
-  allowRequiredDefaults?: boolean;
-}]; // ----- react/destructuring-assignment -----
-type ReactDestructuringAssignment = [] | [("always" | "never")] | [("always" | "never"), {
-  ignoreClassFields?: boolean;
-  destructureInSignature?: ("always" | "ignore");
-}]; // ----- react/display-name -----
-type ReactDisplayName = [] | [{
-  ignoreTranspilerName?: boolean;
-  checkContextObjects?: boolean;
-}]; // ----- react/forbid-component-props -----
-type ReactForbidComponentProps = [] | [{
-  forbid?: (string | {
-    propName?: string;
-    allowedFor?: string[];
-    allowedForPatterns?: string[];
-    message?: string;
-  } | ({
-    [k: string]: unknown | undefined;
-  } | {
-    [k: string]: unknown | undefined;
-  }) | {
-    propNamePattern?: string;
-    allowedFor?: string[];
-    allowedForPatterns?: string[];
-    message?: string;
-  } | ({
-    [k: string]: unknown | undefined;
-  } | {
-    [k: string]: unknown | undefined;
-  }))[];
-  [k: string]: unknown | undefined;
-}]; // ----- react/forbid-dom-props -----
-type ReactForbidDomProps = [] | [{
-  forbid?: (string | {
-    propName?: string;
-    disallowedFor?: string[];
-    message?: string;
-    [k: string]: unknown | undefined;
-  })[];
-}]; // ----- react/forbid-elements -----
-type ReactForbidElements = [] | [{
-  forbid?: (string | {
-    element: string;
-    message?: string;
-  })[];
-}]; // ----- react/forbid-foreign-prop-types -----
-type ReactForbidForeignPropTypes = [] | [{
-  allowInPropTypes?: boolean;
-}]; // ----- react/forbid-prop-types -----
-type ReactForbidPropTypes = [] | [{
-  forbid?: string[];
-  checkContextTypes?: boolean;
-  checkChildContextTypes?: boolean;
-  [k: string]: unknown | undefined;
-}]; // ----- react/function-component-definition -----
-type ReactFunctionComponentDefinition = [] | [{
-  namedComponents?: (("function-declaration" | "arrow-function" | "function-expression") | ("function-declaration" | "arrow-function" | "function-expression")[]);
-  unnamedComponents?: (("arrow-function" | "function-expression") | ("arrow-function" | "function-expression")[]);
-  [k: string]: unknown | undefined;
-}]; // ----- react/hook-use-state -----
-type ReactHookUseState = [] | [{
-  allowDestructuredState?: boolean;
-}]; // ----- react/jsx-boolean-value -----
-type ReactJsxBooleanValue = ([] | [("always" | "never")] | [] | ["always"] | ["always", {
-  never?: string[];
-  assumeUndefinedIsFalse?: boolean;
-}] | [] | ["never"] | ["never", {
-  always?: string[];
-  assumeUndefinedIsFalse?: boolean;
-}]); // ----- react/jsx-closing-bracket-location -----
-type ReactJsxClosingBracketLocation = [] | [(("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | {
-  location?: ("after-props" | "props-aligned" | "tag-aligned" | "line-aligned");
-} | {
-  nonEmpty?: ("after-props" | "props-aligned" | "tag-aligned" | "line-aligned" | false);
-  selfClosing?: ("after-props" | "props-aligned" | "tag-aligned" | "line-aligned" | false);
-})]; // ----- react/jsx-closing-tag-location -----
-type ReactJsxClosingTagLocation = [] | [(("tag-aligned" | "line-aligned") | {
-  location?: ("tag-aligned" | "line-aligned");
-})]; // ----- react/jsx-curly-brace-presence -----
-type ReactJsxCurlyBracePresence = [] | [({
-  props?: ("always" | "never" | "ignore");
-  children?: ("always" | "never" | "ignore");
-  propElementValues?: ("always" | "never" | "ignore");
-} | ("always" | "never" | "ignore"))]; // ----- react/jsx-curly-newline -----
-type ReactJsxCurlyNewline = [] | [(("consistent" | "never") | {
-  singleline?: ("consistent" | "require" | "forbid");
-  multiline?: ("consistent" | "require" | "forbid");
-})]; // ----- react/jsx-curly-spacing -----
-type ReactJsxCurlySpacing = [] | [((_ReactJsxCurlySpacing_BasicConfig & {
-  attributes?: _ReactJsxCurlySpacingBasicConfigOrBoolean;
-  children?: _ReactJsxCurlySpacingBasicConfigOrBoolean;
-  [k: string]: unknown | undefined;
-}) | ("always" | "never"))] | [((_ReactJsxCurlySpacing_BasicConfig & {
-  attributes?: _ReactJsxCurlySpacingBasicConfigOrBoolean;
-  children?: _ReactJsxCurlySpacingBasicConfigOrBoolean;
-  [k: string]: unknown | undefined;
-}) | ("always" | "never")), {
-  allowMultiline?: boolean;
-  spacing?: {
-    objectLiterals?: ("always" | "never");
-    [k: string]: unknown | undefined;
-  };
-}];
-type _ReactJsxCurlySpacingBasicConfigOrBoolean = (_ReactJsxCurlySpacing_BasicConfig | boolean);
-interface _ReactJsxCurlySpacing_BasicConfig {
-  when?: ("always" | "never");
-  allowMultiline?: boolean;
-  spacing?: {
-    objectLiterals?: ("always" | "never");
-    [k: string]: unknown | undefined;
-  };
-  [k: string]: unknown | undefined;
-} // ----- react/jsx-equals-spacing -----
-type ReactJsxEqualsSpacing = [] | [("always" | "never")]; // ----- react/jsx-filename-extension -----
-type ReactJsxFilenameExtension = [] | [{
-  allow?: ("always" | "as-needed");
-  extensions?: string[];
-  ignoreFilesWithoutCode?: boolean;
-}]; // ----- react/jsx-first-prop-new-line -----
-type ReactJsxFirstPropNewLine = [] | [("always" | "never" | "multiline" | "multiline-multiprop" | "multiprop")]; // ----- react/jsx-fragments -----
-type ReactJsxFragments = [] | [("syntax" | "element")]; // ----- react/jsx-handler-names -----
-type ReactJsxHandlerNames = [] | [({
-  eventHandlerPrefix?: string;
-  eventHandlerPropPrefix?: string;
-  checkLocalVariables?: boolean;
-  checkInlineFunction?: boolean;
-  ignoreComponentNames?: string[];
-} | {
-  eventHandlerPrefix?: string;
-  eventHandlerPropPrefix?: false;
-  checkLocalVariables?: boolean;
-  checkInlineFunction?: boolean;
-  ignoreComponentNames?: string[];
-} | {
-  eventHandlerPrefix?: false;
-  eventHandlerPropPrefix?: string;
-  checkLocalVariables?: boolean;
-  checkInlineFunction?: boolean;
-  ignoreComponentNames?: string[];
-} | {
-  checkLocalVariables?: boolean;
-} | {
-  checkInlineFunction?: boolean;
-} | {
-  ignoreComponentNames?: string[];
-  [k: string]: unknown | undefined;
-})]; // ----- react/jsx-indent -----
-type ReactJsxIndent = [] | [("tab" | number)] | [("tab" | number), {
-  checkAttributes?: boolean;
-  indentLogicalExpressions?: boolean;
-}]; // ----- react/jsx-indent-props -----
-type ReactJsxIndentProps = [] | [(("tab" | "first") | number | {
-  indentMode?: (("tab" | "first") | number);
-  ignoreTernaryOperator?: boolean;
-  [k: string]: unknown | undefined;
-})]; // ----- react/jsx-key -----
-type ReactJsxKey = [] | [{
-  checkFragmentShorthand?: boolean;
-  checkKeyMustBeforeSpread?: boolean;
-  warnOnDuplicates?: boolean;
-}]; // ----- react/jsx-max-depth -----
-type ReactJsxMaxDepth = [] | [{
-  max?: number;
-}]; // ----- react/jsx-max-props-per-line -----
-type ReactJsxMaxPropsPerLine = [] | [({
-  maximum?: {
-    single?: number;
-    multi?: number;
-    [k: string]: unknown | undefined;
-  };
-} | {
-  maximum?: number;
-  when?: ("always" | "multiline");
-})]; // ----- react/jsx-newline -----
-type ReactJsxNewline = [] | [{
-  prevent?: boolean;
-  allowMultilines?: boolean;
-}]; // ----- react/jsx-no-bind -----
-type ReactJsxNoBind = [] | [{
-  allowArrowFunctions?: boolean;
-  allowBind?: boolean;
-  allowFunctions?: boolean;
-  ignoreRefs?: boolean;
-  ignoreDOMComponents?: boolean;
-}]; // ----- react/jsx-no-duplicate-props -----
-type ReactJsxNoDuplicateProps = [] | [{
-  ignoreCase?: boolean;
-}]; // ----- react/jsx-no-leaked-render -----
-type ReactJsxNoLeakedRender = [] | [{
-  validStrategies?: ("ternary" | "coerce")[];
-}]; // ----- react/jsx-no-literals -----
-type ReactJsxNoLiterals = [] | [{
-  elementOverrides?: {
-    [k: string]: {
-      applyToNestedElements?: boolean;
-      noStrings?: boolean;
-      allowedStrings?: string[];
-      ignoreProps?: boolean;
-      noAttributeStrings?: boolean;
-      [k: string]: unknown | undefined;
-    };
-  };
-  noStrings?: boolean;
-  allowedStrings?: string[];
-  ignoreProps?: boolean;
-  noAttributeStrings?: boolean;
-}]; // ----- react/jsx-no-script-url -----
-type ReactJsxNoScriptUrl = ([] | [{
-  name: string;
-  props: string[];
-}[]] | [{
-  name: string;
-  props: string[];
-}[], {
-  includeFromSettings?: boolean;
-  [k: string]: unknown | undefined;
-}] | [] | [{
-  includeFromSettings?: boolean;
-  [k: string]: unknown | undefined;
-}]); // ----- react/jsx-no-target-blank -----
-type ReactJsxNoTargetBlank = [] | [{
-  allowReferrer?: boolean;
-  enforceDynamicLinks?: ("always" | "never");
-  warnOnSpreadAttributes?: boolean;
-  links?: boolean;
-  forms?: boolean;
-}]; // ----- react/jsx-no-undef -----
-type ReactJsxNoUndef = [] | [{
-  allowGlobals?: boolean;
+}]; // ----- react/dom-no-unknown-property -----
+type ReactDomNoUnknownProperty = [] | [{
+  ignore?: string[];
+  requireDataLowercase?: boolean;
+}]; // ----- react/exhaustive-deps -----
+type ReactExhaustiveDeps = [] | [{
+  additionalHooks?: string;
+  enableDangerousAutofixThisMayCauseInfiniteLoops?: boolean;
+  experimental_autoDependenciesHooks?: string[];
+  requireExplicitEffectDeps?: boolean;
 }]; // ----- react/jsx-no-useless-fragment -----
 type ReactJsxNoUselessFragment = [] | [{
+  allowEmptyFragment?: boolean;
   allowExpressions?: boolean;
-  [k: string]: unknown | undefined;
-}]; // ----- react/jsx-one-expression-per-line -----
-type ReactJsxOneExpressionPerLine = [] | [{
-  allow?: ("none" | "literal" | "single-child" | "non-jsx");
-}]; // ----- react/jsx-pascal-case -----
-type ReactJsxPascalCase = [] | [{
-  allowAllCaps?: boolean;
-  allowLeadingUnderscore?: boolean;
-  allowNamespace?: boolean;
-  ignore?: [] | [string];
-}]; // ----- react/jsx-props-no-spreading -----
-type ReactJsxPropsNoSpreading = [] | [({
-  html?: ("enforce" | "ignore");
-  custom?: ("enforce" | "ignore");
-  explicitSpread?: ("enforce" | "ignore");
-  exceptions?: string[];
-  [k: string]: unknown | undefined;
-} & {
-  [k: string]: unknown | undefined;
-})]; // ----- react/jsx-sort-default-props -----
-type ReactJsxSortDefaultProps = [] | [{
-  ignoreCase?: boolean;
-}]; // ----- react/jsx-sort-props -----
-type ReactJsxSortProps = [] | [{
-  callbacksLast?: boolean;
-  shorthandFirst?: boolean;
-  shorthandLast?: boolean;
-  multiline?: ("ignore" | "first" | "last");
-  ignoreCase?: boolean;
-  noSortAlphabetically?: boolean;
-  reservedFirst?: (unknown[] | boolean);
-  locale?: string;
-}]; // ----- react/jsx-space-before-closing -----
-type ReactJsxSpaceBeforeClosing = [] | [("always" | "never")]; // ----- react/jsx-tag-spacing -----
-type ReactJsxTagSpacing = [] | [{
-  closingSlash?: ("always" | "never" | "allow");
-  beforeSelfClosing?: ("always" | "proportional-always" | "never" | "allow");
-  afterOpening?: ("always" | "allow-multiline" | "never" | "allow");
-  beforeClosing?: ("always" | "proportional-always" | "never" | "allow");
-}]; // ----- react/jsx-wrap-multilines -----
-type ReactJsxWrapMultilines = [] | [{
-  declaration?: (true | false | "ignore" | "parens" | "parens-new-line" | "never");
-  assignment?: (true | false | "ignore" | "parens" | "parens-new-line" | "never");
-  return?: (true | false | "ignore" | "parens" | "parens-new-line" | "never");
-  arrow?: (true | false | "ignore" | "parens" | "parens-new-line" | "never");
-  condition?: (true | false | "ignore" | "parens" | "parens-new-line" | "never");
-  logical?: (true | false | "ignore" | "parens" | "parens-new-line" | "never");
-  prop?: (true | false | "ignore" | "parens" | "parens-new-line" | "never");
-}]; // ----- react/no-children-prop -----
-type ReactNoChildrenProp = [] | [{
-  allowFunctions?: boolean;
-}]; // ----- react/no-danger -----
-type ReactNoDanger = [] | [{
-  customComponentNames?: string[];
-  [k: string]: unknown | undefined;
-}]; // ----- react/no-did-mount-set-state -----
-type ReactNoDidMountSetState = [] | ["disallow-in-func"]; // ----- react/no-did-update-set-state -----
-type ReactNoDidUpdateSetState = [] | ["disallow-in-func"]; // ----- react/no-invalid-html-attribute -----
-type ReactNoInvalidHtmlAttribute = [] | [("rel")[]]; // ----- react/no-multi-comp -----
-type ReactNoMultiComp = [] | [{
-  ignoreStateless?: boolean;
-}]; // ----- react/no-string-refs -----
-type ReactNoStringRefs = [] | [{
-  noTemplateLiterals?: boolean;
-}]; // ----- react/no-unescaped-entities -----
-type ReactNoUnescapedEntities = [] | [{
-  forbid?: (string | {
-    char?: string;
-    alternatives?: string[];
-    [k: string]: unknown | undefined;
-  })[];
-}]; // ----- react/no-unknown-property -----
-type ReactNoUnknownProperty = [] | [{
-  ignore?: string[];
-  requireDataLowercase?: boolean;
-}]; // ----- react/no-unsafe -----
-type ReactNoUnsafe = [] | [{
-  checkAliases?: boolean;
-}]; // ----- react/no-unstable-nested-components -----
-type ReactNoUnstableNestedComponents = [] | [{
-  customValidators?: string[];
-  allowAsProps?: boolean;
-  propNamePattern?: string;
-}]; // ----- react/no-unused-prop-types -----
-type ReactNoUnusedPropTypes = [] | [{
-  ignore?: string[];
-  customValidators?: string[];
-  skipShapeProps?: boolean;
-}]; // ----- react/no-will-update-set-state -----
-type ReactNoWillUpdateSetState = [] | ["disallow-in-func"]; // ----- react/prefer-es6-class -----
-type ReactPreferEs6Class = [] | [("always" | "never")]; // ----- react/prefer-stateless-function -----
-type ReactPreferStatelessFunction = [] | [{
-  ignorePureComponents?: boolean;
-}]; // ----- react/prop-types -----
-type ReactPropTypes = [] | [{
-  ignore?: string[];
-  customValidators?: string[];
-  skipUndeclared?: boolean;
-}]; // ----- react/require-default-props -----
-type ReactRequireDefaultProps = [] | [{
-  forbidDefaultForRequired?: boolean;
-  classes?: ("defaultProps" | "ignore");
-  functions?: ("defaultArguments" | "defaultProps" | "ignore");
-  ignoreFunctionalComponents?: boolean;
-}]; // ----- react/require-optimization -----
-type ReactRequireOptimization = [] | [{
-  allowDecorators?: string[];
-}]; // ----- react/self-closing-comp -----
-type ReactSelfClosingComp = [] | [{
-  component?: boolean;
-  html?: boolean;
-}]; // ----- react/sort-comp -----
-type ReactSortComp = [] | [{
-  order?: string[];
-  groups?: {
-    [k: string]: string[];
-  };
-}]; // ----- react/sort-default-props -----
-type ReactSortDefaultProps = [] | [{
-  ignoreCase?: boolean;
-}]; // ----- react/sort-prop-types -----
-type ReactSortPropTypes = [] | [{
-  requiredFirst?: boolean;
-  callbacksLast?: boolean;
-  ignoreCase?: boolean;
-  noSortAlphabetically?: boolean;
-  sortShapeProp?: boolean;
-  checkTypes?: boolean;
-}]; // ----- react/state-in-constructor -----
-type ReactStateInConstructor = [] | [("always" | "never")]; // ----- react/static-property-placement -----
-type ReactStaticPropertyPlacement = [] | [("static public field" | "static getter" | "property assignment")] | [("static public field" | "static getter" | "property assignment"), {
-  propTypes?: ("static public field" | "static getter" | "property assignment");
-  defaultProps?: ("static public field" | "static getter" | "property assignment");
-  childContextTypes?: ("static public field" | "static getter" | "property assignment");
-  contextTypes?: ("static public field" | "static getter" | "property assignment");
-  contextType?: ("static public field" | "static getter" | "property assignment");
-  displayName?: ("static public field" | "static getter" | "property assignment");
-}]; // ----- react/style-prop-object -----
-type ReactStylePropObject = [] | [{
-  allow?: string[];
-  [k: string]: unknown | undefined;
+}]; // ----- react/no-unstable-default-props -----
+type ReactNoUnstableDefaultProps = [] | [{
+  safeDefaultProps?: string[];
+}]; // ----- react/rules-of-hooks -----
+type ReactRulesOfHooks = [] | [{
+  additionalHooks?: string;
+}]; // ----- react/use-state -----
+type ReactUseState = [] | [{
+  enforceAssignment?: boolean;
+  enforceLazyInitialization?: boolean;
+  enforceSetterName?: boolean;
+}]; // ----- react/x-exhaustive-deps -----
+type ReactXExhaustiveDeps = [] | [{
+  additionalHooks?: string;
+  enableDangerousAutofixThisMayCauseInfiniteLoops?: boolean;
+  experimental_autoDependenciesHooks?: string[];
+  requireExplicitEffectDeps?: boolean;
+}]; // ----- react/x-no-unstable-default-props -----
+type ReactXNoUnstableDefaultProps = [] | [{
+  safeDefaultProps?: string[];
+}]; // ----- react/x-rules-of-hooks -----
+type ReactXRulesOfHooks = [] | [{
+  additionalHooks?: string;
+}]; // ----- react/x-use-state -----
+type ReactXUseState = [] | [{
+  enforceAssignment?: boolean;
+  enforceLazyInitialization?: boolean;
+  enforceSetterName?: boolean;
 }]; // ----- regexp/hexadecimal-escape -----
 type RegexpHexadecimalEscape = [] | [("always" | "never")]; // ----- regexp/letter-case -----
 type RegexpLetterCase = [] | [{
@@ -16997,7 +16661,7 @@ declare function prettier(options?: PrettierOptions): Promise<FlatConfigItem[]>;
 declare function promise(): Promise<FlatConfigItem[]>;
 //#endregion
 //#region src/configs/react.d.ts
-declare function react(options?: OptionsHasTypeScript & OptionsOverrides & OptionsFiles & OptionsHasTanStackReactQuery): Promise<FlatConfigItem[]>;
+declare function react(options?: OptionsOverrides & OptionsFiles & OptionsHasTanStackReactQuery): Promise<FlatConfigItem[]>;
 //#endregion
 //#region src/configs/regexp.d.ts
 declare function regexp(options?: OptionsOverrides): FlatConfigItem[];