@so1ve/eslint-config

import { ParserOptions } from '@typescript-eslint/utils/ts-eslint'; import { Linter } from 'eslint'; import { FlatGitignoreOptions } from 'eslint-config-flat-gitignore'; import { FlatConfigComposer } from 'eslint-flat-config-utils'; /* eslint-disable */ /* prettier-ignore */ interface RuleOptions { /** * Enforce getter and setter pairs in objects and classes * @see https://eslint.org/docs/latest/rules/accessor-pairs */ 'accessor-pairs'?: Linter.RuleEntry<AccessorPairs> /** * Enforce linebreaks after opening and before closing array brackets * @see https://eslint.org/docs/latest/rules/array-bracket-newline * @deprecated */ 'array-bracket-newline'?: Linter.RuleEntry<ArrayBracketNewline> /** * Enforce consistent spacing inside array brackets * @see https://eslint.org/docs/latest/rules/array-bracket-spacing * @deprecated */ 'array-bracket-spacing'?: Linter.RuleEntry<ArrayBracketSpacing> /** * Enforce `return` statements in callbacks of array methods * @see https://eslint.org/docs/latest/rules/array-callback-return */ 'array-callback-return'?: Linter.RuleEntry<ArrayCallbackReturn> /** * Enforce line breaks after each array element * @see https://eslint.org/docs/latest/rules/array-element-newline * @deprecated */ 'array-element-newline'?: Linter.RuleEntry<ArrayElementNewline> /** * Prefer methods operating from the right over reversing the array */ 'array-func/avoid-reverse'?: Linter.RuleEntry<[]> /** * Prefer using the mapFn callback of Array.from over an immediate .map() call. */ 'array-func/from-map'?: Linter.RuleEntry<[]> /** * Avoid the this parameter when providing arrow function as callback in array functions. */ 'array-func/no-unnecessary-this-arg'?: Linter.RuleEntry<[]> /** * Prefer using Array.from over spreading an iterable in an array literal. Using Array.from also preserves the original type of TypedArrays while mapping. */ 'array-func/prefer-array-from'?: Linter.RuleEntry<[]> /** * Prefer using .flat() over concatenating to flatten an array. */ 'array-func/prefer-flat'?: Linter.RuleEntry<[]> /** * Prefer using the flatMap over an immediate .flat() call after a .map(). */ 'array-func/prefer-flat-map'?: Linter.RuleEntry<[]> /** * Require braces around arrow function bodies * @see https://eslint.org/docs/latest/rules/arrow-body-style */ 'arrow-body-style'?: Linter.RuleEntry<ArrowBodyStyle> /** * Require parentheses around arrow function arguments * @see https://eslint.org/docs/latest/rules/arrow-parens * @deprecated */ 'arrow-parens'?: Linter.RuleEntry<ArrowParens> /** * Enforce consistent spacing before and after the arrow in arrow functions * @see https://eslint.org/docs/latest/rules/arrow-spacing * @deprecated */ 'arrow-spacing'?: Linter.RuleEntry<ArrowSpacing> /** * Enforce the use of variables within the scope they are defined * @see https://eslint.org/docs/latest/rules/block-scoped-var */ 'block-scoped-var'?: Linter.RuleEntry<[]> /** * Disallow or enforce spaces inside of blocks after opening block and before closing block * @see https://eslint.org/docs/latest/rules/block-spacing * @deprecated */ 'block-spacing'?: Linter.RuleEntry<BlockSpacing> /** * Enforce consistent brace style for blocks * @see https://eslint.org/docs/latest/rules/brace-style * @deprecated */ 'brace-style'?: Linter.RuleEntry<BraceStyle> /** * Require `return` statements after callbacks * @see https://eslint.org/docs/latest/rules/callback-return * @deprecated */ 'callback-return'?: Linter.RuleEntry<CallbackReturn> /** * Enforce camelcase naming convention * @see https://eslint.org/docs/latest/rules/camelcase */ 'camelcase'?: Linter.RuleEntry<Camelcase> /** * Enforce or disallow capitalization of the first letter of a comment * @see https://eslint.org/docs/latest/rules/capitalized-comments */ 'capitalized-comments'?: Linter.RuleEntry<CapitalizedComments> /** * Enforce that class methods utilize `this` * @see https://eslint.org/docs/latest/rules/class-methods-use-this */ 'class-methods-use-this'?: Linter.RuleEntry<ClassMethodsUseThis> /** * Require or disallow trailing commas * @see https://eslint.org/docs/latest/rules/comma-dangle * @deprecated */ 'comma-dangle'?: Linter.RuleEntry<CommaDangle> /** * Enforce consistent spacing before and after commas * @see https://eslint.org/docs/latest/rules/comma-spacing * @deprecated */ 'comma-spacing'?: Linter.RuleEntry<CommaSpacing> /** * Enforce consistent comma style * @see https://eslint.org/docs/latest/rules/comma-style * @deprecated */ 'comma-style'?: Linter.RuleEntry<CommaStyle> /** * Enforce a maximum cyclomatic complexity allowed in a program * @see https://eslint.org/docs/latest/rules/complexity */ 'complexity'?: Linter.RuleEntry<Complexity> /** * Enforce consistent spacing inside computed property brackets * @see https://eslint.org/docs/latest/rules/computed-property-spacing * @deprecated */ 'computed-property-spacing'?: Linter.RuleEntry<ComputedPropertySpacing> /** * Require `return` statements to either always or never specify values * @see https://eslint.org/docs/latest/rules/consistent-return */ 'consistent-return'?: Linter.RuleEntry<ConsistentReturn> /** * Enforce consistent naming when capturing the current execution context * @see https://eslint.org/docs/latest/rules/consistent-this */ 'consistent-this'?: Linter.RuleEntry<ConsistentThis> /** * Require `super()` calls in constructors * @see https://eslint.org/docs/latest/rules/constructor-super */ 'constructor-super'?: Linter.RuleEntry<[]> /** * Enforce consistent brace style for all control statements * @see https://eslint.org/docs/latest/rules/curly */ 'curly'?: Linter.RuleEntry<Curly> /** * Require `default` cases in `switch` statements * @see https://eslint.org/docs/latest/rules/default-case */ 'default-case'?: Linter.RuleEntry<DefaultCase> /** * Enforce default clauses in switch statements to be last * @see https://eslint.org/docs/latest/rules/default-case-last */ 'default-case-last'?: Linter.RuleEntry<[]> /** * Enforce default parameters to be last * @see https://eslint.org/docs/latest/rules/default-param-last */ 'default-param-last'?: Linter.RuleEntry<[]> /** * Enforce consistent newlines before and after dots * @see https://eslint.org/docs/latest/rules/dot-location * @deprecated */ 'dot-location'?: Linter.RuleEntry<DotLocation> /** * Enforce dot notation whenever possible * @see https://eslint.org/docs/latest/rules/dot-notation */ 'dot-notation'?: Linter.RuleEntry<DotNotation> /** * Require or disallow newline at the end of files * @see https://eslint.org/docs/latest/rules/eol-last * @deprecated */ 'eol-last'?: Linter.RuleEntry<EolLast> /** * Require the use of `===` and `!==` * @see https://eslint.org/docs/latest/rules/eqeqeq */ 'eqeqeq'?: Linter.RuleEntry<Eqeqeq> /** * require a `eslint-enable` comment for every `eslint-disable` comment * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/disable-enable-pair.html */ 'eslint-comments/disable-enable-pair'?: Linter.RuleEntry<EslintCommentsDisableEnablePair> /** * disallow a `eslint-enable` comment for multiple `eslint-disable` comments * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-aggregating-enable.html */ 'eslint-comments/no-aggregating-enable'?: Linter.RuleEntry<[]> /** * disallow duplicate `eslint-disable` comments * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-duplicate-disable.html */ 'eslint-comments/no-duplicate-disable'?: Linter.RuleEntry<[]> /** * disallow `eslint-disable` comments about specific rules * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-restricted-disable.html */ 'eslint-comments/no-restricted-disable'?: Linter.RuleEntry<EslintCommentsNoRestrictedDisable> /** * disallow `eslint-disable` comments without rule names * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-unlimited-disable.html */ 'eslint-comments/no-unlimited-disable'?: Linter.RuleEntry<[]> /** * disallow unused `eslint-disable` comments * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-unused-disable.html */ 'eslint-comments/no-unused-disable'?: Linter.RuleEntry<[]> /** * disallow unused `eslint-enable` comments * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-unused-enable.html */ 'eslint-comments/no-unused-enable'?: Linter.RuleEntry<[]> /** * disallow ESLint directive-comments * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-use.html */ 'eslint-comments/no-use'?: Linter.RuleEntry<EslintCommentsNoUse> /** * require include descriptions in ESLint directive-comments * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/require-description.html */ 'eslint-comments/require-description'?: Linter.RuleEntry<EslintCommentsRequireDescription> /** * Enforce "for" loop update clause moving the counter in the right direction * @see https://eslint.org/docs/latest/rules/for-direction */ 'for-direction'?: Linter.RuleEntry<[]> /** * Require or disallow spacing between function identifiers and their invocations * @see https://eslint.org/docs/latest/rules/func-call-spacing * @deprecated */ 'func-call-spacing'?: Linter.RuleEntry<FuncCallSpacing> /** * Require function names to match the name of the variable or property to which they are assigned * @see https://eslint.org/docs/latest/rules/func-name-matching */ 'func-name-matching'?: Linter.RuleEntry<FuncNameMatching> /** * Require or disallow named `function` expressions * @see https://eslint.org/docs/latest/rules/func-names */ 'func-names'?: Linter.RuleEntry<FuncNames> /** * Enforce the consistent use of either `function` declarations or expressions assigned to variables * @see https://eslint.org/docs/latest/rules/func-style */ 'func-style'?: Linter.RuleEntry<FuncStyle> /** * Enforce line breaks between arguments of a function call * @see https://eslint.org/docs/latest/rules/function-call-argument-newline * @deprecated */ 'function-call-argument-newline'?: Linter.RuleEntry<FunctionCallArgumentNewline> /** * Enforce consistent line breaks inside function parentheses * @see https://eslint.org/docs/latest/rules/function-paren-newline * @deprecated */ 'function-paren-newline'?: Linter.RuleEntry<FunctionParenNewline> /** * Enforce consistent spacing around `*` operators in generator functions * @see https://eslint.org/docs/latest/rules/generator-star-spacing * @deprecated */ 'generator-star-spacing'?: Linter.RuleEntry<GeneratorStarSpacing> /** * Enforce `return` statements in getters * @see https://eslint.org/docs/latest/rules/getter-return */ 'getter-return'?: Linter.RuleEntry<GetterReturn> /** * Require `require()` calls to be placed at top-level module scope * @see https://eslint.org/docs/latest/rules/global-require * @deprecated */ 'global-require'?: Linter.RuleEntry<[]> /** * Require grouped accessor pairs in object literals and classes * @see https://eslint.org/docs/latest/rules/grouped-accessor-pairs */ 'grouped-accessor-pairs'?: Linter.RuleEntry<GroupedAccessorPairs> /** * Require `for-in` loops to include an `if` statement * @see https://eslint.org/docs/latest/rules/guard-for-in */ 'guard-for-in'?: Linter.RuleEntry<[]> /** * Require error handling in callbacks * @see https://eslint.org/docs/latest/rules/handle-callback-err * @deprecated */ 'handle-callback-err'?: Linter.RuleEntry<HandleCallbackErr> /** * Enforce newline between elements. */ 'html/element-newline'?: Linter.RuleEntry<HtmlElementNewline> /** * Enforce consistent naming id attributes */ 'html/id-naming-convention'?: Linter.RuleEntry<HtmlIdNamingConvention> /** * Enforce consistent indentation */ 'html/indent'?: Linter.RuleEntry<HtmlIndent> /** * Enforce to use lowercase for tag and attribute names. */ 'html/lowercase'?: Linter.RuleEntry<[]> /** * Disallow to use of abstract roles */ 'html/no-abstract-roles'?: Linter.RuleEntry<[]> /** * Disallow to use of accesskey attribute */ 'html/no-accesskey-attrs'?: Linter.RuleEntry<[]> /** * Disallow to use aria-hidden attributes on the `body` element. */ 'html/no-aria-hidden-body'?: Linter.RuleEntry<[]> /** * Disallow to use duplicate attributes */ 'html/no-duplicate-attrs'?: Linter.RuleEntry<[]> /** * Disallow to use duplicate id */ 'html/no-duplicate-id'?: Linter.RuleEntry<[]> /** * Disallow an extra spacing around attributes */ 'html/no-extra-spacing-attrs'?: Linter.RuleEntry<HtmlNoExtraSpacingAttrs> /** * Disallow using inline style */ 'html/no-inline-styles'?: Linter.RuleEntry<[]> /** * Disallow multiple empty lines */ 'html/no-multiple-empty-lines'?: Linter.RuleEntry<HtmlNoMultipleEmptyLines> /** * Disallow multiple `<h1></h1>`. */ 'html/no-multiple-h1'?: Linter.RuleEntry<[]> /** * Disallow use of `user-scalable=no` in `<meta name="viewport">`. */ 'html/no-non-scalable-viewport'?: Linter.RuleEntry<[]> /** * Disallow to use obsolete elements in HTML5 */ 'html/no-obsolete-tags'?: Linter.RuleEntry<[]> /** * Disallow use of positive `tabindex`. */ 'html/no-positive-tabindex'?: Linter.RuleEntry<[]> /** * Disallow specified attributes */ 'html/no-restricted-attr-values'?: Linter.RuleEntry<HtmlNoRestrictedAttrValues> /** * Disallow specified attributes */ 'html/no-restricted-attrs'?: Linter.RuleEntry<HtmlNoRestrictedAttrs> /** * Enforce to omit type attributes for style sheets and scripts */ 'html/no-script-style-type'?: Linter.RuleEntry<[]> /** * Disallow skipping heading levels */ 'html/no-skip-heading-levels'?: Linter.RuleEntry<[]> /** * Disallow usage of unsafe `target='_blank'` */ 'html/no-target-blank'?: Linter.RuleEntry<[]> /** * Disallow trailing whitespace at the end of lines */ 'html/no-trailing-spaces'?: Linter.RuleEntry<[]> /** * Enforce consistent quoting attributes with double(") or single(') */ 'html/quotes'?: Linter.RuleEntry<HtmlQuotes> /** * Require specified attributes */ 'html/require-attrs'?: Linter.RuleEntry<HtmlRequireAttrs> /** * Require use of button element with a valid type attribute. */ 'html/require-button-type'?: Linter.RuleEntry<[]> /** * Require closing tags. */ 'html/require-closing-tags'?: Linter.RuleEntry<HtmlRequireClosingTags> /** * Require `<!DOCTYPE HTML>` in html, */ 'html/require-doctype'?: Linter.RuleEntry<[]> /** * Require `title` in `<frame>`, `<iframe>` */ 'html/require-frame-title'?: Linter.RuleEntry<[]> /** * Require `alt` attribute at `<img>` tag */ 'html/require-img-alt'?: Linter.RuleEntry<HtmlRequireImgAlt> /** * Require `lang` attribute at `<html>` tag */ 'html/require-lang'?: Linter.RuleEntry<[]> /** * Enforce `<li>` to be in `<ul>`, `<ol>` or `<menu>`. */ 'html/require-li-container'?: Linter.RuleEntry<[]> /** * Enforce to use `<meta charset="...">` in `<head>` */ 'html/require-meta-charset'?: Linter.RuleEntry<[]> /** * Require use of `<meta name="description">` in `<head>` */ 'html/require-meta-description'?: Linter.RuleEntry<[]> /** * Enforce to use `<meta name="viewport">` in `<head>` */ 'html/require-meta-viewport'?: Linter.RuleEntry<[]> /** * Enforce to use `<meta name="viewport">` in `<head>` */ 'html/require-open-graph-protocol'?: Linter.RuleEntry<HtmlRequireOpenGraphProtocol> /** * Require `<title><title/>` in the `<head><head/>` */ 'html/require-title'?: Linter.RuleEntry<[]> /** * Enforce attributes alphabetical sorting */ 'html/sort-attrs'?: Linter.RuleEntry<HtmlSortAttrs> /** * Disallow specified identifiers * @see https://eslint.org/docs/latest/rules/id-blacklist * @deprecated */ 'id-blacklist'?: Linter.RuleEntry<IdBlacklist> /** * Disallow specified identifiers * @see https://eslint.org/docs/latest/rules/id-denylist */ 'id-denylist'?: Linter.RuleEntry<IdDenylist> /** * Enforce minimum and maximum identifier lengths * @see https://eslint.org/docs/latest/rules/id-length */ 'id-length'?: Linter.RuleEntry<IdLength> /** * Require identifiers to match a specified regular expression * @see https://eslint.org/docs/latest/rules/id-match */ 'id-match'?: Linter.RuleEntry<IdMatch> /** * Enforce the location of arrow function bodies * @see https://eslint.org/docs/latest/rules/implicit-arrow-linebreak * @deprecated */ 'implicit-arrow-linebreak'?: Linter.RuleEntry<ImplicitArrowLinebreak> /** * Enforce or ban the use of inline type-only markers for named imports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/consistent-type-specifier-style.md */ 'import/consistent-type-specifier-style'?: Linter.RuleEntry<ImportConsistentTypeSpecifierStyle> /** * Ensure a default export is present, given a default import. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/default.md */ 'import/default'?: Linter.RuleEntry<[]> /** * Enforce a leading comment with the webpackChunkName for dynamic imports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/dynamic-import-chunkname.md */ 'import/dynamic-import-chunkname'?: Linter.RuleEntry<ImportDynamicImportChunkname> /** * Forbid any invalid exports, i.e. re-export of the same name. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/export.md */ 'import/export'?: Linter.RuleEntry<[]> /** * Ensure all exports appear after other statements. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/exports-last.md */ 'import/exports-last'?: Linter.RuleEntry<[]> /** * Ensure consistent use of file extension within the import path. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/extensions.md */ 'import/extensions'?: Linter.RuleEntry<ImportExtensions> /** * Ensure all imports appear before other statements. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/first.md */ 'import/first'?: Linter.RuleEntry<ImportFirst> /** * Prefer named exports to be grouped together in a single export declaration. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/group-exports.md */ 'import/group-exports'?: Linter.RuleEntry<ImportGroupExports> /** * Replaced by `import-x/first`. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/7b25c1cb95ee18acc1531002fd343e1e6031f9ed/docs/rules/imports-first.md * @deprecated */ 'import/imports-first'?: Linter.RuleEntry<ImportImportsFirst> /** * Enforce the maximum number of dependencies a module can have. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/max-dependencies.md */ 'import/max-dependencies'?: Linter.RuleEntry<ImportMaxDependencies> /** * Ensure named imports correspond to a named export in the remote file. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/named.md */ 'import/named'?: Linter.RuleEntry<ImportNamed> /** * Ensure imported namespaces contain dereferenced properties as they are dereferenced. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/namespace.md */ 'import/namespace'?: Linter.RuleEntry<ImportNamespace> /** * Enforce a newline after import statements. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/newline-after-import.md */ 'import/newline-after-import'?: Linter.RuleEntry<ImportNewlineAfterImport> /** * Forbid import of modules using absolute paths. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-absolute-path.md */ 'import/no-absolute-path'?: Linter.RuleEntry<ImportNoAbsolutePath> /** * Forbid AMD `require` and `define` calls. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-amd.md */ 'import/no-amd'?: Linter.RuleEntry<[]> /** * Forbid anonymous values as default exports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-anonymous-default-export.md */ 'import/no-anonymous-default-export'?: Linter.RuleEntry<ImportNoAnonymousDefaultExport> /** * Forbid CommonJS `require` calls and `module.exports` or `exports.*`. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-commonjs.md */ 'import/no-commonjs'?: Linter.RuleEntry<ImportNoCommonjs> /** * Forbid a module from importing a module with a dependency path back to itself. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-cycle.md */ 'import/no-cycle'?: Linter.RuleEntry<ImportNoCycle> /** * Forbid default exports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-default-export.md */ 'import/no-default-export'?: Linter.RuleEntry<[]> /** * Forbid imported names marked with `@deprecated` documentation tag. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-deprecated.md */ 'import/no-deprecated'?: Linter.RuleEntry<[]> /** * Forbid repeated import of the same module in multiple places. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-duplicates.md */ 'import/no-duplicates'?: Linter.RuleEntry<ImportNoDuplicates> /** * Forbid `require()` calls with expressions. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-dynamic-require.md */ 'import/no-dynamic-require'?: Linter.RuleEntry<ImportNoDynamicRequire> /** * Forbid empty named import blocks. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-empty-named-blocks.md */ 'import/no-empty-named-blocks'?: Linter.RuleEntry<[]> /** * Forbid the use of extraneous packages. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-extraneous-dependencies.md */ 'import/no-extraneous-dependencies'?: Linter.RuleEntry<ImportNoExtraneousDependencies> /** * Forbid import statements with CommonJS module.exports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-import-module-exports.md */ 'import/no-import-module-exports'?: Linter.RuleEntry<ImportNoImportModuleExports> /** * Forbid importing the submodules of other modules. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-internal-modules.md */ 'import/no-internal-modules'?: Linter.RuleEntry<ImportNoInternalModules> /** * Forbid the use of mutable exports with `var` or `let`. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-mutable-exports.md */ 'import/no-mutable-exports'?: Linter.RuleEntry<[]> /** * Forbid use of exported name as identifier of default export. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-named-as-default.md */ 'import/no-named-as-default'?: Linter.RuleEntry<[]> /** * Forbid use of exported name as property of default export. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-named-as-default-member.md */ 'import/no-named-as-default-member'?: Linter.RuleEntry<[]> /** * Forbid named default exports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-named-default.md */ 'import/no-named-default'?: Linter.RuleEntry<[]> /** * Forbid named exports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-named-export.md */ 'import/no-named-export'?: Linter.RuleEntry<[]> /** * Forbid namespace (a.k.a. "wildcard" `*`) imports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-namespace.md */ 'import/no-namespace'?: Linter.RuleEntry<ImportNoNamespace> /** * Forbid Node.js builtin modules. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-nodejs-modules.md */ 'import/no-nodejs-modules'?: Linter.RuleEntry<ImportNoNodejsModules> /** * Forbid importing packages through relative paths. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-relative-packages.md */ 'import/no-relative-packages'?: Linter.RuleEntry<ImportNoRelativePackages> /** * Forbid importing modules from parent directories. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-relative-parent-imports.md */ 'import/no-relative-parent-imports'?: Linter.RuleEntry<ImportNoRelativeParentImports> /** * Enforce which files can be imported in a given folder. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-restricted-paths.md */ 'import/no-restricted-paths'?: Linter.RuleEntry<ImportNoRestrictedPaths> /** * Forbid a module from importing itself. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-self-import.md */ 'import/no-self-import'?: Linter.RuleEntry<[]> /** * Forbid unassigned imports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-unassigned-import.md */ 'import/no-unassigned-import'?: Linter.RuleEntry<ImportNoUnassignedImport> /** * Ensure imports point to a file/module that can be resolved. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-unresolved.md */ 'import/no-unresolved'?: Linter.RuleEntry<ImportNoUnresolved> /** * Forbid modules without exports, or exports without matching import in another module. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-unused-modules.md */ 'import/no-unused-modules'?: Linter.RuleEntry<ImportNoUnusedModules> /** * Forbid unnecessary path segments in import and require statements. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-useless-path-segments.md */ 'import/no-useless-path-segments'?: Linter.RuleEntry<ImportNoUselessPathSegments> /** * Forbid webpack loader syntax in imports. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/no-webpack-loader-syntax.md */ 'import/no-webpack-loader-syntax'?: Linter.RuleEntry<[]> /** * Enforce a convention in module import order. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/order.md */ 'import/order'?: Linter.RuleEntry<ImportOrder> /** * Prefer a default export if module exports a single name or multiple names. * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/prefer-default-export.md */ 'import/prefer-default-export'?: Linter.RuleEntry<ImportPreferDefaultExport> /** * Forbid potentially ambiguous parse goal (`script` vs. `module`). * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v0.4.4/docs/rules/unambiguous.md */ 'import/unambiguous'?: Linter.RuleEntry<[]> /** * Enforce consistent indentation * @see https://eslint.org/docs/latest/rules/indent * @deprecated */ 'indent'?: Linter.RuleEntry<Indent> /** * Enforce consistent indentation * @see https://eslint.org/docs/latest/rules/indent-legacy * @deprecated */ 'indent-legacy'?: Linter.RuleEntry<IndentLegacy> /** * Require or disallow initialization in variable declarations * @see https://eslint.org/docs/latest/rules/init-declarations */ 'init-declarations'?: Linter.RuleEntry<InitDeclarations> 'jest-formatting/padding-around-after-all-blocks'?: Linter.RuleEntry<[]> 'jest-formatting/padding-around-after-each-blocks'?: Linter.RuleEntry<[]> 'jest-formatting/padding-around-all'?: Linter.RuleEntry<[]> 'jest-formatting/padding-around-before-all-blocks'?: Linter.RuleEntry<[]> 'jest-formatting/padding-around-before-each-blocks'?: Linter.RuleEntry<[]> 'jest-formatting/padding-around-describe-blocks'?: Linter.RuleEntry<[]> 'jest-formatting/padding-around-expect-groups'?: Linter.RuleEntry<[]> 'jest-formatting/padding-around-test-blocks'?: Linter.RuleEntry<[]> /** * enforce line breaks after opening and before closing array brackets * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/array-bracket-newline.html */ 'jsonc/array-bracket-newline'?: Linter.RuleEntry<JsoncArrayBracketNewline> /** * disallow or enforce spaces inside of brackets * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/array-bracket-spacing.html */ 'jsonc/array-bracket-spacing'?: Linter.RuleEntry<JsoncArrayBracketSpacing> /** * enforce line breaks between array elements * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/array-element-newline.html */ 'jsonc/array-element-newline'?: Linter.RuleEntry<JsoncArrayElementNewline> /** * apply jsonc rules similar to your configured ESLint core rules * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/auto.html */ 'jsonc/auto'?: Linter.RuleEntry<[]> /** * require or disallow trailing commas * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/comma-dangle.html */ 'jsonc/comma-dangle'?: Linter.RuleEntry<JsoncCommaDangle> /** * enforce consistent comma style * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/comma-style.html */ 'jsonc/comma-style'?: Linter.RuleEntry<JsoncCommaStyle> /** * enforce consistent indentation * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/indent.html */ 'jsonc/indent'?: Linter.RuleEntry<JsoncIndent> /** * enforce naming convention to property key names * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/key-name-casing.html */ 'jsonc/key-name-casing'?: Linter.RuleEntry<JsoncKeyNameCasing> /** * enforce consistent spacing between keys and values in object literal properties * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/key-spacing.html */ 'jsonc/key-spacing'?: Linter.RuleEntry<JsoncKeySpacing> /** * disallow BigInt literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-bigint-literals.html */ 'jsonc/no-bigint-literals'?: Linter.RuleEntry<[]> /** * disallow binary expression * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-binary-expression.html */ 'jsonc/no-binary-expression'?: Linter.RuleEntry<[]> /** * disallow binary numeric literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-binary-numeric-literals.html */ 'jsonc/no-binary-numeric-literals'?: Linter.RuleEntry<[]> /** * disallow comments * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-comments.html */ 'jsonc/no-comments'?: Linter.RuleEntry<[]> /** * disallow duplicate keys in object literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-dupe-keys.html */ 'jsonc/no-dupe-keys'?: Linter.RuleEntry<[]> /** * disallow escape sequences in identifiers. * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-escape-sequence-in-identifier.html */ 'jsonc/no-escape-sequence-in-identifier'?: Linter.RuleEntry<[]> /** * disallow leading or trailing decimal points in numeric literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-floating-decimal.html */ 'jsonc/no-floating-decimal'?: Linter.RuleEntry<[]> /** * disallow hexadecimal numeric literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-hexadecimal-numeric-literals.html */ 'jsonc/no-hexadecimal-numeric-literals'?: Linter.RuleEntry<[]> /** * disallow Infinity * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-infinity.html */ 'jsonc/no-infinity'?: Linter.RuleEntry<[]> /** * disallow irregular whitespace * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-irregular-whitespace.html */ 'jsonc/no-irregular-whitespace'?: Linter.RuleEntry<JsoncNoIrregularWhitespace> /** * disallow multiline strings * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-multi-str.html */ 'jsonc/no-multi-str'?: Linter.RuleEntry<[]> /** * disallow NaN * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-nan.html */ 'jsonc/no-nan'?: Linter.RuleEntry<[]> /** * disallow number property keys * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-number-props.html */ 'jsonc/no-number-props'?: Linter.RuleEntry<[]> /** * disallow numeric separators * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-numeric-separators.html */ 'jsonc/no-numeric-separators'?: Linter.RuleEntry<[]> /** * disallow legacy octal literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-octal.html */ 'jsonc/no-octal'?: Linter.RuleEntry<[]> /** * disallow octal escape sequences in string literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-octal-escape.html */ 'jsonc/no-octal-escape'?: Linter.RuleEntry<[]> /** * disallow octal numeric literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-octal-numeric-literals.html */ 'jsonc/no-octal-numeric-literals'?: Linter.RuleEntry<[]> /** * disallow parentheses around the expression * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-parenthesized.html */ 'jsonc/no-parenthesized'?: Linter.RuleEntry<[]> /** * disallow plus sign * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-plus-sign.html */ 'jsonc/no-plus-sign'?: Linter.RuleEntry<[]> /** * disallow RegExp literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-regexp-literals.html */ 'jsonc/no-regexp-literals'?: Linter.RuleEntry<[]> /** * disallow sparse arrays * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-sparse-arrays.html */ 'jsonc/no-sparse-arrays'?: Linter.RuleEntry<[]> /** * disallow template literals * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-template-literals.html */ 'jsonc/no-template-literals'?: Linter.RuleEntry<[]> /** * disallow `undefined` * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-undefined-value.html */ 'jsonc/no-undefined-value'?: Linter.RuleEntry<[]> /** * disallow Unicode code point escape sequences. * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-unicode-codepoint-escapes.html */ 'jsonc/no-unicode-codepoint-escapes'?: Linter.RuleEntry<[]> /** * disallow unnecessary escape usage * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/no-useless-escape.html */ 'jsonc/no-useless-escape'?: Linter.RuleEntry<[]> /** * enforce consistent line breaks inside braces * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/object-curly-newline.html */ 'jsonc/object-curly-newline'?: Linter.RuleEntry<JsoncObjectCurlyNewline> /** * enforce consistent spacing inside braces * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/object-curly-spacing.html */ 'jsonc/object-curly-spacing'?: Linter.RuleEntry<JsoncObjectCurlySpacing> /** * enforce placing object properties on separate lines * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/object-property-newline.html */ 'jsonc/object-property-newline'?: Linter.RuleEntry<JsoncObjectPropertyNewline> /** * require quotes around object literal property names * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/quote-props.html */ 'jsonc/quote-props'?: Linter.RuleEntry<JsoncQuoteProps> /** * enforce use of double or single quotes * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/quotes.html */ 'jsonc/quotes'?: Linter.RuleEntry<JsoncQuotes> /** * require array values to be sorted * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/sort-array-values.html */ 'jsonc/sort-array-values'?: Linter.RuleEntry<JsoncSortArrayValues> /** * require object keys to be sorted * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/sort-keys.html */ 'jsonc/sort-keys'?: Linter.RuleEntry<JsoncSortKeys> /** * disallow spaces after unary operators * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/space-unary-ops.html */ 'jsonc/space-unary-ops'?: Linter.RuleEntry<JsoncSpaceUnaryOps> /** * disallow invalid number for JSON * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/valid-json-number.html */ 'jsonc/valid-json-number'?: Linter.RuleEntry<[]> /** * disallow parsing errors in Vue custom blocks * @see https://ota-meshi.github.io/eslint-plugin-jsonc/rules/vue-custom-block/no-parsing-error.html */ 'jsonc/vue-custom-block/no-parsing-error'?: Linter.RuleEntry<[]> /** * Enforce the consistent use of either double or single quotes in JSX attributes * @see https://eslint.org/docs/latest/rules/jsx-quotes * @deprecated */ 'jsx-quotes'?: Linter.RuleEntry<JsxQuotes> /** * Enforce consistent spacing between keys and values in object literal properties * @see https://eslint.org/docs/latest/rules/key-spacing * @deprecated */ 'key-spacing'?: Linter.RuleEntry<KeySpacing> /** * Enforce consistent spacing before and after keywords * @see https://eslint.org/docs/latest/rules/keyword-spacing * @deprecated */ 'keyword-spacing'?: Linter.RuleEntry<KeywordSpacing> /** * Enforce position of line comments * @see https://eslint.org/docs/latest/rules/line-comment-position * @deprecated */ 'line-comment-position'?: Linter.RuleEntry<LineCommentPosition> /** * Enforce consistent linebreak style * @see https://eslint.org/docs/latest/rules/linebreak-style * @deprecated */ 'linebreak-style'?: Linter.RuleEntry<LinebreakStyle> /** * Require empty lines around comments * @see https://eslint.org/docs/latest/rules/lines-around-comment * @deprecated */ 'lines-around-comment'?: Linter.RuleEntry<LinesAroundComment> /** * Require or disallow newlines around directives * @see https://eslint.org/docs/latest/rules/lines-around-directive * @deprecated */ 'lines-around-directive'?: Linter.RuleEntry<LinesAroundDirective> /** * Require or disallow an empty line between class members * @see https://eslint.org/docs/latest/rules/lines-between-class-members * @deprecated */ 'lines-between-class-members'?: Linter.RuleEntry<LinesBetweenClassMembers> /** * Require or disallow logical assignment operator shorthand * @see https://eslint.org/docs/latest/rules/logical-assignment-operators */ 'logical-assignment-operators'?: Linter.RuleEntry<LogicalAssignmentOperators> /** * Enforce a maximum number of classes per file * @see https://eslint.org/docs/latest/rules/max-classes-per-file */ 'max-classes-per-file'?: Linter.RuleEntry<MaxClassesPerFile> /** * Enforce a maximum depth that blocks can be nested * @see https://eslint.org/docs/latest/rules/max-depth */ 'max-depth'?: Linter.RuleEntry<MaxDepth> /** * Enforce a maximum line length * @see https://eslint.org/docs/latest/rules/max-len * @deprecated */ 'max-len'?: Linter.RuleEntry<MaxLen> /** * Enforce a maximum number of lines per file * @see https://eslint.org/docs/latest/rules/max-lines */ 'max-lines'?: Linter.RuleEntry<MaxLines> /** * Enforce a maximum number of lines of code in a function * @see https://eslint.org/docs/latest/rules/max-lines-per-function */ 'max-lines-per-function'?: Linter.RuleEntry<MaxLinesPerFunction> /** * Enforce a maximum depth that callbacks can be nested * @see https://eslint.org/docs/latest/rules/max-nested-callbacks */ 'max-nested-callbacks'?: Linter.RuleEntry<MaxNestedCallbacks> /** * Enforce a maximum number of parameters in function definitions * @see https://eslint.org/docs/latest/rules/max-params */ 'max-params'?: Linter.RuleEntry<MaxParams> /** * Enforce a maximum number of statements allowed in function blocks * @see https://eslint.org/docs/latest/rules/max-statements */ 'max-statements'?: Linter.RuleEntry<MaxStatements> /** * Enforce a maximum number of statements allowed per line * @see https://eslint.org/docs/latest/rules/max-statements-per-line * @deprecated */ 'max-statements-per-line'?: Linter.RuleEntry<MaxStatementsPerLine> /** * Linter integration with remark plugins */ 'mdx/remark'?: Linter.RuleEntry<[]> /** * Enforce a particular style for multiline comments * @see https://eslint.org/docs/latest/rules/multiline-comment-style * @deprecated */ 'multiline-comment-style'?: Linter.RuleEntry<MultilineCommentStyle> /** * Enforce newlines between operands of ternary expressions * @see https://eslint.org/docs/latest/rules/multiline-ternary * @deprecated */ 'multiline-ternary'?: Linter.RuleEntry<MultilineTernary> /** * Require constructor names to begin with a capital letter * @see https://eslint.org/docs/latest/rules/new-cap */ 'new-cap'?: Linter.RuleEntry<NewCap> /** * Enforce or disallow parentheses when invoking a constructor with no arguments * @see https://eslint.org/docs/latest/rules/new-parens * @deprecated */ 'new-parens'?: Linter.RuleEntry<NewParens> /** * Require or disallow an empty line after variable declarations * @see https://eslint.org/docs/latest/rules/newline-after-var * @deprecated */ 'newline-after-var'?: Linter.RuleEntry<NewlineAfterVar> /** * Require an empty line before `return` statements * @see https://eslint.org/docs/latest/rules/newline-before-return * @deprecated */ 'newline-before-return'?: Linter.RuleEntry<[]> /** * Require a newline after each call in a method chain * @see https://eslint.org/docs/latest/rules/newline-per-chained-call * @deprecated */ 'newline-per-chained-call'?: Linter.RuleEntry<NewlinePerChainedCall> /** * Disallow the use of `alert`, `confirm`, and `prompt` * @see https://eslint.org/docs/latest/rules/no-alert */ 'no-alert'?: Linter.RuleEntry<[]> /** * Disallow `Array` constructors * @see https://eslint.org/docs/latest/rules/no-array-constructor */ 'no-array-constructor'?: Linter.RuleEntry<[]> /** * Disallow using an async function as a Promise executor * @see https://eslint.org/docs/latest/rules/no-async-promise-executor */ 'no-async-promise-executor'?: Linter.RuleEntry<[]> /** * Disallow `await` inside of loops * @see https://eslint.org/docs/latest/rules/no-await-in-loop */ 'no-await-in-loop'?: Linter.RuleEntry<[]> /** * no await inside Promise statements * @see https://github.com/hugo-vrijswijk/eslint-plugin-no-await-in-promise/blob/main/docs/rules/no-await-in-promise.md */ 'no-await-in-promise/no-await-in-promise'?: Linter.RuleEntry<[]> /** * Disallow bitwise operators * @see https://eslint.org/docs/latest/rules/no-bitwise */ 'no-bitwise'?: Linter.RuleEntry<NoBitwise> /** * Disallow use of the `Buffer()` constructor * @see https://eslint.org/docs/latest/rules/no-buffer-constructor * @deprecated */ 'no-buffer-constructor'?: Linter.RuleEntry<[]> /** * Disallow the use of `arguments.caller` or `arguments.callee` * @see https://eslint.org/docs/latest/rules/no-caller */ 'no-caller'?: Linter.RuleEntry<[]> /** * Disallow lexical declarations in case clauses * @see https://eslint.org/docs/latest/rules/no-case-declarations */ 'no-case-declarations'?: Linter.RuleEntry<[]> /** * Disallow `catch` clause parameters from shadowing variables in the outer scope * @see https://eslint.org/docs/latest/rules/no-catch-shadow * @deprecated */ 'no-catch-shadow'?: Linter.RuleEntry<[]> /** * Disallow reassigning class members * @see https://eslint.org/docs/latest/rules/no-class-assign */ 'no-class-assign'?: Linter.RuleEntry<[]> /** * Disallow comparing against -0 * @see https://eslint.org/docs/latest/rules/no-compare-neg-zero */ 'no-compare-neg-zero'?: Linter.RuleEntry<[]> /** * Disallow assignment operators in conditional expressions * @see https://eslint.org/docs/latest/rules/no-cond-assign */ 'no-cond-assign'?: Linter.RuleEntry<NoCondAssign> /** * Disallow arrow functions where they could be confused with comparisons * @see https://eslint.org/docs/latest/rules/no-confusing-arrow * @deprecated */ 'no-confusing-arrow'?: Linter.RuleEntry<NoConfusingArrow> /** * Disallow the use of `console` * @see https://eslint.org/docs/latest/rules/no-console */ 'no-console'?: Linter.RuleEntry<NoConsole> /** * Disallow reassigning `const` variables * @see https://eslint.org/docs/latest/rules/no-const-assign */ 'no-const-assign'?: Linter.RuleEntry<[]> /** * Disallow expressions where the operation doesn't affect the value * @see https://eslint.org/docs/latest/rules/no-constant-binary-expression */ 'no-constant-binary-expression'?: Linter.RuleEntry<[]> /** * Disallow constant expressions in conditions * @see https://eslint.org/docs/latest/rules/no-constant-condition */ 'no-constant-condition'?: Linter.RuleEntry<NoConstantCondition> /** * Disallow returning value from constructor * @see https://eslint.org/docs/latest/rules/no-constructor-return */ 'no-constructor-return'?: Linter.RuleEntry<[]> /** * Disallow `continue` statements * @see https://eslint.org/docs/latest/rules/no-continue */ 'no-continue'?: Linter.RuleEntry<[]> /** * Disallow control characters in regular expressions * @see https://eslint.org/docs/latest/rules/no-control-regex */ 'no-control-regex'?: Linter.RuleEntry<[]> /** * Disallow the use of `debugger` * @see https://eslint.org/docs/latest/rules/no-debugger */ 'no-debugger'?: Linter.RuleEntry<[]> /** * Disallow deleting variables * @see https://eslint.org/docs/latest/rules/no-delete-var */ 'no-delete-var'?: Linter.RuleEntry<[]> /** * Disallow equal signs explicitly at the beginning of regular expressions * @see https://eslint.org/docs/latest/rules/no-div-regex */ 'no-div-regex'?: Linter.RuleEntry<[]> /** * Disallow duplicate arguments in `function` definitions * @see https://eslint.org/docs/latest/rules/no-dupe-args */ 'no-dupe-args'?: Linter.RuleEntry<[]> /** * Disallow duplicate class members * @see https://eslint.org/docs/latest/rules/no-dupe-class-members */ 'no-dupe-class-members'?: Linter.RuleEntry<[]> /** * Disallow duplicate conditions in if-else-if chains * @see https://eslint.org/docs/latest/rules/no-dupe-else-if */ 'no-dupe-else-if'?: Linter.RuleEntry<[]> /** * Disallow duplicate keys in object literals * @see https://eslint.org/docs/latest/rules/no-dupe-keys */ 'no-dupe-keys'?: Linter.RuleEntry<[]> /** * Disallow duplicate case labels * @see https://eslint.org/docs/latest/rules/no-duplicate-case */ 'no-duplicate-case'?: Linter.RuleEntry<[]> /** * Disallow duplicate module imports * @see https://eslint.org/docs/latest/rules/no-duplicate-imports */ 'no-duplicate-imports'?: Linter.RuleEntry<NoDuplicateImports> /** * Disallow `else` blocks after `return` statements in `if` statements * @see https://eslint.org/docs/latest/rules/no-else-return */ 'no-else-return'?: Linter.RuleEntry<NoElseReturn> /** * Disallow empty block statements * @see https://eslint.org/docs/latest/rules/no-empty */ 'no-empty'?: Linter.RuleEntry<NoEmpty> /** * Disallow empty character classes in regular expressions * @see https://eslint.org/docs/latest/rules/no-empty-character-class */ 'no-empty-character-class'?: Linter.RuleEntry<[]> /** * Disallow empty functions * @see https://eslint.org/docs/latest/rules/no-empty-function */ 'no-empty-function'?: Linter.RuleEntry<NoEmptyFunction> /** * Disallow empty destructuring patterns * @see https://eslint.org/docs/latest/rules/no-empty-pattern */ 'no-empty-pattern'?: Linter.RuleEntry<NoEmptyPattern> /** * Disallow empty static blocks * @see https://eslint.org/docs/latest/rules/no-empty-static-block */ 'no-empty-static-block'?: Linter.RuleEntry<[]> /** * Disallow `null` comparisons without type-checking operators * @see https://eslint.org/docs/latest/rules/no-eq-null */ 'no-eq-null'?: Linter.RuleEntry<[]> /** * Disallow the use of `eval()` * @see https://eslint.org/docs/latest/rules/no-eval */ 'no-eval'?: Linter.RuleEntry<NoEval> /** * Disallow reassigning exceptions in `catch` clauses * @see https://eslint.org/docs/latest/rules/no-ex-assign */ 'no-ex-assign'?: Linter.RuleEntry<[]> /** * Disallow extending native types * @see https://eslint.org/docs/latest/rules/no-extend-native */ 'no-extend-nat