@kazupon/eslint-config 0.12.0 → 0.13.0

package/dist/types/gens/react.d.cts

@@ -0,0 +1,1053 @@
+import type { Linter } from 'eslint';
+export interface ReactRules {
+    /**
+     * 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>;
+    /**
+     * enforces the Rules of Hooks
+     * @see https://reactjs.org/docs/hooks-rules.html
+     */
+    'react-hooks/rules-of-hooks'?: Linter.RuleEntry<[]>;
+    'react-refresh/only-export-components'?: Linter.RuleEntry<ReactRefreshOnlyExportComponents>;
+    /**
+     * Enforces consistent naming for boolean props
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/boolean-prop-naming.md
+     */
+    'react/boolean-prop-naming'?: Linter.RuleEntry<ReactBooleanPropNaming>;
+    /**
+     * 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
+     */
+    'react/button-has-type'?: Linter.RuleEntry<ReactButtonHasType>;
+    /**
+     * 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
+     */
+    'react/checked-requires-onchange-or-readonly'?: Linter.RuleEntry<ReactCheckedRequiresOnchangeOrReadonly>;
+    /**
+     * 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
+     */
+    'react/default-props-match-prop-types'?: Linter.RuleEntry<ReactDefaultPropsMatchPropTypes>;
+    /**
+     * 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
+     */
+    'react/destructuring-assignment'?: Linter.RuleEntry<ReactDestructuringAssignment>;
+    /**
+     * Disallow missing displayName in a React component definition
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/display-name.md
+     */
+    'react/display-name'?: Linter.RuleEntry<ReactDisplayName>;
+    /**
+     * Disallow certain props on components
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-component-props.md
+     */
+    'react/forbid-component-props'?: Linter.RuleEntry<ReactForbidComponentProps>;
+    /**
+     * Disallow certain props on DOM Nodes
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-dom-props.md
+     */
+    'react/forbid-dom-props'?: Linter.RuleEntry<ReactForbidDomProps>;
+    /**
+     * Disallow certain elements
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-elements.md
+     */
+    'react/forbid-elements'?: Linter.RuleEntry<ReactForbidElements>;
+    /**
+     * Disallow using another component's propTypes
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-foreign-prop-types.md
+     */
+    'react/forbid-foreign-prop-types'?: Linter.RuleEntry<ReactForbidForeignPropTypes>;
+    /**
+     * Disallow certain propTypes
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/forbid-prop-types.md
+     */
+    'react/forbid-prop-types'?: Linter.RuleEntry<ReactForbidPropTypes>;
+    /**
+     * 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
+     */
+    'react/function-component-definition'?: Linter.RuleEntry<ReactFunctionComponentDefinition>;
+    /**
+     * 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
+     */
+    'react/hook-use-state'?: Linter.RuleEntry<ReactHookUseState>;
+    /**
+     * Enforce sandbox attribute on iframe elements
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/iframe-missing-sandbox.md
+     */
+    'react/iframe-missing-sandbox'?: 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
+     */
+    'react/jsx-boolean-value'?: Linter.RuleEntry<ReactJsxBooleanValue>;
+    /**
+     * 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
+     */
+    'react/jsx-child-element-spacing'?: 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
+     */
+    'react/jsx-closing-bracket-location'?: Linter.RuleEntry<ReactJsxClosingBracketLocation>;
+    /**
+     * 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
+     */
+    'react/jsx-closing-tag-location'?: Linter.RuleEntry<ReactJsxClosingTagLocation>;
+    /**
+     * 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
+     */
+    'react/jsx-curly-brace-presence'?: Linter.RuleEntry<ReactJsxCurlyBracePresence>;
+    /**
+     * 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
+     */
+    'react/jsx-curly-newline'?: Linter.RuleEntry<ReactJsxCurlyNewline>;
+    /**
+     * 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
+     */
+    'react/jsx-curly-spacing'?: Linter.RuleEntry<ReactJsxCurlySpacing>;
+    /**
+     * 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
+     */
+    'react/jsx-equals-spacing'?: Linter.RuleEntry<ReactJsxEqualsSpacing>;
+    /**
+     * Disallow file extensions that may contain JSX
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-filename-extension.md
+     */
+    'react/jsx-filename-extension'?: Linter.RuleEntry<ReactJsxFilenameExtension>;
+    /**
+     * 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
+     */
+    'react/jsx-first-prop-new-line'?: Linter.RuleEntry<ReactJsxFirstPropNewLine>;
+    /**
+     * Enforce shorthand or standard form for React fragments
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-fragments.md
+     */
+    'react/jsx-fragments'?: Linter.RuleEntry<ReactJsxFragments>;
+    /**
+     * Enforce event handler naming conventions in JSX
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-handler-names.md
+     */
+    'react/jsx-handler-names'?: Linter.RuleEntry<ReactJsxHandlerNames>;
+    /**
+     * Enforce JSX indentation
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-indent.md
+     */
+    'react/jsx-indent'?: Linter.RuleEntry<ReactJsxIndent>;
+    /**
+     * Enforce props indentation in JSX
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-indent-props.md
+     */
+    'react/jsx-indent-props'?: Linter.RuleEntry<ReactJsxIndentProps>;
+    /**
+     * Disallow missing `key` props in iterators/collection literals
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-key.md
+     */
+    'react/jsx-key'?: Linter.RuleEntry<ReactJsxKey>;
+    /**
+     * Enforce JSX maximum depth
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-max-depth.md
+     */
+    'react/jsx-max-depth'?: Linter.RuleEntry<ReactJsxMaxDepth>;
+    /**
+     * 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
+     */
+    'react/jsx-max-props-per-line'?: Linter.RuleEntry<ReactJsxMaxPropsPerLine>;
+    /**
+     * 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
+     */
+    'react/jsx-newline'?: Linter.RuleEntry<ReactJsxNewline>;
+    /**
+     * 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
+     */
+    'react/jsx-no-bind'?: Linter.RuleEntry<ReactJsxNoBind>;
+    /**
+     * 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
+     */
+    'react/jsx-no-comment-textnodes'?: 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
+     */
+    'react/jsx-no-constructed-context-values'?: 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
+     */
+    'react/jsx-no-duplicate-props'?: Linter.RuleEntry<ReactJsxNoDuplicateProps>;
+    /**
+     * 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
+     */
+    'react/jsx-no-leaked-render'?: Linter.RuleEntry<ReactJsxNoLeakedRender>;
+    /**
+     * Disallow usage of string literals in JSX
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-literals.md
+     */
+    'react/jsx-no-literals'?: Linter.RuleEntry<ReactJsxNoLiterals>;
+    /**
+     * Disallow usage of `javascript:` URLs
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-script-url.md
+     */
+    'react/jsx-no-script-url'?: Linter.RuleEntry<ReactJsxNoScriptUrl>;
+    /**
+     * 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
+     */
+    'react/jsx-no-target-blank'?: Linter.RuleEntry<ReactJsxNoTargetBlank>;
+    /**
+     * Disallow undeclared variables in JSX
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-undef.md
+     */
+    'react/jsx-no-undef'?: Linter.RuleEntry<ReactJsxNoUndef>;
+    /**
+     * Disallow unnecessary fragments
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-no-useless-fragment.md
+     */
+    'react/jsx-no-useless-fragment'?: Linter.RuleEntry<ReactJsxNoUselessFragment>;
+    /**
+     * 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
+     */
+    'react/jsx-one-expression-per-line'?: Linter.RuleEntry<ReactJsxOneExpressionPerLine>;
+    /**
+     * Enforce PascalCase for user-defined JSX components
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-pascal-case.md
+     */
+    'react/jsx-pascal-case'?: Linter.RuleEntry<ReactJsxPascalCase>;
+    /**
+     * 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
+     */
+    'react/jsx-props-no-multi-spaces'?: 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
+     */
+    'react/jsx-props-no-spread-multi'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow JSX prop spreading
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-props-no-spreading.md
+     */
+    'react/jsx-props-no-spreading'?: Linter.RuleEntry<ReactJsxPropsNoSpreading>;
+    /**
+     * Enforce defaultProps declarations alphabetical sorting
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-sort-default-props.md
+     * @deprecated
+     */
+    'react/jsx-sort-default-props'?: Linter.RuleEntry<ReactJsxSortDefaultProps>;
+    /**
+     * Enforce props alphabetical sorting
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/jsx-sort-props.md
+     */
+    'react/jsx-sort-props'?: Linter.RuleEntry<ReactJsxSortProps>;
+    /**
+     * 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
+     */
+    'react/jsx-space-before-closing'?: Linter.RuleEntry<ReactJsxSpaceBeforeClosing>;
+    /**
+     * 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
+     */
+    'react/jsx-tag-spacing'?: Linter.RuleEntry<ReactJsxTagSpacing>;
+    /**
+     * 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
+     */
+    'react/jsx-uses-react'?: 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
+     */
+    'react/jsx-uses-vars'?: 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
+     */
+    'react/jsx-wrap-multilines'?: Linter.RuleEntry<ReactJsxWrapMultilines>;
+    /**
+     * 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
+     */
+    'react/no-access-state-in-setstate'?: 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
+     */
+    'react/no-adjacent-inline-elements'?: 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
+     */
+    'react/no-array-index-key'?: 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
+     */
+    'react/no-arrow-function-lifecycle'?: 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
+     */
+    'react/no-children-prop'?: Linter.RuleEntry<ReactNoChildrenProp>;
+    /**
+     * Disallow usage of dangerous JSX properties
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-danger.md
+     */
+    'react/no-danger'?: Linter.RuleEntry<ReactNoDanger>;
+    /**
+     * 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
+     */
+    'react/no-danger-with-children'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow usage of deprecated methods
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-deprecated.md
+     */
+    'react/no-deprecated'?: 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
+     */
+    'react/no-did-mount-set-state'?: Linter.RuleEntry<ReactNoDidMountSetState>;
+    /**
+     * 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
+     */
+    'react/no-did-update-set-state'?: Linter.RuleEntry<ReactNoDidUpdateSetState>;
+    /**
+     * Disallow direct mutation of this.state
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-direct-mutation-state.md
+     */
+    'react/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
+     */
+    'react/no-find-dom-node'?: 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
+     */
+    'react/no-invalid-html-attribute'?: Linter.RuleEntry<ReactNoInvalidHtmlAttribute>;
+    /**
+     * Disallow usage of isMounted
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-is-mounted.md
+     */
+    'react/no-is-mounted'?: 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
+     */
+    'react/no-multi-comp'?: Linter.RuleEntry<ReactNoMultiComp>;
+    /**
+     * 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
+     */
+    'react/no-namespace'?: 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
+     */
+    'react/no-object-type-as-default-prop'?: 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
+     */
+    'react/no-redundant-should-component-update'?: 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
+     */
+    'react/no-render-return-value'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow usage of setState
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-set-state.md
+     */
+    'react/no-set-state'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow using string references
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-string-refs.md
+     */
+    'react/no-string-refs'?: Linter.RuleEntry<ReactNoStringRefs>;
+    /**
+     * 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
+     */
+    'react/no-this-in-sfc'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow common typos
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-typos.md
+     */
+    'react/no-typos'?: 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
+     */
+    'react/no-unescaped-entities'?: Linter.RuleEntry<ReactNoUnescapedEntities>;
+    /**
+     * Disallow usage of unknown DOM property
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unknown-property.md
+     */
+    'react/no-unknown-property'?: Linter.RuleEntry<ReactNoUnknownProperty>;
+    /**
+     * Disallow usage of unsafe lifecycle methods
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unsafe.md
+     */
+    'react/no-unsafe'?: Linter.RuleEntry<ReactNoUnsafe>;
+    /**
+     * Disallow creating unstable components inside components
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unstable-nested-components.md
+     */
+    'react/no-unstable-nested-components'?: Linter.RuleEntry<ReactNoUnstableNestedComponents>;
+    /**
+     * 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
+     */
+    'react/no-unused-class-component-methods'?: 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
+     */
+    'react/no-unused-prop-types'?: Linter.RuleEntry<ReactNoUnusedPropTypes>;
+    /**
+     * Disallow definitions of unused state
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/no-unused-state.md
+     */
+    'react/no-unused-state'?: 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
+     */
+    'react/no-will-update-set-state'?: Linter.RuleEntry<ReactNoWillUpdateSetState>;
+    /**
+     * 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
+     */
+    'react/prefer-es6-class'?: Linter.RuleEntry<ReactPreferEs6Class>;
+    /**
+     * Prefer exact proptype definitions
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/prefer-exact-props.md
+     */
+    'react/prefer-exact-props'?: 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
+     */
+    'react/prefer-read-only-props'?: 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
+     */
+    'react/prefer-stateless-function'?: Linter.RuleEntry<ReactPreferStatelessFunction>;
+    /**
+     * 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
+     */
+    'react/prop-types'?: Linter.RuleEntry<ReactPropTypes>;
+    /**
+     * Disallow missing React when using JSX
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/react-in-jsx-scope.md
+     */
+    'react/react-in-jsx-scope'?: 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
+     */
+    'react/require-default-props'?: Linter.RuleEntry<ReactRequireDefaultProps>;
+    /**
+     * Enforce React components to have a shouldComponentUpdate method
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/require-optimization.md
+     */
+    'react/require-optimization'?: Linter.RuleEntry<ReactRequireOptimization>;
+    /**
+     * 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
+     */
+    'react/require-render-return'?: 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
+     */
+    'react/self-closing-comp'?: Linter.RuleEntry<ReactSelfClosingComp>;
+    /**
+     * Enforce component methods order
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-comp.md
+     */
+    'react/sort-comp'?: Linter.RuleEntry<ReactSortComp>;
+    /**
+     * Enforce defaultProps declarations alphabetical sorting
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-default-props.md
+     */
+    'react/sort-default-props'?: Linter.RuleEntry<ReactSortDefaultProps>;
+    /**
+     * Enforce propTypes declarations alphabetical sorting
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/sort-prop-types.md
+     */
+    'react/sort-prop-types'?: Linter.RuleEntry<ReactSortPropTypes>;
+    /**
+     * Enforce class component state initialization style
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/state-in-constructor.md
+     */
+    'react/state-in-constructor'?: Linter.RuleEntry<ReactStateInConstructor>;
+    /**
+     * 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
+     */
+    'react/static-property-placement'?: Linter.RuleEntry<ReactStaticPropertyPlacement>;
+    /**
+     * Enforce style prop value is an object
+     * @see https://github.com/jsx-eslint/eslint-plugin-react/tree/master/docs/rules/style-prop-object.md
+     */
+    'react/style-prop-object'?: Linter.RuleEntry<ReactStylePropObject>;
+    /**
+     * 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
+     */
+    'react/void-dom-elements-no-children'?: Linter.RuleEntry<[]>;
+}
+type ReactHooksExhaustiveDeps = [] | [
+    {
+        additionalHooks?: string;
+        enableDangerousAutofixThisMayCauseInfiniteLoops?: boolean;
+    }
+];
+type ReactRefreshOnlyExportComponents = [] | [
+    {
+        allowConstantExport?: boolean;
+        checkJS?: boolean;
+        allowExportNames?: string[];
+    }
+];
+type ReactBooleanPropNaming = [] | [
+    {
+        propTypeNames?: [string, ...(string)[]];
+        rule?: string;
+        message?: string;
+        validateNested?: boolean;
+    }
+];
+type ReactButtonHasType = [] | [
+    {
+        button?: boolean;
+        submit?: boolean;
+        reset?: boolean;
+    }
+];
+type ReactCheckedRequiresOnchangeOrReadonly = [] | [
+    {
+        ignoreMissingProperties?: boolean;
+        ignoreExclusiveCheckedAttribute?: boolean;
+    }
+];
+type ReactDefaultPropsMatchPropTypes = [] | [
+    {
+        allowRequiredDefaults?: boolean;
+    }
+];
+type ReactDestructuringAssignment = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        ignoreClassFields?: boolean;
+        destructureInSignature?: ("always" | "ignore");
+    }
+];
+type ReactDisplayName = [] | [
+    {
+        ignoreTranspilerName?: boolean;
+        checkContextObjects?: boolean;
+    }
+];
+type ReactForbidComponentProps = [] | [
+    {
+        forbid?: (string | {
+            propName?: string;
+            allowedFor?: string[];
+            message?: string;
+        } | {
+            propName?: string;
+            disallowedFor: [string, ...(string)[]];
+            message?: string;
+        } | {
+            propNamePattern?: string;
+            allowedFor?: string[];
+            message?: string;
+        } | {
+            propNamePattern?: string;
+            disallowedFor: [string, ...(string)[]];
+            message?: string;
+        })[];
+        [k: string]: unknown | undefined;
+    }
+];
+type ReactForbidDomProps = [] | [
+    {
+        forbid?: (string | {
+            propName?: string;
+            disallowedFor?: string[];
+            message?: string;
+            [k: string]: unknown | undefined;
+        })[];
+    }
+];
+type ReactForbidElements = [] | [
+    {
+        forbid?: (string | {
+            element: string;
+            message?: string;
+        })[];
+    }
+];
+type ReactForbidForeignPropTypes = [] | [
+    {
+        allowInPropTypes?: boolean;
+    }
+];
+type ReactForbidPropTypes = [] | [
+    {
+        forbid?: string[];
+        checkContextTypes?: boolean;
+        checkChildContextTypes?: boolean;
+        [k: string]: unknown | undefined;
+    }
+];
+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;
+    }
+];
+type ReactHookUseState = [] | [
+    {
+        allowDestructuredState?: boolean;
+    }
+];
+type ReactJsxBooleanValue = ([] | [("always" | "never")] | [] | ["always"] | [
+    "always",
+    {
+        never?: string[];
+        assumeUndefinedIsFalse?: boolean;
+    }
+] | [] | ["never"] | [
+    "never",
+    {
+        always?: string[];
+        assumeUndefinedIsFalse?: boolean;
+    }
+]);
+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);
+    })
+];
+type ReactJsxClosingTagLocation = [] | [
+    (("tag-aligned" | "line-aligned") | {
+        location?: ("tag-aligned" | "line-aligned");
+    })
+];
+type ReactJsxCurlyBracePresence = [] | [
+    ({
+        props?: ("always" | "never" | "ignore");
+        children?: ("always" | "never" | "ignore");
+        propElementValues?: ("always" | "never" | "ignore");
+    } | ("always" | "never" | "ignore"))
+];
+type ReactJsxCurlyNewline = [] | [
+    (("consistent" | "never") | {
+        singleline?: ("consistent" | "require" | "forbid");
+        multiline?: ("consistent" | "require" | "forbid");
+    })
+];
+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;
+}
+type ReactJsxEqualsSpacing = [] | [("always" | "never")];
+type ReactJsxFilenameExtension = [] | [
+    {
+        allow?: ("always" | "as-needed");
+        extensions?: string[];
+        ignoreFilesWithoutCode?: boolean;
+    }
+];
+type ReactJsxFirstPropNewLine = [] | [("always" | "never" | "multiline" | "multiline-multiprop" | "multiprop")];
+type ReactJsxFragments = [] | [("syntax" | "element")];
+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;
+    })
+];
+type ReactJsxIndent = [] | [("tab" | number)] | [
+    ("tab" | number),
+    {
+        checkAttributes?: boolean;
+        indentLogicalExpressions?: boolean;
+    }
+];
+type ReactJsxIndentProps = [] | [
+    (("tab" | "first") | number | {
+        indentMode?: (("tab" | "first") | number);
+        ignoreTernaryOperator?: boolean;
+        [k: string]: unknown | undefined;
+    })
+];
+type ReactJsxKey = [] | [
+    {
+        checkFragmentShorthand?: boolean;
+        checkKeyMustBeforeSpread?: boolean;
+        warnOnDuplicates?: boolean;
+    }
+];
+type ReactJsxMaxDepth = [] | [
+    {
+        max?: number;
+    }
+];
+type ReactJsxMaxPropsPerLine = [] | [
+    ({
+        maximum?: {
+            single?: number;
+            multi?: number;
+            [k: string]: unknown | undefined;
+        };
+    } | {
+        maximum?: number;
+        when?: ("always" | "multiline");
+    })
+];
+type ReactJsxNewline = [] | [
+    {
+        prevent?: boolean;
+        allowMultilines?: boolean;
+    }
+];
+type ReactJsxNoBind = [] | [
+    {
+        allowArrowFunctions?: boolean;
+        allowBind?: boolean;
+        allowFunctions?: boolean;
+        ignoreRefs?: boolean;
+        ignoreDOMComponents?: boolean;
+    }
+];
+type ReactJsxNoDuplicateProps = [] | [
+    {
+        ignoreCase?: boolean;
+    }
+];
+type ReactJsxNoLeakedRender = [] | [
+    {
+        validStrategies?: ("ternary" | "coerce")[];
+    }
+];
+type ReactJsxNoLiterals = [] | [
+    {
+        noStrings?: boolean;
+        allowedStrings?: string[];
+        ignoreProps?: boolean;
+        noAttributeStrings?: boolean;
+    }
+];
+type ReactJsxNoScriptUrl = ([] | [
+    {
+        name: string;
+        props: string[];
+    }[]
+] | [
+    {
+        name: string;
+        props: string[];
+    }[],
+    {
+        includeFromSettings?: boolean;
+        [k: string]: unknown | undefined;
+    }
+] | [] | [
+    {
+        includeFromSettings?: boolean;
+        [k: string]: unknown | undefined;
+    }
+]);
+type ReactJsxNoTargetBlank = [] | [
+    {
+        allowReferrer?: boolean;
+        enforceDynamicLinks?: ("always" | "never");
+        warnOnSpreadAttributes?: boolean;
+        links?: boolean;
+        forms?: boolean;
+    }
+];
+type ReactJsxNoUndef = [] | [
+    {
+        allowGlobals?: boolean;
+    }
+];
+type ReactJsxNoUselessFragment = [] | [
+    {
+        allowExpressions?: boolean;
+        [k: string]: unknown | undefined;
+    }
+];
+type ReactJsxOneExpressionPerLine = [] | [
+    {
+        allow?: ("none" | "literal" | "single-child" | "non-jsx");
+    }
+];
+type ReactJsxPascalCase = [] | [
+    {
+        allowAllCaps?: boolean;
+        allowLeadingUnderscore?: boolean;
+        allowNamespace?: boolean;
+        ignore?: [] | [string];
+    }
+];
+type ReactJsxPropsNoSpreading = [] | [
+    ({
+        html?: ("enforce" | "ignore");
+        custom?: ("enforce" | "ignore");
+        exceptions?: string[];
+        [k: string]: unknown | undefined;
+    } & {
+        [k: string]: unknown | undefined;
+    })
+];
+type ReactJsxSortDefaultProps = [] | [
+    {
+        ignoreCase?: boolean;
+    }
+];
+type ReactJsxSortProps = [] | [
+    {
+        callbacksLast?: boolean;
+        shorthandFirst?: boolean;
+        shorthandLast?: boolean;
+        multiline?: ("ignore" | "first" | "last");
+        ignoreCase?: boolean;
+        noSortAlphabetically?: boolean;
+        reservedFirst?: (unknown[] | boolean);
+        locale?: string;
+    }
+];
+type ReactJsxSpaceBeforeClosing = [] | [("always" | "never")];
+type ReactJsxTagSpacing = [] | [
+    {
+        closingSlash?: ("always" | "never" | "allow");
+        beforeSelfClosing?: ("always" | "proportional-always" | "never" | "allow");
+        afterOpening?: ("always" | "allow-multiline" | "never" | "allow");
+        beforeClosing?: ("always" | "proportional-always" | "never" | "allow");
+    }
+];
+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");
+    }
+];
+type ReactNoChildrenProp = [] | [
+    {
+        allowFunctions?: boolean;
+    }
+];
+type ReactNoDanger = [] | [
+    {
+        customComponentNames?: string[];
+        [k: string]: unknown | undefined;
+    }
+];
+type ReactNoDidMountSetState = [] | ["disallow-in-func"];
+type ReactNoDidUpdateSetState = [] | ["disallow-in-func"];
+type ReactNoInvalidHtmlAttribute = [] | [("rel")[]];
+type ReactNoMultiComp = [] | [
+    {
+        ignoreStateless?: boolean;
+    }
+];
+type ReactNoStringRefs = [] | [
+    {
+        noTemplateLiterals?: boolean;
+    }
+];
+type ReactNoUnescapedEntities = [] | [
+    {
+        forbid?: (string | {
+            char?: string;
+            alternatives?: string[];
+            [k: string]: unknown | undefined;
+        })[];
+    }
+];
+type ReactNoUnknownProperty = [] | [
+    {
+        ignore?: string[];
+        requireDataLowercase?: boolean;
+    }
+];
+type ReactNoUnsafe = [] | [
+    {
+        checkAliases?: boolean;
+    }
+];
+type ReactNoUnstableNestedComponents = [] | [
+    {
+        customValidators?: string[];
+        allowAsProps?: boolean;
+    }
+];
+type ReactNoUnusedPropTypes = [] | [
+    {
+        ignore?: string[];
+        customValidators?: string[];
+        skipShapeProps?: boolean;
+    }
+];
+type ReactNoWillUpdateSetState = [] | ["disallow-in-func"];
+type ReactPreferEs6Class = [] | [("always" | "never")];
+type ReactPreferStatelessFunction = [] | [
+    {
+        ignorePureComponents?: boolean;
+    }
+];
+type ReactPropTypes = [] | [
+    {
+        ignore?: string[];
+        customValidators?: string[];
+        skipUndeclared?: boolean;
+    }
+];
+type ReactRequireDefaultProps = [] | [
+    {
+        forbidDefaultForRequired?: boolean;
+        classes?: ("defaultProps" | "ignore");
+        functions?: ("defaultArguments" | "defaultProps" | "ignore");
+        ignoreFunctionalComponents?: boolean;
+    }
+];
+type ReactRequireOptimization = [] | [
+    {
+        allowDecorators?: string[];
+    }
+];
+type ReactSelfClosingComp = [] | [
+    {
+        component?: boolean;
+        html?: boolean;
+    }
+];
+type ReactSortComp = [] | [
+    {
+        order?: string[];
+        groups?: {
+            [k: string]: string[];
+        };
+    }
+];
+type ReactSortDefaultProps = [] | [
+    {
+        ignoreCase?: boolean;
+    }
+];
+type ReactSortPropTypes = [] | [
+    {
+        requiredFirst?: boolean;
+        callbacksLast?: boolean;
+        ignoreCase?: boolean;
+        noSortAlphabetically?: boolean;
+        sortShapeProp?: boolean;
+        checkTypes?: boolean;
+    }
+];
+type ReactStateInConstructor = [] | [("always" | "never")];
+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");
+    }
+];
+type ReactStylePropObject = [] | [
+    {
+        allow?: string[];
+        [k: string]: unknown | undefined;
+    }
+];
+export {};