`) that have click handlers use the role attribute. * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-static-element-interactions.md */ "jsx-a11y/no-static-element-interactions"?: Linter.RuleEntry; /** * Enforces using semantic DOM elements over the ARIA `role` property. * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/prefer-tag-over-role.md */ "jsx-a11y/prefer-tag-over-role"?: Linter.RuleEntry; /** * Enforce that elements with ARIA roles must have all required attributes for that role. * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/role-has-required-aria-props.md */ "jsx-a11y/role-has-required-aria-props"?: Linter.RuleEntry; /** * Enforce that elements with explicit or implicit roles defined contain only `aria-*` properties supported by that `role`. * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/role-supports-aria-props.md */ "jsx-a11y/role-supports-aria-props"?: Linter.RuleEntry; /** * Enforce `scope` prop is only used on `` elements. * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/scope.md */ "jsx-a11y/scope"?: Linter.RuleEntry; /** * Enforce `tabIndex` value is not greater than zero. * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/tabindex-no-positive.md */ "jsx-a11y/tabindex-no-positive"?: Linter.RuleEntry; /** * require `return` statements after callbacks * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/callback-return.md */ "n/callback-return"?: Linter.RuleEntry; /** * enforce either `module.exports` or `exports` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/exports-style.md */ "n/exports-style"?: Linter.RuleEntry; /** * enforce the style of file extensions in `import` declarations * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/file-extension-in-import.md */ "n/file-extension-in-import"?: Linter.RuleEntry; /** * require `require()` calls to be placed at top-level module scope * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/global-require.md */ "n/global-require"?: Linter.RuleEntry<[ ]>; /** * require error handling in callbacks * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/handle-callback-err.md */ "n/handle-callback-err"?: Linter.RuleEntry; /** * require correct usage of hashbang * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/hashbang.md */ "n/hashbang"?: Linter.RuleEntry; /** * enforce Node.js-style error-first callback pattern is followed * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-callback-literal.md */ "n/no-callback-literal"?: Linter.RuleEntry<[ ]>; /** * disallow deprecated APIs * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-deprecated-api.md */ "n/no-deprecated-api"?: Linter.RuleEntry; /** * disallow the assignment to `exports` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-exports-assign.md */ "n/no-exports-assign"?: Linter.RuleEntry<[ ]>; /** * disallow `import` declarations which import extraneous modules * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-extraneous-import.md */ "n/no-extraneous-import"?: Linter.RuleEntry; /** * disallow `require()` expressions which import extraneous modules * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-extraneous-require.md */ "n/no-extraneous-require"?: Linter.RuleEntry; /** * disallow third-party modules which are hiding core modules * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-hide-core-modules.md * @deprecated */ "n/no-hide-core-modules"?: Linter.RuleEntry; /** * disallow `import` declarations which import missing modules * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-missing-import.md */ "n/no-missing-import"?: Linter.RuleEntry; /** * disallow `require()` expressions which import missing modules * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-missing-require.md */ "n/no-missing-require"?: Linter.RuleEntry; /** * disallow `require` calls to be mixed with regular variable declarations * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-mixed-requires.md */ "n/no-mixed-requires"?: Linter.RuleEntry; /** * disallow `new` operators with calls to `require` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-new-require.md */ "n/no-new-require"?: Linter.RuleEntry<[ ]>; /** * disallow string concatenation with `__dirname` and `__filename` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-path-concat.md */ "n/no-path-concat"?: Linter.RuleEntry<[ ]>; /** * disallow the use of `process.env` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-process-env.md */ "n/no-process-env"?: Linter.RuleEntry; /** * disallow the use of `process.exit()` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-process-exit.md */ "n/no-process-exit"?: Linter.RuleEntry<[ ]>; /** * disallow specified modules when loaded by `import` declarations * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-restricted-import.md */ "n/no-restricted-import"?: Linter.RuleEntry; /** * disallow specified modules when loaded by `require` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-restricted-require.md */ "n/no-restricted-require"?: Linter.RuleEntry; /** * disallow synchronous methods * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-sync.md */ "n/no-sync"?: Linter.RuleEntry; /** * disallow top-level `await` in published modules * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-top-level-await.md */ "n/no-top-level-await"?: Linter.RuleEntry; /** * disallow `bin` files that npm ignores * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-unpublished-bin.md */ "n/no-unpublished-bin"?: Linter.RuleEntry; /** * disallow `import` declarations which import private modules * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-unpublished-import.md */ "n/no-unpublished-import"?: Linter.RuleEntry; /** * disallow `require()` expressions which import private modules * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-unpublished-require.md */ "n/no-unpublished-require"?: Linter.RuleEntry; /** * disallow unsupported ECMAScript built-ins on the specified version * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-unsupported-features/es-builtins.md */ "n/no-unsupported-features/es-builtins"?: Linter.RuleEntry; /** * disallow unsupported ECMAScript syntax on the specified version * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-unsupported-features/es-syntax.md */ "n/no-unsupported-features/es-syntax"?: Linter.RuleEntry; /** * disallow unsupported Node.js built-in APIs on the specified version * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/no-unsupported-features/node-builtins.md */ "n/no-unsupported-features/node-builtins"?: Linter.RuleEntry; /** * enforce either `Buffer` or `require("buffer").Buffer` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/buffer.md */ "n/prefer-global/buffer"?: Linter.RuleEntry; /** * enforce either `console` or `require("console")` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/console.md */ "n/prefer-global/console"?: Linter.RuleEntry; /** * enforce either `crypto` or `require("crypto").webcrypto` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/crypto.md */ "n/prefer-global/crypto"?: Linter.RuleEntry; /** * enforce either `process` or `require("process")` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/process.md */ "n/prefer-global/process"?: Linter.RuleEntry; /** * enforce either `TextDecoder` or `require("util").TextDecoder` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/text-decoder.md */ "n/prefer-global/text-decoder"?: Linter.RuleEntry; /** * enforce either `TextEncoder` or `require("util").TextEncoder` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/text-encoder.md */ "n/prefer-global/text-encoder"?: Linter.RuleEntry; /** * enforce either global timer functions or `require("timers")` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/timers.md */ "n/prefer-global/timers"?: Linter.RuleEntry; /** * enforce either `URL` or `require("url").URL` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/url.md */ "n/prefer-global/url"?: Linter.RuleEntry; /** * enforce either `URLSearchParams` or `require("url").URLSearchParams` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-global/url-search-params.md */ "n/prefer-global/url-search-params"?: Linter.RuleEntry; /** * enforce using the `node:` protocol when importing Node.js builtin modules. * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-node-protocol.md */ "n/prefer-node-protocol"?: Linter.RuleEntry; /** * enforce `require("dns").promises` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-promises/dns.md */ "n/prefer-promises/dns"?: Linter.RuleEntry<[ ]>; /** * enforce `require("fs").promises` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/prefer-promises/fs.md */ "n/prefer-promises/fs"?: Linter.RuleEntry<[ ]>; /** * require that `process.exit()` expressions use the same code path as `throw` * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/process-exit-as-throw.md */ "n/process-exit-as-throw"?: Linter.RuleEntry<[ ]>; /** * require correct usage of hashbang * @see https://github.com/eslint-community/eslint-plugin-n/blob/HEAD/docs/rules/hashbang.md * @deprecated */ "n/shebang"?: Linter.RuleEntry; /** * disallow .only blocks in tests * @see https://github.com/levibuzolic/eslint-plugin-no-only-tests */ "no-only-tests/no-only-tests"?: Linter.RuleEntry; /** * Optimize regex literals */ "optimize-regex/optimize-regex"?: Linter.RuleEntry; /** * Require languages for fenced code blocks * @see https://github.com/eslint/markdown/blob/main/docs/rules/fenced-code-language.md */ "pluginMarkdown/fenced-code-language"?: Linter.RuleEntry; /** * Enforce heading levels increment by one * @see https://github.com/eslint/markdown/blob/main/docs/rules/heading-increment.md */ "pluginMarkdown/heading-increment"?: Linter.RuleEntry; /** * Disallow bare URLs * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-bare-urls.md */ "pluginMarkdown/no-bare-urls"?: Linter.RuleEntry<[ ]>; /** * Disallow duplicate definitions * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-duplicate-definitions.md */ "pluginMarkdown/no-duplicate-definitions"?: Linter.RuleEntry; /** * Disallow duplicate headings in the same document * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-duplicate-headings.md */ "pluginMarkdown/no-duplicate-headings"?: Linter.RuleEntry; /** * Disallow empty definitions * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-empty-definitions.md */ "pluginMarkdown/no-empty-definitions"?: Linter.RuleEntry; /** * Disallow empty images * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-empty-images.md */ "pluginMarkdown/no-empty-images"?: Linter.RuleEntry<[ ]>; /** * Disallow empty links * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-empty-links.md */ "pluginMarkdown/no-empty-links"?: Linter.RuleEntry<[ ]>; /** * Disallow HTML tags * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-html.md */ "pluginMarkdown/no-html"?: Linter.RuleEntry; /** * Disallow invalid label references * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-invalid-label-refs.md */ "pluginMarkdown/no-invalid-label-refs"?: Linter.RuleEntry<[ ]>; /** * Disallow headings without a space after the hash characters * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-missing-atx-heading-space.md */ "pluginMarkdown/no-missing-atx-heading-space"?: Linter.RuleEntry; /** * Disallow missing label references * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-missing-label-refs.md */ "pluginMarkdown/no-missing-label-refs"?: Linter.RuleEntry; /** * Disallow link fragments that do not reference valid headings * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-missing-link-fragments.md */ "pluginMarkdown/no-missing-link-fragments"?: Linter.RuleEntry; /** * Disallow multiple H1 headings in the same document * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-multiple-h1.md */ "pluginMarkdown/no-multiple-h1"?: Linter.RuleEntry; /** * Disallow URLs that match defined reference identifiers * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-reference-like-urls.md */ "pluginMarkdown/no-reference-like-urls"?: Linter.RuleEntry<[ ]>; /** * Disallow reversed link and image syntax * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-reversed-media-syntax.md */ "pluginMarkdown/no-reversed-media-syntax"?: Linter.RuleEntry<[ ]>; /** * Disallow spaces around emphasis markers * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-space-in-emphasis.md */ "pluginMarkdown/no-space-in-emphasis"?: Linter.RuleEntry; /** * Disallow unused definitions * @see https://github.com/eslint/markdown/blob/main/docs/rules/no-unused-definitions.md */ "pluginMarkdown/no-unused-definitions"?: Linter.RuleEntry; /** * Require alternative text for images * @see https://github.com/eslint/markdown/blob/main/docs/rules/require-alt-text.md */ "pluginMarkdown/require-alt-text"?: Linter.RuleEntry<[ ]>; /** * Disallow data rows in a GitHub Flavored Markdown table from having more cells than the header row * @see https://github.com/eslint/markdown/blob/main/docs/rules/table-column-count.md */ "pluginMarkdown/table-column-count"?: Linter.RuleEntry; /** * Require returning inside each `then()` to create readable and reusable Promise chains. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/always-return.md */ "promise/always-return"?: Linter.RuleEntry; /** * Disallow creating `new` promises outside of utility libs (use [util.promisify][] instead). * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/avoid-new.md */ "promise/avoid-new"?: Linter.RuleEntry<[ ]>; /** * Enforce the use of `catch()` on un-returned promises. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/catch-or-return.md */ "promise/catch-or-return"?: Linter.RuleEntry; /** * Disallow calling `cb()` inside of a `then()` (use [util.callbackify][] instead). * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-callback-in-promise.md */ "promise/no-callback-in-promise"?: Linter.RuleEntry; /** * Disallow creating new promises with paths that resolve multiple times. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-multiple-resolved.md */ "promise/no-multiple-resolved"?: Linter.RuleEntry<[ ]>; /** * Require creating a `Promise` constructor before using it in an ES5 environment. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-native.md */ "promise/no-native"?: Linter.RuleEntry<[ ]>; /** * Disallow nested `then()` or `catch()` statements. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-nesting.md */ "promise/no-nesting"?: Linter.RuleEntry<[ ]>; /** * Disallow calling `new` on a Promise static method. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-new-statics.md */ "promise/no-new-statics"?: Linter.RuleEntry<[ ]>; /** * Disallow using promises inside of callbacks. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-promise-in-callback.md */ "promise/no-promise-in-callback"?: Linter.RuleEntry<[ ]>; /** * Disallow return statements in `finally()`. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-in-finally.md */ "promise/no-return-in-finally"?: Linter.RuleEntry<[ ]>; /** * Disallow wrapping values in `Promise.resolve` or `Promise.reject` when not needed. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/no-return-wrap.md */ "promise/no-return-wrap"?: Linter.RuleEntry; /** * Enforce consistent param names and ordering when creating new promises. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/param-names.md */ "promise/param-names"?: Linter.RuleEntry; /** * Prefer `async`/`await` to the callback pattern. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-callbacks.md */ "promise/prefer-await-to-callbacks"?: Linter.RuleEntry<[ ]>; /** * Prefer `await` to `then()`/`catch()`/`finally()` for reading Promise values. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-await-to-then.md */ "promise/prefer-await-to-then"?: Linter.RuleEntry; /** * Prefer `catch` to `then(a, b)`/`then(null, b)` for handling errors. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/prefer-catch.md */ "promise/prefer-catch"?: Linter.RuleEntry<[ ]>; /** * Disallow use of non-standard Promise static methods. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/spec-only.md */ "promise/spec-only"?: Linter.RuleEntry; /** * Enforces the proper number of arguments are passed to Promise functions. * @see https://github.com/eslint-community/eslint-plugin-promise/blob/main/docs/rules/valid-params.md */ "promise/valid-params"?: 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<[ ]>; /** * Replaces usage of 'ReactDOM.hydrate()' with 'hydrateRoot()'. * @see https://eslint-react.xyz/docs/rules/dom-no-hydrate */ "react-dom/no-hydrate"?: Linter.RuleEntry<[ ]>; /** * Enforces an explicit 'type' attribute for 'button' elements. * @see https://eslint-react.xyz/docs/rules/dom-no-missing-button-type */ "react-dom/no-missing-button-type"?: Linter.RuleEntry<[ ]>; /** * Enforces an explicit 'sandbox' attribute for 'iframe' elements. * @see https://eslint-react.xyz/docs/rules/dom-no-missing-iframe-sandbox */ "react-dom/no-missing-iframe-sandbox"?: Linter.RuleEntry<[ ]>; /** * Enforces the absence of a 'namespace' in React elements. * @see https://eslint-react.xyz/docs/rules/dom-no-namespace */ "react-dom/no-namespace"?: Linter.RuleEntry<[ ]>; /** * Replaces usage of 'ReactDOM.render()' with 'createRoot(node).render()'. * @see https://eslint-react.xyz/docs/rules/dom-no-render */ "react-dom/no-render"?: Linter.RuleEntry<[ ]>; /** * Disallows the return value of 'ReactDOM.render'. * @see https://eslint-react.xyz/docs/rules/dom-no-render-return-value */ "react-dom/no-render-return-value"?: Linter.RuleEntry<[ ]>; /** * 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; /** * 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<[ ]>; /** * Disallows direct calls to the ['set' function](https://react.dev/reference/react/useState#setstate) of 'useState' in 'useEffect'. * @see https://eslint-react.xyz/docs/rules/hooks-extra-no-direct-set-state-in-use-effect */ "react-hooks-extra/no-direct-set-state-in-use-effect"?: Linter.RuleEntry<[ ]>; /** * Verifies that automatic effect dependencies are compiled if opted-in */ "react-hooks/automatic-effect-dependencies"?: Linter.RuleEntry; /** * Validates against calling capitalized functions/methods instead of using JSX */ "react-hooks/capitalized-calls"?: Linter.RuleEntry; /** * Validates against higher order functions defining nested components or hooks. Components and hooks should be defined at the module level */ "react-hooks/component-hook-factories"?: Linter.RuleEntry; /** * Validates the compiler configuration options */ "react-hooks/config"?: Linter.RuleEntry; /** * Validates usage of error boundaries instead of try/catch for errors in child components */ "react-hooks/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; /** * Validates usage of fbt */ "react-hooks/fbt"?: Linter.RuleEntry; /** * Validates usage of `fire` */ "react-hooks/fire"?: Linter.RuleEntry; /** * Validates configuration of [gating mode](https://react.dev/reference/react-compiler/gating) */ "react-hooks/gating"?: 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) */ "react-hooks/globals"?: Linter.RuleEntry; /** * Validates the rules of hooks */ "react-hooks/hooks"?: 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) */ "react-hooks/immutability"?: Linter.RuleEntry; /** * Validates against usage of libraries which are incompatible with memoization (manual or automatic) */ "react-hooks/incompatible-library"?: Linter.RuleEntry; /** * Internal invariants */ "react-hooks/invariant"?: Linter.RuleEntry; /** * Validates that effect dependencies are memoized */ "react-hooks/memoized-effect-dependencies"?: Linter.RuleEntry; /** * Validates against deriving values from state in an effect */ "react-hooks/no-deriving-state-in-effects"?: 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) */ "react-hooks/preserve-manual-memoization"?: 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 */ "react-hooks/purity"?: 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) */ "react-hooks/refs"?: Linter.RuleEntry; /** * Validates against suppression of other rules */ "react-hooks/rule-suppression"?: Linter.RuleEntry; /** * enforces the Rules of Hooks * @see https://react.dev/reference/rules/rules-of-hooks */ "react-hooks/rules-of-hooks"?: Linter.RuleEntry; /** * Validates against calling setState synchronously in an effect, which can lead to re-renders that degrade performance */ "react-hooks/set-state-in-effect"?: Linter.RuleEntry; /** * Validates against setting state during render, which can trigger additional renders and potential infinite render loops */ "react-hooks/set-state-in-render"?: Linter.RuleEntry; /** * Validates that components are static, not recreated every render. Components that are recreated dynamically can reset state and trigger excessive re-rendering */ "react-hooks/static-components"?: Linter.RuleEntry; /** * Validates against invalid syntax */ "react-hooks/syntax"?: Linter.RuleEntry; /** * Unimplemented features */ "react-hooks/todo"?: Linter.RuleEntry; /** * Validates against syntax that we do not plan to support in React Compiler */ "react-hooks/unsupported-syntax"?: Linter.RuleEntry; /** * Validates usage of the useMemo() hook against common mistakes. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information. */ "react-hooks/use-memo"?: 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. */ "react-hooks/void-use-memo"?: Linter.RuleEntry; /** * Enforces naming conventions for components. * @see https://eslint-react.xyz/docs/rules/naming-convention-component-name */ "react-naming-convention/component-name"?: Linter.RuleEntry; /** * 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-naming-convention/context-name"?: Linter.RuleEntry<[ ]>; /** * Enforces consistent file-naming conventions. * @see https://eslint-react.xyz/docs/rules/naming-convention-filename */ "react-naming-convention/filename"?: Linter.RuleEntry; /** * Enforces consistent use of the JSX file extension. * @see https://eslint-react.xyz/docs/rules/naming-convention-filename-extension */ "react-naming-convention/filename-extension"?: Linter.RuleEntry; /** * 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-naming-convention/id-name"?: Linter.RuleEntry<[ ]>; /** * 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-naming-convention/ref-name"?: Linter.RuleEntry<[ ]>; /** * Enforces destructuring and symmetric naming of the 'useState' hook value and setter. * @see https://eslint-react.xyz/docs/rules/naming-convention-use-state */ "react-naming-convention/use-state"?: Linter.RuleEntry; "react-refresh/only-export-components"?: Linter.RuleEntry; /** * Prevents unintentional '$' sign before expression. * @see https://eslint-react.xyz/docs/rules/jsx-dollar */ "react/jsx-dollar"?: Linter.RuleEntry<[ ]>; /** * Enforces 'key' prop placement before spread props. * @see https://eslint-react.xyz/docs/rules/jsx-key-before-spread */ "react/jsx-key-before-spread"?: Linter.RuleEntry<[ ]>; /** * Prevents comment strings (e.g., beginning with '//' or '/*') from being accidentally inserted into a JSX element's text nodes. * @see https://eslint-react.xyz/docs/rules/jsx-no-comment-textnodes */ "react/jsx-no-comment-textnodes"?: Linter.RuleEntry<[ ]>; /** * Disallows duplicate props in JSX elements. * @see https://eslint-react.xyz/docs/rules/jsx-no-duplicate-props */ "react/jsx-no-duplicate-props"?: Linter.RuleEntry<[ ]>; /** * Disallows immediately-invoked function expressions in JSX. * @see https://eslint-react.xyz/docs/rules/jsx-no-iife */ "react/jsx-no-iife"?: Linter.RuleEntry<[ ]>; /** * Prevents using variables in JSX that are not defined in the scope. * @see https://eslint-react.xyz/docs/rules/jsx-no-undef */ "react/jsx-no-undef"?: Linter.RuleEntry<[ ]>; /** * Enforces shorthand syntax for boolean props. * @see https://eslint-react.xyz/docs/rules/jsx-shorthand-boolean */ "react/jsx-shorthand-boolean"?: Linter.RuleEntry; /** * Enforces shorthand syntax for fragment elements. * @see https://eslint-react.xyz/docs/rules/jsx-shorthand-fragment */ "react/jsx-shorthand-fragment"?: Linter.RuleEntry; /** * Marks React variables as used when JSX is present. * @see https://eslint-react.xyz/docs/rules/jsx-uses-react */ "react/jsx-uses-react"?: Linter.RuleEntry<[ ]>; /** * Marks JSX element variables as used. * @see https://eslint-react.xyz/docs/rules/jsx-uses-vars */ "react/jsx-uses-vars"?: Linter.RuleEntry<[ ]>; /** * Disallows accessing 'this.state' inside 'setState' calls. * @see https://eslint-react.xyz/docs/rules/no-access-state-in-setstate */ "react/no-access-state-in-setstate"?: Linter.RuleEntry<[ ]>; /** * Disallows using an item's index in the array as its key. * @see https://eslint-react.xyz/docs/rules/no-array-index-key */ "react/no-array-index-key"?: Linter.RuleEntry<[ ]>; /** * Disallows the use of 'Children.count' from the 'react' package. * @see https://eslint-react.xyz/docs/rules/no-children-count */ "react/no-children-count"?: Linter.RuleEntry<[ ]>; /** * Disallows the use of 'Children.forEach' from the 'react' package. * @see https://eslint-react.xyz/docs/rules/no-children-for-each */ "react/no-children-for-each"?: Linter.RuleEntry<[ ]>; /** * Disallows the use of 'Children.map' from the 'react' package. * @see https://eslint-react.xyz/docs/rules/no-children-map */ "react/no-children-map"?: Linter.RuleEntry<[ ]>; /** * Disallows the use of 'Children.only' from the 'react' package. * @see https://eslint-react.xyz/docs/rules/no-children-only */ "react/no-children-only"?: Linter.RuleEntry<[ ]>; /** * Disallows passing 'children' as a prop. * @see https://eslint-react.xyz/docs/rules/no-children-prop */ "react/no-children-prop"?: Linter.RuleEntry<[ ]>; /** * Disallows the use of 'Children.toArray' from the 'react' package. * @see https://eslint-react.xyz/docs/rules/no-children-to-array */ "react/no-children-to-array"?: Linter.RuleEntry<[ ]>; /** * Disallows class components except for error boundaries. * @see https://eslint-react.xyz/docs/rules/no-class-component */ "react/no-class-component"?: Linter.RuleEntry<[ ]>; /** * Disallows 'cloneElement'. * @see https://eslint-react.xyz/docs/rules/no-clone-element */ "react/no-clone-element"?: Linter.RuleEntry<[ ]>; /** * Replaces usage of 'componentWillMount' with 'UNSAFE_componentWillMount'. * @see https://eslint-react.xyz/docs/rules/no-component-will-mount */ "react/no-component-will-mount"?: Linter.RuleEntry<[ ]>; /** * Replaces usage of 'componentWillReceiveProps' with 'UNSAFE_componentWillReceiveProps'. * @see https://eslint-react.xyz/docs/rules/no-component-will-receive-props */ "react/no-component-will-receive-props"?: Linter.RuleEntry<[ ]>; /** * Replaces usage of 'componentWillUpdate' with 'UNSAFE_componentWillUpdate'. * @see https://eslint-react.xyz/docs/rules/no-component-will-update */ "react/no-component-will-update"?: Linter.RuleEntry<[ ]>; /** * Replaces usage of '' with ''. * @see https://eslint-react.xyz/docs/rules/no-context-provider */ "react/no-context-provider"?: Linter.RuleEntry<[ ]>; /** * Disallows 'createRef' in function components. * @see https://eslint-react.xyz/docs/rules/no-create-ref */ "react/no-create-ref"?: Linter.RuleEntry<[ ]>; /** * Disallows the 'defaultProps' property in favor of ES6 default parameters. * @see https://eslint-react.xyz/docs/rules/no-default-props */ "react/no-default-props"?: Linter.RuleEntry<[ ]>; /** * Disallows direct mutation of 'this.state'. * @see https://eslint-react.xyz/docs/rules/no-direct-mutation-state */ "react/no-direct-mutation-state"?: Linter.RuleEntry<[ ]>; /** * Prevents duplicate 'key' props on sibling elements when rendering lists. * @see https://eslint-react.xyz/docs/rules/no-duplicate-key */ "react/no-duplicate-key"?: Linter.RuleEntry<[ ]>; /** * Disallows certain props on components. * @see https://eslint-react.xyz/docs/rules/no-forbidden-props * @deprecated */ "react/no-forbidden-props"?: Linter.RuleEntry; /** * Replaces usage of 'forwardRef' with passing 'ref' as a prop. * @see https://eslint-react.xyz/docs/rules/no-forward-ref */ "react/no-forward-ref"?: Linter.RuleEntry<[ ]>; /** * Prevents implicitly passing the 'key' prop to components. * @see https://eslint-react.xyz/docs/rules/no-implicit-key */ "react/no-implicit-key"?: Linter.RuleEntry<[ ]>; /** * Prevents problematic leaked values from being rendered. * @see https://eslint-react.xyz/docs/rules/no-leaked-conditional-rendering */ "react/no-leaked-conditional-rendering"?: Linter.RuleEntry<[ ]>; /** * 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-missing-component-display-name"?: Linter.RuleEntry<[ ]>; /** * 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-missing-context-display-name"?: Linter.RuleEntry<[ ]>; /** * Disallows missing 'key' on items in list rendering. * @see https://eslint-react.xyz/docs/rules/no-missing-key */ "react/no-missing-key"?: Linter.RuleEntry<[ ]>; /** * Prevents incorrect usage of 'captureOwnerStack'. * @see https://eslint-react.xyz/docs/rules/no-misused-capture-owner-stack */ "react/no-misused-capture-owner-stack"?: Linter.RuleEntry<[ ]>; /** * Disallows nesting component definitions inside other components. * @see https://eslint-react.xyz/docs/rules/no-nested-component-definitions */ "react/no-nested-component-definitions"?: Linter.RuleEntry<[ ]>; /** * Disallows nesting lazy component declarations inside other components. * @see https://eslint-react.xyz/docs/rules/no-nested-lazy-component-declarations */ "react/no-nested-lazy-component-declarations"?: Linter.RuleEntry<[ ]>; /** * Disallows 'propTypes' in favor of TypeScript or another type-checking solution. * @see https://eslint-react.xyz/docs/rules/no-prop-types */ "react/no-prop-types"?: Linter.RuleEntry<[ ]>; /** * Disallows 'shouldComponentUpdate' when extending 'React.PureComponent'. * @see https://eslint-react.xyz/docs/rules/no-redundant-should-component-update */ "react/no-redundant-should-component-update"?: Linter.RuleEntry<[ ]>; /** * 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-set-state-in-component-did-mount"?: Linter.RuleEntry<[ ]>; /** * 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-set-state-in-component-did-update"?: Linter.RuleEntry<[ ]>; /** * 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-set-state-in-component-will-update"?: Linter.RuleEntry<[ ]>; /** * Replaces string refs with callback refs. * @see https://eslint-react.xyz/docs/rules/no-string-refs */ "react/no-string-refs"?: Linter.RuleEntry<[ ]>; /** * Disallows unnecessary 'key' props on nested child elements when rendering lists. * @see https://eslint-react.xyz/docs/rules/no-unnecessary-key */ "react/no-unnecessary-key"?: Linter.RuleEntry<[ ]>; /** * Disallows unnecessary usage of 'useCallback'. * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-callback */ "react/no-unnecessary-use-callback"?: Linter.RuleEntry<[ ]>; /** * Disallows unnecessary usage of 'useMemo'. * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-memo */ "react/no-unnecessary-use-memo"?: Linter.RuleEntry<[ ]>; /** * 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-unnecessary-use-prefix"?: Linter.RuleEntry<[ ]>; /** * Disallows unnecessary usage of 'useRef'. * @see https://eslint-react.xyz/docs/rules/no-unnecessary-use-ref */ "react/no-unnecessary-use-ref"?: Linter.RuleEntry<[ ]>; /** * Warns about the use of 'UNSAFE_componentWillMount' in class components. * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-mount */ "react/no-unsafe-component-will-mount"?: Linter.RuleEntry<[ ]>; /** * Warns about the use of 'UNSAFE_componentWillReceiveProps' in class components. * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-receive-props */ "react/no-unsafe-component-will-receive-props"?: Linter.RuleEntry<[ ]>; /** * Warns about the use of 'UNSAFE_componentWillUpdate' in class components. * @see https://eslint-react.xyz/docs/rules/no-unsafe-component-will-update */ "react/no-unsafe-component-will-update"?: Linter.RuleEntry<[ ]>; /** * Prevents non-stable values (i.e., object literals) from being used as a value for 'Context.Provider'. * @see https://eslint-react.xyz/docs/rules/no-unstable-context-value */ "react/no-unstable-context-value"?: Linter.RuleEntry<[ ]>; /** * Prevents using referential-type values as default props in object destructuring. * @see https://eslint-react.xyz/docs/rules/no-unstable-default-props */ "react/no-unstable-default-props"?: Linter.RuleEntry; /** * Warns about unused class component methods and properties. * @see https://eslint-react.xyz/docs/rules/no-unused-class-component-members */ "react/no-unused-class-component-members"?: Linter.RuleEntry<[ ]>; /** * Warns about component props that are defined but never used. * @see https://eslint-react.xyz/docs/rules/no-unused-props */ "react/no-unused-props"?: Linter.RuleEntry<[ ]>; /** * Warns about unused class component state. * @see https://eslint-react.xyz/docs/rules/no-unused-state */ "react/no-unused-state"?: Linter.RuleEntry<[ ]>; /** * Replaces usage of 'useContext' with 'use'. * @see https://eslint-react.xyz/docs/rules/no-use-context */ "react/no-use-context"?: Linter.RuleEntry<[ ]>; /** * Disallows useless 'forwardRef' calls on components that don't use 'ref's. * @see https://eslint-react.xyz/docs/rules/no-useless-forward-ref */ "react/no-useless-forward-ref"?: Linter.RuleEntry<[ ]>; /** * Disallows useless fragment elements. * @see https://eslint-react.xyz/docs/rules/no-useless-fragment */ "react/no-useless-fragment"?: Linter.RuleEntry; /** * Enforces destructuring assignment for component props and context. * @see https://eslint-react.xyz/docs/rules/prefer-destructuring-assignment */ "react/prefer-destructuring-assignment"?: Linter.RuleEntry<[ ]>; /** * Enforces importing React via a namespace import. * @see https://eslint-react.xyz/docs/rules/prefer-namespace-import */ "react/prefer-namespace-import"?: Linter.RuleEntry<[ ]>; /** * Enforces read-only props in components. * @see https://eslint-react.xyz/docs/rules/prefer-read-only-props */ "react/prefer-read-only-props"?: Linter.RuleEntry<[ ]>; /** * Enforces wrapping function calls made inside 'useState' in an 'initializer function'. * @see https://eslint-react.xyz/docs/rules/prefer-use-state-lazy-initialization */ "react/prefer-use-state-lazy-initialization"?: Linter.RuleEntry<[ ]>; /** * disallow confusing quantifiers * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/confusing-quantifier.html */ "regexp/confusing-quantifier"?: Linter.RuleEntry<[ ]>; /** * enforce consistent escaping of control characters * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/control-character-escape.html */ "regexp/control-character-escape"?: Linter.RuleEntry<[ ]>; /** * enforce single grapheme in string literal * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/grapheme-string-literal.html */ "regexp/grapheme-string-literal"?: Linter.RuleEntry<[ ]>; /** * enforce consistent usage of hexadecimal escape * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/hexadecimal-escape.html */ "regexp/hexadecimal-escape"?: Linter.RuleEntry; /** * enforce into your favorite case * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/letter-case.html */ "regexp/letter-case"?: Linter.RuleEntry; /** * enforce match any character style * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/match-any.html */ "regexp/match-any"?: Linter.RuleEntry; /** * enforce use of escapes on negation * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/negation.html */ "regexp/negation"?: Linter.RuleEntry<[ ]>; /** * disallow elements that contradict assertions * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-contradiction-with-assertion.html */ "regexp/no-contradiction-with-assertion"?: Linter.RuleEntry<[ ]>; /** * disallow control characters * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-control-character.html */ "regexp/no-control-character"?: Linter.RuleEntry<[ ]>; /** * disallow duplicate characters in the RegExp character class * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-dupe-characters-character-class.html */ "regexp/no-dupe-characters-character-class"?: Linter.RuleEntry<[ ]>; /** * disallow duplicate disjunctions * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-dupe-disjunctions.html */ "regexp/no-dupe-disjunctions"?: Linter.RuleEntry; /** * disallow alternatives without elements * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-alternative.html */ "regexp/no-empty-alternative"?: Linter.RuleEntry<[ ]>; /** * disallow capturing group that captures empty. * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-capturing-group.html */ "regexp/no-empty-capturing-group"?: Linter.RuleEntry<[ ]>; /** * disallow character classes that match no characters * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-character-class.html */ "regexp/no-empty-character-class"?: Linter.RuleEntry<[ ]>; /** * disallow empty group * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-group.html */ "regexp/no-empty-group"?: Linter.RuleEntry<[ ]>; /** * disallow empty lookahead assertion or empty lookbehind assertion * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-lookarounds-assertion.html */ "regexp/no-empty-lookarounds-assertion"?: Linter.RuleEntry<[ ]>; /** * disallow empty string literals in character classes * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-empty-string-literal.html */ "regexp/no-empty-string-literal"?: Linter.RuleEntry<[ ]>; /** * disallow escape backspace (`[\b]`) * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-escape-backspace.html */ "regexp/no-escape-backspace"?: Linter.RuleEntry<[ ]>; /** * disallow unnecessary nested lookaround assertions * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-extra-lookaround-assertions.html */ "regexp/no-extra-lookaround-assertions"?: Linter.RuleEntry<[ ]>; /** * disallow invalid regular expression strings in `RegExp` constructors * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-invalid-regexp.html */ "regexp/no-invalid-regexp"?: Linter.RuleEntry<[ ]>; /** * disallow invisible raw character * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-invisible-character.html */ "regexp/no-invisible-character"?: Linter.RuleEntry<[ ]>; /** * disallow lazy quantifiers at the end of an expression * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-lazy-ends.html */ "regexp/no-lazy-ends"?: Linter.RuleEntry; /** * disallow legacy RegExp features * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-legacy-features.html */ "regexp/no-legacy-features"?: Linter.RuleEntry; /** * disallow capturing groups that do not behave as one would expect * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-misleading-capturing-group.html */ "regexp/no-misleading-capturing-group"?: Linter.RuleEntry; /** * disallow multi-code-point characters in character classes and quantifiers * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-misleading-unicode-character.html */ "regexp/no-misleading-unicode-character"?: Linter.RuleEntry; /** * disallow missing `g` flag in patterns used in `String#matchAll` and `String#replaceAll` * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-missing-g-flag.html */ "regexp/no-missing-g-flag"?: Linter.RuleEntry; /** * disallow non-standard flags * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-non-standard-flag.html */ "regexp/no-non-standard-flag"?: Linter.RuleEntry<[ ]>; /** * disallow obscure character ranges * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-obscure-range.html */ "regexp/no-obscure-range"?: Linter.RuleEntry; /** * disallow octal escape sequence * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-octal.html */ "regexp/no-octal"?: Linter.RuleEntry<[ ]>; /** * disallow optional assertions * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-optional-assertion.html */ "regexp/no-optional-assertion"?: Linter.RuleEntry<[ ]>; /** * disallow backreferences that reference a group that might not be matched * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-potentially-useless-backreference.html */ "regexp/no-potentially-useless-backreference"?: Linter.RuleEntry<[ ]>; /** * disallow standalone backslashes (`\`) * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-standalone-backslash.html */ "regexp/no-standalone-backslash"?: Linter.RuleEntry<[ ]>; /** * disallow exponential and polynomial backtracking * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-super-linear-backtracking.html */ "regexp/no-super-linear-backtracking"?: Linter.RuleEntry; /** * disallow quantifiers that cause quadratic moves * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-super-linear-move.html */ "regexp/no-super-linear-move"?: Linter.RuleEntry; /** * disallow trivially nested assertions * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-trivially-nested-assertion.html */ "regexp/no-trivially-nested-assertion"?: Linter.RuleEntry<[ ]>; /** * disallow nested quantifiers that can be rewritten as one quantifier * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-trivially-nested-quantifier.html */ "regexp/no-trivially-nested-quantifier"?: Linter.RuleEntry<[ ]>; /** * disallow unused capturing group * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-unused-capturing-group.html */ "regexp/no-unused-capturing-group"?: Linter.RuleEntry; /** * disallow assertions that are known to always accept (or reject) * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-assertions.html */ "regexp/no-useless-assertions"?: Linter.RuleEntry<[ ]>; /** * disallow useless backreferences in regular expressions * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-backreference.html */ "regexp/no-useless-backreference"?: Linter.RuleEntry<[ ]>; /** * disallow character class with one character * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-character-class.html */ "regexp/no-useless-character-class"?: Linter.RuleEntry; /** * disallow useless `$` replacements in replacement string * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-dollar-replacements.html */ "regexp/no-useless-dollar-replacements"?: Linter.RuleEntry<[ ]>; /** * disallow unnecessary escape characters in RegExp * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-escape.html */ "regexp/no-useless-escape"?: Linter.RuleEntry<[ ]>; /** * disallow unnecessary regex flags * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-flag.html */ "regexp/no-useless-flag"?: Linter.RuleEntry; /** * disallow unnecessarily non-greedy quantifiers * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-lazy.html */ "regexp/no-useless-lazy"?: Linter.RuleEntry<[ ]>; /** * disallow unnecessary non-capturing group * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-non-capturing-group.html */ "regexp/no-useless-non-capturing-group"?: Linter.RuleEntry; /** * disallow quantifiers that can be removed * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-quantifier.html */ "regexp/no-useless-quantifier"?: Linter.RuleEntry<[ ]>; /** * disallow unnecessary character ranges * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-range.html */ "regexp/no-useless-range"?: Linter.RuleEntry<[ ]>; /** * disallow unnecessary elements in expression character classes * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-set-operand.html */ "regexp/no-useless-set-operand"?: Linter.RuleEntry<[ ]>; /** * disallow string disjunction of single characters in `\q{...}` * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-string-literal.html */ "regexp/no-useless-string-literal"?: Linter.RuleEntry<[ ]>; /** * disallow unnecessary `{n,m}` quantifier * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-two-nums-quantifier.html */ "regexp/no-useless-two-nums-quantifier"?: Linter.RuleEntry<[ ]>; /** * disallow quantifiers with a maximum of zero * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-zero-quantifier.html */ "regexp/no-zero-quantifier"?: Linter.RuleEntry<[ ]>; /** * disallow the alternatives of lookarounds that end with a non-constant quantifier * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/optimal-lookaround-quantifier.html */ "regexp/optimal-lookaround-quantifier"?: Linter.RuleEntry<[ ]>; /** * require optimal quantifiers for concatenated quantifiers * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/optimal-quantifier-concatenation.html */ "regexp/optimal-quantifier-concatenation"?: Linter.RuleEntry; /** * enforce using character class * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-character-class.html */ "regexp/prefer-character-class"?: Linter.RuleEntry; /** * enforce using `\d` * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-d.html */ "regexp/prefer-d"?: Linter.RuleEntry; /** * enforces escape of replacement `$` character (`$$`). * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-escape-replacement-dollar-char.html */ "regexp/prefer-escape-replacement-dollar-char"?: Linter.RuleEntry<[ ]>; /** * prefer lookarounds over capturing group that do not replace * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-lookaround.html */ "regexp/prefer-lookaround"?: Linter.RuleEntry; /** * enforce using named backreferences * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-named-backreference.html */ "regexp/prefer-named-backreference"?: Linter.RuleEntry<[ ]>; /** * enforce using named capture groups * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-named-capture-group.html */ "regexp/prefer-named-capture-group"?: Linter.RuleEntry<[ ]>; /** * enforce using named replacement * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-named-replacement.html */ "regexp/prefer-named-replacement"?: Linter.RuleEntry; /** * enforce using `+` quantifier * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-plus-quantifier.html */ "regexp/prefer-plus-quantifier"?: Linter.RuleEntry<[ ]>; /** * prefer predefined assertion over equivalent lookarounds * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-predefined-assertion.html */ "regexp/prefer-predefined-assertion"?: Linter.RuleEntry<[ ]>; /** * enforce using quantifier * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-quantifier.html */ "regexp/prefer-quantifier"?: Linter.RuleEntry; /** * enforce using `?` quantifier * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-question-quantifier.html */ "regexp/prefer-question-quantifier"?: Linter.RuleEntry<[ ]>; /** * enforce using character class range * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-range.html */ "regexp/prefer-range"?: Linter.RuleEntry; /** * enforce that `RegExp#exec` is used instead of `String#match` if no global flag is provided * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-regexp-exec.html */ "regexp/prefer-regexp-exec"?: Linter.RuleEntry<[ ]>; /** * enforce that `RegExp#test` is used instead of `String#match` and `RegExp#exec` * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-regexp-test.html */ "regexp/prefer-regexp-test"?: Linter.RuleEntry<[ ]>; /** * enforce using result array `groups` * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-result-array-groups.html */ "regexp/prefer-result-array-groups"?: Linter.RuleEntry; /** * prefer character class set operations instead of lookarounds * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-set-operation.html */ "regexp/prefer-set-operation"?: Linter.RuleEntry<[ ]>; /** * enforce using `*` quantifier * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-star-quantifier.html */ "regexp/prefer-star-quantifier"?: Linter.RuleEntry<[ ]>; /** * enforce use of unicode codepoint escapes * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-unicode-codepoint-escapes.html */ "regexp/prefer-unicode-codepoint-escapes"?: Linter.RuleEntry<[ ]>; /** * enforce using `\w` * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-w.html */ "regexp/prefer-w"?: Linter.RuleEntry<[ ]>; /** * enforce the use of the `u` flag * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/require-unicode-regexp.html */ "regexp/require-unicode-regexp"?: Linter.RuleEntry<[ ]>; /** * enforce the use of the `v` flag * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/require-unicode-sets-regexp.html */ "regexp/require-unicode-sets-regexp"?: Linter.RuleEntry<[ ]>; /** * require simplify set operations * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/simplify-set-operations.html */ "regexp/simplify-set-operations"?: Linter.RuleEntry<[ ]>; /** * sort alternatives if order doesn't matter * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/sort-alternatives.html */ "regexp/sort-alternatives"?: Linter.RuleEntry<[ ]>; /** * enforces elements order in character class * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/sort-character-class-elements.html */ "regexp/sort-character-class-elements"?: Linter.RuleEntry; /** * require regex flags to be sorted * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/sort-flags.html */ "regexp/sort-flags"?: Linter.RuleEntry<[ ]>; /** * disallow not strictly valid regular expressions * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/strict.html */ "regexp/strict"?: Linter.RuleEntry<[ ]>; /** * enforce consistent usage of unicode escape or unicode codepoint escape * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/unicode-escape.html */ "regexp/unicode-escape"?: Linter.RuleEntry; /** * enforce consistent naming of unicode properties * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/unicode-property.html */ "regexp/unicode-property"?: Linter.RuleEntry; /** * use the `i` flag if it simplifies the pattern * @see https://ota-meshi.github.io/eslint-plugin-regexp/rules/use-ignore-case.html */ "regexp/use-ignore-case"?: Linter.RuleEntry<[ ]>; /** * Alternatives in regular expressions should be grouped when used with anchors * @see https://sonarsource.github.io/rspec/#/rspec/S5850/javascript */ "sonarjs/anchor-precedence"?: Linter.RuleEntry<[ ]>; /** * Arguments to built-in functions should match documented types * @see https://sonarsource.github.io/rspec/#/rspec/S3782/javascript */ "sonarjs/argument-type"?: Linter.RuleEntry<[ ]>; /** * Parameters should be passed in the correct order * @see https://sonarsource.github.io/rspec/#/rspec/S2234/javascript */ "sonarjs/arguments-order"?: Linter.RuleEntry<[ ]>; /** * "arguments" should not be accessed directly * @see https://sonarsource.github.io/rspec/#/rspec/S3513/javascript */ "sonarjs/arguments-usage"?: Linter.RuleEntry<[ ]>; /** * Callbacks of array methods should have return statements * @see https://sonarsource.github.io/rspec/#/rspec/S3796/javascript */ "sonarjs/array-callback-without-return"?: Linter.RuleEntry<[ ]>; /** * Array constructors should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S1528/javascript */ "sonarjs/array-constructor"?: Linter.RuleEntry<[ ]>; /** * Braces and parentheses should be used consistently with arrow functions * @see https://sonarsource.github.io/rspec/#/rspec/S3524/javascript */ "sonarjs/arrow-function-convention"?: Linter.RuleEntry; /** * Tests should include assertions * @see https://sonarsource.github.io/rspec/#/rspec/S2699/javascript */ "sonarjs/assertions-in-tests"?: Linter.RuleEntry<[ ]>; /** * Creating public APIs is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6333/javascript */ "sonarjs/aws-apigateway-public-api"?: Linter.RuleEntry<[ ]>; /** * Allowing public network access to cloud resources is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6329/javascript */ "sonarjs/aws-ec2-rds-dms-public"?: Linter.RuleEntry<[ ]>; /** * Using unencrypted EBS volumes is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6275/javascript */ "sonarjs/aws-ec2-unencrypted-ebs-volume"?: Linter.RuleEntry<[ ]>; /** * Using unencrypted EFS file systems is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6332/javascript */ "sonarjs/aws-efs-unencrypted"?: Linter.RuleEntry<[ ]>; /** * Policies granting all privileges are security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6302/javascript */ "sonarjs/aws-iam-all-privileges"?: Linter.RuleEntry<[ ]>; /** * Policies granting access to all resources of an account are security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6304/javascript */ "sonarjs/aws-iam-all-resources-accessible"?: Linter.RuleEntry<[ ]>; /** * AWS IAM policies should limit the scope of permissions given * @see https://sonarsource.github.io/rspec/#/rspec/S6317/javascript */ "sonarjs/aws-iam-privilege-escalation"?: Linter.RuleEntry<[ ]>; /** * Policies authorizing public access to resources are security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6270/javascript */ "sonarjs/aws-iam-public-access"?: Linter.RuleEntry<[ ]>; /** * Using unencrypted Opensearch domains is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6308/javascript */ "sonarjs/aws-opensearchservice-domain"?: Linter.RuleEntry<[ ]>; /** * Using unencrypted RDS DB resources is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6303/javascript */ "sonarjs/aws-rds-unencrypted-databases"?: Linter.RuleEntry<[ ]>; /** * Administration services access should be restricted to specific IP addresses * @see https://sonarsource.github.io/rspec/#/rspec/S6321/javascript */ "sonarjs/aws-restricted-ip-admin-access"?: Linter.RuleEntry<[ ]>; /** * Granting access to S3 buckets to all or authenticated users is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6265/javascript */ "sonarjs/aws-s3-bucket-granted-access"?: Linter.RuleEntry<[ ]>; /** * Authorizing HTTP communications with S3 buckets is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6249/javascript */ "sonarjs/aws-s3-bucket-insecure-http"?: Linter.RuleEntry<[ ]>; /** * Allowing public ACLs or policies on a S3 bucket is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6281/javascript */ "sonarjs/aws-s3-bucket-public-access"?: Linter.RuleEntry<[ ]>; /** * Disabling server-side encryption of S3 buckets is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6245/javascript * @deprecated */ "sonarjs/aws-s3-bucket-server-encryption"?: Linter.RuleEntry<[ ]>; /** * Disabling versioning of S3 buckets is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6252/javascript */ "sonarjs/aws-s3-bucket-versioning"?: Linter.RuleEntry<[ ]>; /** * Using unencrypted SageMaker notebook instances is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6319/javascript */ "sonarjs/aws-sagemaker-unencrypted-notebook"?: Linter.RuleEntry<[ ]>; /** * Using unencrypted SNS topics is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6327/javascript */ "sonarjs/aws-sns-unencrypted-topics"?: Linter.RuleEntry<[ ]>; /** * Using unencrypted SQS queues is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6330/javascript */ "sonarjs/aws-sqs-unencrypted-queue"?: Linter.RuleEntry<[ ]>; /** * Bitwise operators should not be used in boolean contexts * @see https://sonarsource.github.io/rspec/#/rspec/S1529/javascript */ "sonarjs/bitwise-operators"?: Linter.RuleEntry<[ ]>; /** * Variables should be used in the blocks where they are declared * @see https://sonarsource.github.io/rspec/#/rspec/S2392/javascript */ "sonarjs/block-scoped-var"?: Linter.RuleEntry<[ ]>; /** * Optional boolean parameters should have default value * @see https://sonarsource.github.io/rspec/#/rspec/S4798/javascript */ "sonarjs/bool-param-default"?: Linter.RuleEntry<[ ]>; /** * Function call arguments should not start on new lines * @see https://sonarsource.github.io/rspec/#/rspec/S1472/javascript */ "sonarjs/call-argument-line"?: Linter.RuleEntry<[ ]>; /** * Disabling Certificate Transparency monitoring is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5742/javascript * @deprecated */ "sonarjs/certificate-transparency"?: Linter.RuleEntry<[ ]>; /** * Chai assertions should have only one reason to succeed * @see https://sonarsource.github.io/rspec/#/rspec/S6092/javascript */ "sonarjs/chai-determinate-assertion"?: Linter.RuleEntry<[ ]>; /** * Class names should comply with a naming convention * @see https://sonarsource.github.io/rspec/#/rspec/S101/javascript */ "sonarjs/class-name"?: Linter.RuleEntry; /** * Class methods should be used instead of "prototype" assignments * @see https://sonarsource.github.io/rspec/#/rspec/S3525/javascript */ "sonarjs/class-prototype"?: Linter.RuleEntry<[ ]>; /** * Cognitive Complexity of functions should not be too high * @see https://sonarsource.github.io/rspec/#/rspec/S3776/javascript */ "sonarjs/cognitive-complexity"?: Linter.RuleEntry; /** * Comma and logical OR operators should not be used in switch cases * @see https://sonarsource.github.io/rspec/#/rspec/S3616/javascript */ "sonarjs/comma-or-logical-or-case"?: Linter.RuleEntry<[ ]>; /** * Track comments matching a regular expression * @see https://sonarsource.github.io/rspec/#/rspec/S124/javascript */ "sonarjs/comment-regex"?: Linter.RuleEntry; /** * Regular expression quantifiers and character classes should be used concisely * @see https://sonarsource.github.io/rspec/#/rspec/S6353/javascript */ "sonarjs/concise-regex"?: Linter.RuleEntry<[ ]>; /** * A conditionally executed single line should be denoted by indentation * @see https://sonarsource.github.io/rspec/#/rspec/S3973/javascript * @deprecated */ "sonarjs/conditional-indentation"?: Linter.RuleEntry<[ ]>; /** * Allowing confidential information to be logged is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5757/javascript */ "sonarjs/confidential-information-logging"?: Linter.RuleEntry<[ ]>; /** * Objects should not be created to be dropped immediately without being used * @see https://sonarsource.github.io/rspec/#/rspec/S1848/javascript */ "sonarjs/constructor-for-side-effects"?: Linter.RuleEntry<[ ]>; /** * Allowing requests with excessive content length is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5693/javascript */ "sonarjs/content-length"?: Linter.RuleEntry; /** * Disabling content security policy fetch directives is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5728/javascript */ "sonarjs/content-security-policy"?: Linter.RuleEntry<[ ]>; /** * Creating cookies without the "HttpOnly" flag is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S3330/javascript */ "sonarjs/cookie-no-httponly"?: Linter.RuleEntry<[ ]>; /** * Writing cookies is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S2255/javascript * @deprecated */ "sonarjs/cookies"?: Linter.RuleEntry<[ ]>; /** * Having a permissive Cross-Origin Resource Sharing policy is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5122/javascript */ "sonarjs/cors"?: Linter.RuleEntry<[ ]>; /** * Disabling CSRF protections is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S4502/javascript */ "sonarjs/csrf"?: Linter.RuleEntry<[ ]>; /** * Cyclomatic Complexity of functions should not be too high * @see https://sonarsource.github.io/rspec/#/rspec/S1541/javascript */ "sonarjs/cyclomatic-complexity"?: Linter.RuleEntry; /** * Variables and functions should not be declared in the global scope * @see https://sonarsource.github.io/rspec/#/rspec/S3798/javascript */ "sonarjs/declarations-in-global-scope"?: Linter.RuleEntry<[ ]>; /** * Deprecated APIs should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S1874/javascript */ "sonarjs/deprecation"?: Linter.RuleEntry<[ ]>; /** * Destructuring syntax should be used for assignments * @see https://sonarsource.github.io/rspec/#/rspec/S3514/javascript */ "sonarjs/destructuring-assignment-syntax"?: Linter.RuleEntry<[ ]>; /** * Strict equality operators should not be used with dissimilar types * @see https://sonarsource.github.io/rspec/#/rspec/S3403/javascript */ "sonarjs/different-types-comparison"?: Linter.RuleEntry<[ ]>; /** * Disabling auto-escaping in template engines is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5247/javascript */ "sonarjs/disabled-auto-escaping"?: Linter.RuleEntry<[ ]>; /** * Using remote artifacts without integrity checks is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5725/javascript */ "sonarjs/disabled-resource-integrity"?: Linter.RuleEntry<[ ]>; /** * Disabling Mocha timeouts should be explicit * @see https://sonarsource.github.io/rspec/#/rspec/S6080/javascript */ "sonarjs/disabled-timeout"?: Linter.RuleEntry<[ ]>; /** * Allowing browsers to perform DNS prefetching is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5743/javascript * @deprecated */ "sonarjs/dns-prefetching"?: Linter.RuleEntry<[ ]>; /** * Character classes in regular expressions should not contain the same character twice * @see https://sonarsource.github.io/rspec/#/rspec/S5869/javascript */ "sonarjs/duplicates-in-character-class"?: Linter.RuleEntry<[ ]>; /** * Templates should not be constructed dynamically * @see https://sonarsource.github.io/rspec/#/rspec/S7790/javascript */ "sonarjs/dynamically-constructed-templates"?: Linter.RuleEntry<[ ]>; /** * "if ... else if" constructs should end with "else" clauses * @see https://sonarsource.github.io/rspec/#/rspec/S126/javascript */ "sonarjs/elseif-without-else"?: Linter.RuleEntry<[ ]>; /** * Repeated patterns in regular expressions should not match the empty string * @see https://sonarsource.github.io/rspec/#/rspec/S5842/javascript */ "sonarjs/empty-string-repetition"?: Linter.RuleEntry<[ ]>; /** * Encrypting data is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S4787/javascript * @deprecated */ "sonarjs/encryption"?: Linter.RuleEntry<[ ]>; /** * Encryption algorithms should be used with secure mode and padding scheme * @see https://sonarsource.github.io/rspec/#/rspec/S5542/javascript */ "sonarjs/encryption-secure-mode"?: Linter.RuleEntry<[ ]>; /** * Replacement strings should reference existing regular expression groups * @see https://sonarsource.github.io/rspec/#/rspec/S6328/javascript */ "sonarjs/existing-groups"?: Linter.RuleEntry<[ ]>; /** * Expressions should not be too complex * @see https://sonarsource.github.io/rspec/#/rspec/S1067/javascript */ "sonarjs/expression-complexity"?: Linter.RuleEntry; /** * Track lack of copyright and license headers * @see https://sonarsource.github.io/rspec/#/rspec/S1451/javascript */ "sonarjs/file-header"?: Linter.RuleEntry; /** * Default export names and file names should match * @see https://sonarsource.github.io/rspec/#/rspec/S3317/javascript */ "sonarjs/file-name-differ-from-class"?: Linter.RuleEntry<[ ]>; /** * Setting loose POSIX file permissions is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S2612/javascript */ "sonarjs/file-permissions"?: Linter.RuleEntry<[ ]>; /** * File uploads should be restricted * @see https://sonarsource.github.io/rspec/#/rspec/S2598/javascript */ "sonarjs/file-uploads"?: Linter.RuleEntry<[ ]>; /** * Track uses of "FIXME" tags * @see https://sonarsource.github.io/rspec/#/rspec/S1134/javascript */ "sonarjs/fixme-tag"?: Linter.RuleEntry<[ ]>; /** * "for...in" loops should filter properties before acting on them * @see https://sonarsource.github.io/rspec/#/rspec/S1535/javascript */ "sonarjs/for-in"?: Linter.RuleEntry<[ ]>; /** * A "for" loop update clause should move the counter in the right direction * @see https://sonarsource.github.io/rspec/#/rspec/S2251/javascript */ "sonarjs/for-loop-increment-sign"?: Linter.RuleEntry<[ ]>; /** * Disabling content security policy frame-ancestors directive is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5732/javascript */ "sonarjs/frame-ancestors"?: Linter.RuleEntry<[ ]>; /** * Functions should not be defined inside loops * @see https://sonarsource.github.io/rspec/#/rspec/S1515/javascript */ "sonarjs/function-inside-loop"?: Linter.RuleEntry<[ ]>; /** * Function and method names should comply with a naming convention * @see https://sonarsource.github.io/rspec/#/rspec/S100/javascript */ "sonarjs/function-name"?: Linter.RuleEntry; /** * Functions should always return the same type * @see https://sonarsource.github.io/rspec/#/rspec/S3800/javascript */ "sonarjs/function-return-type"?: Linter.RuleEntry<[ ]>; /** * Future reserved words should not be used as identifiers * @see https://sonarsource.github.io/rspec/#/rspec/S1527/javascript */ "sonarjs/future-reserved-words"?: Linter.RuleEntry<[ ]>; /** * Generators should explicitly "yield" a value * @see https://sonarsource.github.io/rspec/#/rspec/S3531/javascript */ "sonarjs/generator-without-yield"?: Linter.RuleEntry<[ ]>; /** * Credentials should not be hard-coded * @see https://sonarsource.github.io/rspec/#/rspec/S6437/javascript */ "sonarjs/hardcoded-secret-signatures"?: Linter.RuleEntry<[ ]>; /** * Using weak hashing algorithms is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S4790/javascript */ "sonarjs/hashing"?: Linter.RuleEntry<[ ]>; /** * Statically serving hidden files is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5691/javascript */ "sonarjs/hidden-files"?: Linter.RuleEntry<[ ]>; /** * "in" should not be used with primitive types * @see https://sonarsource.github.io/rspec/#/rspec/S3785/javascript */ "sonarjs/in-operator-type-error"?: Linter.RuleEntry<[ ]>; /** * Functions should be called consistently with or without "new" * @see https://sonarsource.github.io/rspec/#/rspec/S3686/javascript */ "sonarjs/inconsistent-function-call"?: Linter.RuleEntry<[ ]>; /** * "indexOf" checks should not be for positive numbers * @see https://sonarsource.github.io/rspec/#/rspec/S2692/javascript */ "sonarjs/index-of-compare-to-positive-number"?: Linter.RuleEntry<[ ]>; /** * Creating cookies without the "secure" flag is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S2092/javascript */ "sonarjs/insecure-cookie"?: Linter.RuleEntry<[ ]>; /** * JWT should be signed and verified with strong cipher algorithms * @see https://sonarsource.github.io/rspec/#/rspec/S5659/javascript */ "sonarjs/insecure-jwt-token"?: Linter.RuleEntry<[ ]>; /** * Assertion arguments should be passed in the correct order * @see https://sonarsource.github.io/rspec/#/rspec/S3415/javascript */ "sonarjs/inverted-assertion-arguments"?: Linter.RuleEntry<[ ]>; /** * React components should not render non-boolean condition values * @see https://sonarsource.github.io/rspec/#/rspec/S6439/javascript */ "sonarjs/jsx-no-leaked-render"?: Linter.RuleEntry<[ ]>; /** * Only "while", "do", "for" and "switch" statements should be labelled * @see https://sonarsource.github.io/rspec/#/rspec/S1439/javascript */ "sonarjs/label-position"?: Linter.RuleEntry<[ ]>; /** * Authorizing an opened window to access back to the originating window is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5148/javascript */ "sonarjs/link-with-target-blank"?: Linter.RuleEntry<[ ]>; /** * Files should not have too many lines of code * @see https://sonarsource.github.io/rspec/#/rspec/S104/javascript */ "sonarjs/max-lines"?: Linter.RuleEntry; /** * Functions should not have too many lines of code * @see https://sonarsource.github.io/rspec/#/rspec/S138/javascript */ "sonarjs/max-lines-per-function"?: Linter.RuleEntry; /** * "switch" statements should not have too many "case" clauses * @see https://sonarsource.github.io/rspec/#/rspec/S1479/javascript */ "sonarjs/max-switch-cases"?: Linter.RuleEntry; /** * Union types should not have too many elements * @see https://sonarsource.github.io/rspec/#/rspec/S4622/javascript */ "sonarjs/max-union-size"?: Linter.RuleEntry; /** * "for" loop increment clauses should modify the loops' counters * @see https://sonarsource.github.io/rspec/#/rspec/S1994/javascript */ "sonarjs/misplaced-loop-counter"?: Linter.RuleEntry<[ ]>; /** * Control flow statements "if", "for", "while", "switch" and "try" should not be nested too deeply * @see https://sonarsource.github.io/rspec/#/rspec/S134/javascript */ "sonarjs/nested-control-flow"?: Linter.RuleEntry; /** * "new" should only be used with functions and classes * @see https://sonarsource.github.io/rspec/#/rspec/S2999/javascript */ "sonarjs/new-operator-misuse"?: Linter.RuleEntry; /** * All branches in a conditional structure should not have exactly the same implementation * @see https://sonarsource.github.io/rspec/#/rspec/S3923/javascript */ "sonarjs/no-all-duplicated-branches"?: Linter.RuleEntry<[ ]>; /** * "Array.prototype.sort()" and "Array.prototype.toSorted()" should use a compare function * @see https://sonarsource.github.io/rspec/#/rspec/S2871/javascript */ "sonarjs/no-alphabetical-sort"?: Linter.RuleEntry<[ ]>; /** * Disabling Angular built-in sanitization is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6268/javascript */ "sonarjs/no-angular-bypass-sanitization"?: Linter.RuleEntry<[ ]>; /** * "delete" should not be used on arrays * @see https://sonarsource.github.io/rspec/#/rspec/S2870/javascript */ "sonarjs/no-array-delete"?: Linter.RuleEntry<[ ]>; /** * Array indexes should be numeric * @see https://sonarsource.github.io/rspec/#/rspec/S3579/javascript */ "sonarjs/no-associative-arrays"?: Linter.RuleEntry<[ ]>; /** * Constructors should not contain asynchronous operations * @see https://sonarsource.github.io/rspec/#/rspec/S7059/javascript */ "sonarjs/no-async-constructor"?: Linter.RuleEntry<[ ]>; /** * Built-in objects should not be overridden * @see https://sonarsource.github.io/rspec/#/rspec/S2424/javascript */ "sonarjs/no-built-in-override"?: Linter.RuleEntry<[ ]>; /** * "switch" statements should not contain non-case labels * @see https://sonarsource.github.io/rspec/#/rspec/S1219/javascript */ "sonarjs/no-case-label-in-switch"?: Linter.RuleEntry<[ ]>; /** * Using clear-text protocols is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5332/javascript */ "sonarjs/no-clear-text-protocols"?: Linter.RuleEntry<[ ]>; /** * Tests should not execute any code after "done()" is called * @see https://sonarsource.github.io/rspec/#/rspec/S6079/javascript */ "sonarjs/no-code-after-done"?: Linter.RuleEntry<[ ]>; /** * Mergeable "if" statements should be combined * @see https://sonarsource.github.io/rspec/#/rspec/S1066/javascript */ "sonarjs/no-collapsible-if"?: Linter.RuleEntry<[ ]>; /** * Collection size and array length comparisons should make sense * @see https://sonarsource.github.io/rspec/#/rspec/S3981/javascript */ "sonarjs/no-collection-size-mischeck"?: Linter.RuleEntry<[ ]>; /** * Sections of code should not be commented out * @see https://sonarsource.github.io/rspec/#/rspec/S125/javascript */ "sonarjs/no-commented-code"?: Linter.RuleEntry<[ ]>; /** * Regular expressions should not contain control characters * @see https://sonarsource.github.io/rspec/#/rspec/S6324/javascript */ "sonarjs/no-control-regex"?: Linter.RuleEntry<[ ]>; /** * Unused assignments should be removed * @see https://sonarsource.github.io/rspec/#/rspec/S1854/javascript */ "sonarjs/no-dead-store"?: Linter.RuleEntry<[ ]>; /** * "delete" should be used only with object properties * @see https://sonarsource.github.io/rspec/#/rspec/S3001/javascript */ "sonarjs/no-delete-var"?: Linter.RuleEntry<[ ]>; /** * Union and intersection types should not include duplicated constituents * @see https://sonarsource.github.io/rspec/#/rspec/S4621/javascript */ "sonarjs/no-duplicate-in-composite"?: Linter.RuleEntry<[ ]>; /** * String literals should not be duplicated * @see https://sonarsource.github.io/rspec/#/rspec/S1192/javascript */ "sonarjs/no-duplicate-string"?: Linter.RuleEntry; /** * Two branches in a conditional structure should not have exactly the same implementation * @see https://sonarsource.github.io/rspec/#/rspec/S1871/javascript */ "sonarjs/no-duplicated-branches"?: Linter.RuleEntry<[ ]>; /** * Collection elements should not be replaced unconditionally * @see https://sonarsource.github.io/rspec/#/rspec/S4143/javascript */ "sonarjs/no-element-overwrite"?: Linter.RuleEntry<[ ]>; /** * Reluctant quantifiers in regular expressions should be followed by an expression that can't match the empty string * @see https://sonarsource.github.io/rspec/#/rspec/S6019/javascript */ "sonarjs/no-empty-after-reluctant"?: Linter.RuleEntry<[ ]>; /** * Alternation in regular expressions should not contain empty alternatives * @see https://sonarsource.github.io/rspec/#/rspec/S6323/javascript */ "sonarjs/no-empty-alternatives"?: Linter.RuleEntry<[ ]>; /** * Empty character classes should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S2639/javascript */ "sonarjs/no-empty-character-class"?: Linter.RuleEntry<[ ]>; /** * Empty collections should not be accessed or iterated * @see https://sonarsource.github.io/rspec/#/rspec/S4158/javascript */ "sonarjs/no-empty-collection"?: Linter.RuleEntry<[ ]>; /** * Regular expressions should not contain empty groups * @see https://sonarsource.github.io/rspec/#/rspec/S6331/javascript */ "sonarjs/no-empty-group"?: Linter.RuleEntry<[ ]>; /** * Test files should contain at least one test case * @see https://sonarsource.github.io/rspec/#/rspec/S2187/javascript */ "sonarjs/no-empty-test-file"?: Linter.RuleEntry<[ ]>; /** * Equality operators should not be used in "for" loop termination conditions * @see https://sonarsource.github.io/rspec/#/rspec/S888/javascript */ "sonarjs/no-equals-in-for-termination"?: Linter.RuleEntry<[ ]>; /** * Exclusive tests should not be committed to version control * @see https://sonarsource.github.io/rspec/#/rspec/S6426/javascript */ "sonarjs/no-exclusive-tests"?: Linter.RuleEntry<[ ]>; /** * Function calls should not pass extra arguments * @see https://sonarsource.github.io/rspec/#/rspec/S930/javascript */ "sonarjs/no-extra-arguments"?: Linter.RuleEntry<[ ]>; /** * Switch cases should end with an unconditional "break" statement * @see https://sonarsource.github.io/rspec/#/rspec/S128/javascript */ "sonarjs/no-fallthrough"?: Linter.RuleEntry<[ ]>; /** * "for in" should not be used with iterables * @see https://sonarsource.github.io/rspec/#/rspec/S4139/javascript */ "sonarjs/no-for-in-iterable"?: Linter.RuleEntry<[ ]>; /** * Function declarations should not be made within blocks * @see https://sonarsource.github.io/rspec/#/rspec/S1530/javascript */ "sonarjs/no-function-declaration-in-block"?: Linter.RuleEntry<[ ]>; /** * The global "this" object should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S2990/javascript */ "sonarjs/no-global-this"?: Linter.RuleEntry<[ ]>; /** * Special identifiers should not be bound or assigned * @see https://sonarsource.github.io/rspec/#/rspec/S2137/javascript */ "sonarjs/no-globals-shadowing"?: Linter.RuleEntry<[ ]>; /** * Boolean expressions should not be gratuitous * @see https://sonarsource.github.io/rspec/#/rspec/S2589/javascript */ "sonarjs/no-gratuitous-expressions"?: Linter.RuleEntry<[ ]>; /** * Using hardcoded IP addresses is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S1313/javascript */ "sonarjs/no-hardcoded-ip"?: Linter.RuleEntry<[ ]>; /** * Credentials should not be hard-coded * @see https://sonarsource.github.io/rspec/#/rspec/S2068/javascript */ "sonarjs/no-hardcoded-passwords"?: Linter.RuleEntry; /** * Secrets should not be hard-coded * @see https://sonarsource.github.io/rspec/#/rspec/S6418/javascript */ "sonarjs/no-hardcoded-secrets"?: Linter.RuleEntry; /** * React's useState hook should not be used directly in the render function or body of a component * @see https://sonarsource.github.io/rspec/#/rspec/S6442/javascript */ "sonarjs/no-hook-setter-in-body"?: Linter.RuleEntry<[ ]>; /** * "if/else if" chains and "switch" cases should not have the same condition * @see https://sonarsource.github.io/rspec/#/rspec/S1862/javascript */ "sonarjs/no-identical-conditions"?: Linter.RuleEntry<[ ]>; /** * Identical expressions should not be used on both sides of a binary operator * @see https://sonarsource.github.io/rspec/#/rspec/S1764/javascript */ "sonarjs/no-identical-expressions"?: Linter.RuleEntry<[ ]>; /** * Functions should not have identical implementations * @see https://sonarsource.github.io/rspec/#/rspec/S4144/javascript */ "sonarjs/no-identical-functions"?: Linter.RuleEntry; /** * Exceptions should not be ignored * @see https://sonarsource.github.io/rspec/#/rspec/S2486/javascript */ "sonarjs/no-ignored-exceptions"?: Linter.RuleEntry<[ ]>; /** * Return values from functions without side effects should not be ignored * @see https://sonarsource.github.io/rspec/#/rspec/S2201/javascript */ "sonarjs/no-ignored-return"?: Linter.RuleEntry<[ ]>; /** * Dependencies should be explicit * @see https://sonarsource.github.io/rspec/#/rspec/S4328/javascript */ "sonarjs/no-implicit-dependencies"?: Linter.RuleEntry; /** * Variables should be declared explicitly * @see https://sonarsource.github.io/rspec/#/rspec/S2703/javascript */ "sonarjs/no-implicit-global"?: Linter.RuleEntry<[ ]>; /** * "in" should not be used on arrays * @see https://sonarsource.github.io/rspec/#/rspec/S4619/javascript */ "sonarjs/no-in-misuse"?: Linter.RuleEntry<[ ]>; /** * Assertions should be complete * @see https://sonarsource.github.io/rspec/#/rspec/S2970/javascript */ "sonarjs/no-incomplete-assertions"?: Linter.RuleEntry<[ ]>; /** * Functions should use "return" consistently * @see https://sonarsource.github.io/rspec/#/rspec/S3801/javascript */ "sonarjs/no-inconsistent-returns"?: Linter.RuleEntry<[ ]>; /** * Strings and non-strings should not be added * @see https://sonarsource.github.io/rspec/#/rspec/S3402/javascript */ "sonarjs/no-incorrect-string-concat"?: Linter.RuleEntry<[ ]>; /** * Users should not use internal APIs * @see https://sonarsource.github.io/rspec/#/rspec/S6627/javascript */ "sonarjs/no-internal-api-use"?: Linter.RuleEntry<[ ]>; /** * Using intrusive permissions is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5604/javascript */ "sonarjs/no-intrusive-permissions"?: Linter.RuleEntry; /** * Regular expressions should be syntactically valid * @see https://sonarsource.github.io/rspec/#/rspec/S5856/javascript */ "sonarjs/no-invalid-regexp"?: Linter.RuleEntry<[ ]>; /** * Function returns should not be invariant * @see https://sonarsource.github.io/rspec/#/rspec/S3516/javascript */ "sonarjs/no-invariant-returns"?: Linter.RuleEntry<[ ]>; /** * Boolean checks should not be inverted * @see https://sonarsource.github.io/rspec/#/rspec/S1940/javascript */ "sonarjs/no-inverted-boolean-check"?: Linter.RuleEntry<[ ]>; /** * Forwarding client IP address is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5759/javascript */ "sonarjs/no-ip-forward"?: Linter.RuleEntry<[ ]>; /** * Labels should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S1119/javascript */ "sonarjs/no-labels"?: Linter.RuleEntry<[ ]>; /** * Literals should not be used as functions * @see https://sonarsource.github.io/rspec/#/rspec/S6958/javascript */ "sonarjs/no-literal-call"?: Linter.RuleEntry<[ ]>; /** * Allowing browsers to sniff MIME types is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5734/javascript */ "sonarjs/no-mime-sniff"?: Linter.RuleEntry<[ ]>; /** * Array-mutating methods should not be used misleadingly * @see https://sonarsource.github.io/rspec/#/rspec/S4043/javascript */ "sonarjs/no-misleading-array-reverse"?: Linter.RuleEntry<[ ]>; /** * Unicode Grapheme Clusters should be avoided inside regex character classes * @see https://sonarsource.github.io/rspec/#/rspec/S5868/javascript */ "sonarjs/no-misleading-character-class"?: Linter.RuleEntry<[ ]>; /** * Allowing mixed-content is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5730/javascript */ "sonarjs/no-mixed-content"?: Linter.RuleEntry<[ ]>; /** * Assignments should not be made from within sub-expressions * @see https://sonarsource.github.io/rspec/#/rspec/S1121/javascript */ "sonarjs/no-nested-assignment"?: Linter.RuleEntry<[ ]>; /** * Ternary operators should not be nested * @see https://sonarsource.github.io/rspec/#/rspec/S3358/javascript */ "sonarjs/no-nested-conditional"?: Linter.RuleEntry<[ ]>; /** * Functions should not be nested too deeply * @see https://sonarsource.github.io/rspec/#/rspec/S2004/javascript */ "sonarjs/no-nested-functions"?: Linter.RuleEntry; /** * Increment (++) and decrement (--) operators should not be used in a method call or mixed with other operators in an expression * @see https://sonarsource.github.io/rspec/#/rspec/S881/javascript */ "sonarjs/no-nested-incdec"?: Linter.RuleEntry<[ ]>; /** * "switch" statements should not be nested * @see https://sonarsource.github.io/rspec/#/rspec/S1821/javascript */ "sonarjs/no-nested-switch"?: Linter.RuleEntry<[ ]>; /** * Template literals should not be nested * @see https://sonarsource.github.io/rspec/#/rspec/S4624/javascript */ "sonarjs/no-nested-template-literals"?: Linter.RuleEntry<[ ]>; /** * Searching OS commands in PATH is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S4036/javascript */ "sonarjs/no-os-command-from-path"?: Linter.RuleEntry<[ ]>; /** * Initial values of parameters, caught exceptions, and loop variables should not be ignored * @see https://sonarsource.github.io/rspec/#/rspec/S1226/javascript */ "sonarjs/no-parameter-reassignment"?: Linter.RuleEntry<[ ]>; /** * Wrapper objects should not be used for primitive types * @see https://sonarsource.github.io/rspec/#/rspec/S1533/javascript */ "sonarjs/no-primitive-wrappers"?: Linter.RuleEntry<[ ]>; /** * Assignments should not be redundant * @see https://sonarsource.github.io/rspec/#/rspec/S4165/javascript */ "sonarjs/no-redundant-assignments"?: Linter.RuleEntry<[ ]>; /** * Boolean literals should not be used in comparisons * @see https://sonarsource.github.io/rspec/#/rspec/S1125/javascript */ "sonarjs/no-redundant-boolean"?: Linter.RuleEntry<[ ]>; /** * Jump statements should not be redundant * @see https://sonarsource.github.io/rspec/#/rspec/S3626/javascript */ "sonarjs/no-redundant-jump"?: Linter.RuleEntry<[ ]>; /** * Optional property declarations should not use both '?' and 'undefined' syntax * @see https://sonarsource.github.io/rspec/#/rspec/S4782/javascript */ "sonarjs/no-redundant-optional"?: Linter.RuleEntry<[ ]>; /** * Redundant pairs of parentheses should be removed * @see https://sonarsource.github.io/rspec/#/rspec/S1110/javascript * @deprecated */ "sonarjs/no-redundant-parentheses"?: Linter.RuleEntry<[ ]>; /** * Variables should be defined before being used * @see https://sonarsource.github.io/rspec/#/rspec/S3827/javascript */ "sonarjs/no-reference-error"?: Linter.RuleEntry<[ ]>; /** * Disabling strict HTTP no-referrer policy is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5736/javascript */ "sonarjs/no-referrer-policy"?: Linter.RuleEntry<[ ]>; /** * Regular expressions should not contain multiple spaces * @see https://sonarsource.github.io/rspec/#/rspec/S6326/javascript */ "sonarjs/no-regex-spaces"?: Linter.RuleEntry<[ ]>; /** * "import" should be used to include external code * @see https://sonarsource.github.io/rspec/#/rspec/S3533/javascript */ "sonarjs/no-require-or-define"?: Linter.RuleEntry<[ ]>; /** * Primitive return types should be used * @see https://sonarsource.github.io/rspec/#/rspec/S4324/javascript */ "sonarjs/no-return-type-any"?: Linter.RuleEntry<[ ]>; /** * Assertions should not be given twice the same argument * @see https://sonarsource.github.io/rspec/#/rspec/S5863/javascript */ "sonarjs/no-same-argument-assert"?: Linter.RuleEntry<[ ]>; /** * Conditionals should start on new lines * @see https://sonarsource.github.io/rspec/#/rspec/S3972/javascript */ "sonarjs/no-same-line-conditional"?: Linter.RuleEntry<[ ]>; /** * Methods should not contain selector parameters * @see https://sonarsource.github.io/rspec/#/rspec/S2301/javascript */ "sonarjs/no-selector-parameter"?: Linter.RuleEntry<[ ]>; /** * Static Assets should not serve session cookies * @see https://sonarsource.github.io/rspec/#/rspec/S8441/javascript */ "sonarjs/no-session-cookies-on-static-assets"?: Linter.RuleEntry<[ ]>; /** * Tests should not be skipped without providing a reason * @see https://sonarsource.github.io/rspec/#/rspec/S1607/javascript */ "sonarjs/no-skipped-tests"?: Linter.RuleEntry<[ ]>; /** * "if" statements should be preferred over "switch" when simpler * @see https://sonarsource.github.io/rspec/#/rspec/S1301/javascript */ "sonarjs/no-small-switch"?: Linter.RuleEntry<[ ]>; /** * Track uses of "NOSONAR" comments * @see https://sonarsource.github.io/rspec/#/rspec/S1291/javascript */ "sonarjs/no-sonar-comments"?: Linter.RuleEntry<[ ]>; /** * Tabulation characters should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S105/javascript * @deprecated */ "sonarjs/no-tab"?: Linter.RuleEntry<[ ]>; /** * HTML "" should not be used for layout purposes * @see https://sonarsource.github.io/rspec/#/rspec/S5257/javascript */ "sonarjs/no-table-as-layout"?: Linter.RuleEntry<[ ]>; /** * Promise rejections should not be caught by "try" blocks * @see https://sonarsource.github.io/rspec/#/rspec/S4822/javascript */ "sonarjs/no-try-promise"?: Linter.RuleEntry<[ ]>; /** * "undefined" should not be passed as the value of optional parameters * @see https://sonarsource.github.io/rspec/#/rspec/S4623/javascript */ "sonarjs/no-undefined-argument"?: Linter.RuleEntry<[ ]>; /** * "undefined" should not be assigned * @see https://sonarsource.github.io/rspec/#/rspec/S2138/javascript */ "sonarjs/no-undefined-assignment"?: Linter.RuleEntry<[ ]>; /** * Multiline blocks should be enclosed in curly braces * @see https://sonarsource.github.io/rspec/#/rspec/S2681/javascript */ "sonarjs/no-unenclosed-multiline-block"?: Linter.RuleEntry<[ ]>; /** * JSX list components keys should match up between renders * @see https://sonarsource.github.io/rspec/#/rspec/S6486/javascript */ "sonarjs/no-uniq-key"?: Linter.RuleEntry<[ ]>; /** * Expanding archive files without controlling resource consumption is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S5042/javascript */ "sonarjs/no-unsafe-unzip"?: Linter.RuleEntry<[ ]>; /** * Errors should not be created without being thrown * @see https://sonarsource.github.io/rspec/#/rspec/S3984/javascript */ "sonarjs/no-unthrown-error"?: Linter.RuleEntry<[ ]>; /** * Collection contents should be used * @see https://sonarsource.github.io/rspec/#/rspec/S4030/javascript */ "sonarjs/no-unused-collection"?: Linter.RuleEntry<[ ]>; /** * Unused function parameters should be removed * @see https://sonarsource.github.io/rspec/#/rspec/S1172/javascript */ "sonarjs/no-unused-function-argument"?: Linter.RuleEntry<[ ]>; /** * Unused local variables and functions should be removed * @see https://sonarsource.github.io/rspec/#/rspec/S1481/javascript */ "sonarjs/no-unused-vars"?: Linter.RuleEntry<[ ]>; /** * The return value of void functions should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S3699/javascript */ "sonarjs/no-use-of-empty-return-value"?: Linter.RuleEntry<[ ]>; /** * "catch" clauses should do more than rethrow * @see https://sonarsource.github.io/rspec/#/rspec/S2737/javascript */ "sonarjs/no-useless-catch"?: Linter.RuleEntry<[ ]>; /** * Values should not be uselessly incremented * @see https://sonarsource.github.io/rspec/#/rspec/S2123/javascript */ "sonarjs/no-useless-increment"?: Linter.RuleEntry<[ ]>; /** * Type intersections should use meaningful types * @see https://sonarsource.github.io/rspec/#/rspec/S4335/javascript */ "sonarjs/no-useless-intersection"?: Linter.RuleEntry<[ ]>; /** * React state setter function should not be called with its matching state variable * @see https://sonarsource.github.io/rspec/#/rspec/S6443/javascript */ "sonarjs/no-useless-react-setstate"?: Linter.RuleEntry<[ ]>; /** * Variables declared with "var" should be declared before they are used * @see https://sonarsource.github.io/rspec/#/rspec/S1526/javascript */ "sonarjs/no-variable-usage-before-declaration"?: Linter.RuleEntry<[ ]>; /** * Disabling Vue.js built-in escaping is security-sensitive * @see https://sonarsource.github.io/rspec/#/rspec/S6299/javascript * @deprecated */ "sonarjs/no-vue-bypass-sanitization"?: Linter.RuleEntry<[ ]>; /** * Cipher algorithms should be robust * @see https://sonarsource.github.io/rspec/#/rspec/S5547/javascript */ "sonarjs/no-weak-cipher"?: Linter.RuleEntry<[ ]>; /** * Cryptographic keys should be robust * @see https://sonarsource.github.io/rspec/#/rspec/S4426/javascript */ "sonarjs/no-weak-keys"?: Linter.RuleEntry<[ ]>; /** * Wildcard imports should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S2208/javascript */ "sonarjs/no-wildcard-import"?: Linter.RuleEntry<[ ]>; /** * Non-existent operators '=+', '=-' and '=!' should not be used * @see https://sonarsource.github.io/rspec/#/rspec/S2757/javascript */ "sonarjs/non-existent-operator"?: Linter.RuleEntry<[ ]>; /** * Arithmetic operators should only have numbers as operands * @see https://sonarsource.github.io/rspec/#/rspec/S3760/javascript */ "sonarjs/non-number-in-arithmetic-expression"?: Linter.RuleEntry<[ ]>; /** * Properties of variables with "null" or "undefined" values should not be accessed * @see https://sonarsource.github.io/rspec/#/rspec/S2259/javascript */ "sonarjs/null-dereference"?: Linter.RuleEntry<[ ]>; /** * "