import { Linter } from 'eslint'; import { FlatConfigComposer } from 'eslint-flat-config-utils'; import { StylisticCustomizeOptions } from '@stylistic/eslint-plugin'; import { ParserOptions } from '@typescript-eslint/parser'; import { NormalizedPackageJson } from '@visulima/package'; import { FlatGitignoreOptions } from 'eslint-config-flat-gitignore'; interface RuleOptions { /** * Enforce linebreaks after opening and before closing array brackets * @see https://eslint.style/rules/array-bracket-newline */ '@stylistic/array-bracket-newline'?: Linter.RuleEntry; /** * Enforce consistent spacing inside array brackets * @see https://eslint.style/rules/array-bracket-spacing */ '@stylistic/array-bracket-spacing'?: Linter.RuleEntry; /** * Enforce line breaks after each array element * @see https://eslint.style/rules/array-element-newline */ '@stylistic/array-element-newline'?: Linter.RuleEntry; /** * Require parentheses around arrow function arguments * @see https://eslint.style/rules/arrow-parens */ '@stylistic/arrow-parens'?: Linter.RuleEntry; /** * Enforce consistent spacing before and after the arrow in arrow functions * @see https://eslint.style/rules/arrow-spacing */ '@stylistic/arrow-spacing'?: Linter.RuleEntry; /** * Disallow or enforce spaces inside of blocks after opening block and before closing block * @see https://eslint.style/rules/block-spacing */ '@stylistic/block-spacing'?: Linter.RuleEntry; /** * Enforce consistent brace style for blocks * @see https://eslint.style/rules/brace-style */ '@stylistic/brace-style'?: Linter.RuleEntry; /** * Require or disallow trailing commas * @see https://eslint.style/rules/comma-dangle */ '@stylistic/comma-dangle'?: Linter.RuleEntry; /** * Enforce consistent spacing before and after commas * @see https://eslint.style/rules/comma-spacing */ '@stylistic/comma-spacing'?: Linter.RuleEntry; /** * Enforce consistent comma style * @see https://eslint.style/rules/comma-style */ '@stylistic/comma-style'?: Linter.RuleEntry; /** * Enforce consistent spacing inside computed property brackets * @see https://eslint.style/rules/computed-property-spacing */ '@stylistic/computed-property-spacing'?: Linter.RuleEntry; /** * Enforce consistent line breaks after opening and before closing braces * @see https://eslint.style/rules/curly-newline */ '@stylistic/curly-newline'?: Linter.RuleEntry; /** * Enforce consistent newlines before and after dots * @see https://eslint.style/rules/dot-location */ '@stylistic/dot-location'?: Linter.RuleEntry; /** * Require or disallow newline at the end of files * @see https://eslint.style/rules/eol-last */ '@stylistic/eol-last'?: Linter.RuleEntry; /** * Enforce consistent line break styles for JSX props * @see https://eslint.style/rules/jsx-props-style */ '@stylistic/exp-jsx-props-style'?: Linter.RuleEntry; /** * Enforce consistent spacing and line break styles inside brackets. * @see https://eslint.style/rules/list-style */ '@stylistic/exp-list-style'?: Linter.RuleEntry; /** * Enforce line breaks between arguments of a function call * @see https://eslint.style/rules/function-call-argument-newline */ '@stylistic/function-call-argument-newline'?: Linter.RuleEntry; /** * Require or disallow spacing between function identifiers and their invocations * @see https://eslint.style/rules/function-call-spacing */ '@stylistic/function-call-spacing'?: Linter.RuleEntry; /** * Enforce consistent line breaks inside function parentheses * @see https://eslint.style/rules/function-paren-newline */ '@stylistic/function-paren-newline'?: Linter.RuleEntry; /** * Enforce consistent spacing around `*` operators in generator functions * @see https://eslint.style/rules/generator-star-spacing */ '@stylistic/generator-star-spacing'?: Linter.RuleEntry; /** * Enforce the location of arrow function bodies * @see https://eslint.style/rules/implicit-arrow-linebreak */ '@stylistic/implicit-arrow-linebreak'?: Linter.RuleEntry; /** * Enforce consistent indentation * @see https://eslint.style/rules/indent */ '@stylistic/indent'?: Linter.RuleEntry; /** * Indentation for binary operators * @see https://eslint.style/rules/indent-binary-ops */ '@stylistic/indent-binary-ops'?: Linter.RuleEntry; /** * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions * @see https://eslint.style/rules/jsx-child-element-spacing */ '@stylistic/jsx-child-element-spacing'?: Linter.RuleEntry<[]>; /** * Enforce closing bracket location in JSX * @see https://eslint.style/rules/jsx-closing-bracket-location */ '@stylistic/jsx-closing-bracket-location'?: Linter.RuleEntry; /** * Enforce closing tag location for multiline JSX * @see https://eslint.style/rules/jsx-closing-tag-location */ '@stylistic/jsx-closing-tag-location'?: Linter.RuleEntry; /** * Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes * @see https://eslint.style/rules/jsx-curly-brace-presence */ '@stylistic/jsx-curly-brace-presence'?: Linter.RuleEntry; /** * Enforce consistent linebreaks in curly braces in JSX attributes and expressions * @see https://eslint.style/rules/jsx-curly-newline */ '@stylistic/jsx-curly-newline'?: Linter.RuleEntry; /** * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions * @see https://eslint.style/rules/jsx-curly-spacing */ '@stylistic/jsx-curly-spacing'?: Linter.RuleEntry; /** * Enforce or disallow spaces around equal signs in JSX attributes * @see https://eslint.style/rules/jsx-equals-spacing */ '@stylistic/jsx-equals-spacing'?: Linter.RuleEntry; /** * Enforce proper position of the first property in JSX * @see https://eslint.style/rules/jsx-first-prop-new-line */ '@stylistic/jsx-first-prop-new-line'?: Linter.RuleEntry; /** * Enforce line breaks before and after JSX elements when they are used as arguments to a function. * @see https://eslint.style/rules/jsx-function-call-newline */ '@stylistic/jsx-function-call-newline'?: Linter.RuleEntry; /** * Enforce JSX indentation. Deprecated, use `indent` rule instead. * @see https://eslint.style/rules/jsx-indent * @deprecated */ '@stylistic/jsx-indent'?: Linter.RuleEntry; /** * Enforce props indentation in JSX * @see https://eslint.style/rules/jsx-indent-props */ '@stylistic/jsx-indent-props'?: Linter.RuleEntry; /** * Enforce maximum of props on a single line in JSX * @see https://eslint.style/rules/jsx-max-props-per-line */ '@stylistic/jsx-max-props-per-line'?: Linter.RuleEntry; /** * Require or prevent a new line after jsx elements and expressions. * @see https://eslint.style/rules/jsx-newline */ '@stylistic/jsx-newline'?: Linter.RuleEntry; /** * Require one JSX element per line * @see https://eslint.style/rules/jsx-one-expression-per-line */ '@stylistic/jsx-one-expression-per-line'?: Linter.RuleEntry; /** * Enforce PascalCase for user-defined JSX components * @see https://eslint.style/rules/jsx-pascal-case */ '@stylistic/jsx-pascal-case'?: Linter.RuleEntry; /** * Disallow multiple spaces between inline JSX props. Deprecated, use `no-multi-spaces` rule instead. * @see https://eslint.style/rules/jsx-props-no-multi-spaces * @deprecated */ '@stylistic/jsx-props-no-multi-spaces'?: Linter.RuleEntry<[]>; /** * Enforce the consistent use of either double or single quotes in JSX attributes * @see https://eslint.style/rules/jsx-quotes */ '@stylistic/jsx-quotes'?: Linter.RuleEntry; /** * Disallow extra closing tags for components without children * @see https://eslint.style/rules/jsx-self-closing-comp */ '@stylistic/jsx-self-closing-comp'?: Linter.RuleEntry; /** * Enforce props alphabetical sorting * @see https://eslint.style/rules/jsx-sort-props * @deprecated */ '@stylistic/jsx-sort-props'?: Linter.RuleEntry; /** * Enforce whitespace in and around the JSX opening and closing brackets * @see https://eslint.style/rules/jsx-tag-spacing */ '@stylistic/jsx-tag-spacing'?: Linter.RuleEntry; /** * Disallow missing parentheses around multiline JSX * @see https://eslint.style/rules/jsx-wrap-multilines */ '@stylistic/jsx-wrap-multilines'?: Linter.RuleEntry; /** * Enforce consistent spacing between property names and type annotations in types and interfaces * @see https://eslint.style/rules/key-spacing */ '@stylistic/key-spacing'?: Linter.RuleEntry; /** * Enforce consistent spacing before and after keywords * @see https://eslint.style/rules/keyword-spacing */ '@stylistic/keyword-spacing'?: Linter.RuleEntry; /** * Enforce position of line comments * @see https://eslint.style/rules/line-comment-position */ '@stylistic/line-comment-position'?: Linter.RuleEntry; /** * Enforce consistent linebreak style * @see https://eslint.style/rules/linebreak-style */ '@stylistic/linebreak-style'?: Linter.RuleEntry; /** * Require empty lines around comments * @see https://eslint.style/rules/lines-around-comment */ '@stylistic/lines-around-comment'?: Linter.RuleEntry; /** * Require or disallow an empty line between class members * @see https://eslint.style/rules/lines-between-class-members */ '@stylistic/lines-between-class-members'?: Linter.RuleEntry; /** * Enforce a maximum line length * @see https://eslint.style/rules/max-len */ '@stylistic/max-len'?: Linter.RuleEntry; /** * Enforce a maximum number of statements allowed per line * @see https://eslint.style/rules/max-statements-per-line */ '@stylistic/max-statements-per-line'?: Linter.RuleEntry; /** * Require a specific member delimiter style for interfaces and type literals * @see https://eslint.style/rules/member-delimiter-style */ '@stylistic/member-delimiter-style'?: Linter.RuleEntry; /** * Enforce a particular style for multiline comments * @see https://eslint.style/rules/multiline-comment-style */ '@stylistic/multiline-comment-style'?: Linter.RuleEntry; /** * Enforce newlines between operands of ternary expressions * @see https://eslint.style/rules/multiline-ternary */ '@stylistic/multiline-ternary'?: Linter.RuleEntry; /** * Enforce or disallow parentheses when invoking a constructor with no arguments * @see https://eslint.style/rules/new-parens */ '@stylistic/new-parens'?: Linter.RuleEntry; /** * Require a newline after each call in a method chain * @see https://eslint.style/rules/newline-per-chained-call */ '@stylistic/newline-per-chained-call'?: Linter.RuleEntry; /** * Disallow arrow functions where they could be confused with comparisons * @see https://eslint.style/rules/no-confusing-arrow */ '@stylistic/no-confusing-arrow'?: Linter.RuleEntry; /** * Disallow unnecessary parentheses * @see https://eslint.style/rules/no-extra-parens */ '@stylistic/no-extra-parens'?: Linter.RuleEntry; /** * Disallow unnecessary semicolons * @see https://eslint.style/rules/no-extra-semi */ '@stylistic/no-extra-semi'?: Linter.RuleEntry<[]>; /** * Disallow leading or trailing decimal points in numeric literals * @see https://eslint.style/rules/no-floating-decimal */ '@stylistic/no-floating-decimal'?: Linter.RuleEntry<[]>; /** * Disallow mixed binary operators * @see https://eslint.style/rules/no-mixed-operators */ '@stylistic/no-mixed-operators'?: Linter.RuleEntry; /** * Disallow mixed spaces and tabs for indentation * @see https://eslint.style/rules/no-mixed-spaces-and-tabs */ '@stylistic/no-mixed-spaces-and-tabs'?: Linter.RuleEntry; /** * Disallow multiple spaces * @see https://eslint.style/rules/no-multi-spaces */ '@stylistic/no-multi-spaces'?: Linter.RuleEntry; /** * Disallow multiple empty lines * @see https://eslint.style/rules/no-multiple-empty-lines */ '@stylistic/no-multiple-empty-lines'?: Linter.RuleEntry; /** * Disallow all tabs * @see https://eslint.style/rules/no-tabs */ '@stylistic/no-tabs'?: Linter.RuleEntry; /** * Disallow trailing whitespace at the end of lines * @see https://eslint.style/rules/no-trailing-spaces */ '@stylistic/no-trailing-spaces'?: Linter.RuleEntry; /** * Disallow whitespace before properties * @see https://eslint.style/rules/no-whitespace-before-property */ '@stylistic/no-whitespace-before-property'?: Linter.RuleEntry<[]>; /** * Enforce the location of single-line statements * @see https://eslint.style/rules/nonblock-statement-body-position */ '@stylistic/nonblock-statement-body-position'?: Linter.RuleEntry; /** * Enforce consistent line breaks after opening and before closing braces * @see https://eslint.style/rules/object-curly-newline */ '@stylistic/object-curly-newline'?: Linter.RuleEntry; /** * Enforce consistent spacing inside braces * @see https://eslint.style/rules/object-curly-spacing */ '@stylistic/object-curly-spacing'?: Linter.RuleEntry; /** * Enforce placing object properties on separate lines * @see https://eslint.style/rules/object-property-newline */ '@stylistic/object-property-newline'?: Linter.RuleEntry; /** * Require or disallow newlines around variable declarations * @see https://eslint.style/rules/one-var-declaration-per-line */ '@stylistic/one-var-declaration-per-line'?: Linter.RuleEntry; /** * Enforce consistent linebreak style for operators * @see https://eslint.style/rules/operator-linebreak */ '@stylistic/operator-linebreak'?: Linter.RuleEntry; /** * Require or disallow padding within blocks * @see https://eslint.style/rules/padded-blocks */ '@stylistic/padded-blocks'?: Linter.RuleEntry; /** * Require or disallow padding lines between statements * @see https://eslint.style/rules/padding-line-between-statements */ '@stylistic/padding-line-between-statements'?: Linter.RuleEntry; /** * Require quotes around object literal, type literal, interfaces and enums property names * @see https://eslint.style/rules/quote-props */ '@stylistic/quote-props'?: Linter.RuleEntry; /** * Enforce the consistent use of either backticks, double, or single quotes * @see https://eslint.style/rules/quotes */ '@stylistic/quotes'?: Linter.RuleEntry; /** * Enforce spacing between rest and spread operators and their expressions * @see https://eslint.style/rules/rest-spread-spacing */ '@stylistic/rest-spread-spacing'?: Linter.RuleEntry; /** * Require or disallow semicolons instead of ASI * @see https://eslint.style/rules/semi */ '@stylistic/semi'?: Linter.RuleEntry; /** * Enforce consistent spacing before and after semicolons * @see https://eslint.style/rules/semi-spacing */ '@stylistic/semi-spacing'?: Linter.RuleEntry; /** * Enforce location of semicolons * @see https://eslint.style/rules/semi-style */ '@stylistic/semi-style'?: Linter.RuleEntry; /** * Enforce consistent spacing before blocks * @see https://eslint.style/rules/space-before-blocks */ '@stylistic/space-before-blocks'?: Linter.RuleEntry; /** * Enforce consistent spacing before function parenthesis * @see https://eslint.style/rules/space-before-function-paren */ '@stylistic/space-before-function-paren'?: Linter.RuleEntry; /** * Enforce consistent spacing inside parentheses * @see https://eslint.style/rules/space-in-parens */ '@stylistic/space-in-parens'?: Linter.RuleEntry; /** * Require spacing around infix operators * @see https://eslint.style/rules/space-infix-ops */ '@stylistic/space-infix-ops'?: Linter.RuleEntry; /** * Enforce consistent spacing before or after unary operators * @see https://eslint.style/rules/space-unary-ops */ '@stylistic/space-unary-ops'?: Linter.RuleEntry; /** * Enforce consistent spacing after the `//` or `/*` in a comment * @see https://eslint.style/rules/spaced-comment */ '@stylistic/spaced-comment'?: Linter.RuleEntry; /** * Enforce spacing around colons of switch statements * @see https://eslint.style/rules/switch-colon-spacing */ '@stylistic/switch-colon-spacing'?: Linter.RuleEntry; /** * Require or disallow spacing around embedded expressions of template strings * @see https://eslint.style/rules/template-curly-spacing */ '@stylistic/template-curly-spacing'?: Linter.RuleEntry; /** * Require or disallow spacing between template tags and their literals * @see https://eslint.style/rules/template-tag-spacing */ '@stylistic/template-tag-spacing'?: Linter.RuleEntry; /** * Require consistent spacing around type annotations * @see https://eslint.style/rules/type-annotation-spacing */ '@stylistic/type-annotation-spacing'?: Linter.RuleEntry; /** * Enforces consistent spacing inside TypeScript type generics * @see https://eslint.style/rules/type-generic-spacing */ '@stylistic/type-generic-spacing'?: Linter.RuleEntry<[]>; /** * Expect space before the type declaration in the named tuple * @see https://eslint.style/rules/type-named-tuple-spacing */ '@stylistic/type-named-tuple-spacing'?: Linter.RuleEntry<[]>; /** * Require parentheses around immediate `function` invocations * @see https://eslint.style/rules/wrap-iife */ '@stylistic/wrap-iife'?: Linter.RuleEntry; /** * Require parenthesis around regex literals * @see https://eslint.style/rules/wrap-regex */ '@stylistic/wrap-regex'?: Linter.RuleEntry<[]>; /** * Require or disallow spacing around the `*` in `yield*` expressions * @see https://eslint.style/rules/yield-star-spacing */ '@stylistic/yield-star-spacing'?: Linter.RuleEntry; /** * Exhaustive deps rule for useQuery * @see https://tanstack.com/query/latest/docs/eslint/exhaustive-deps */ '@tanstack/query/exhaustive-deps'?: Linter.RuleEntry; /** * Ensure correct order of inference sensitive properties for infinite queries * @see https://tanstack.com/query/latest/docs/eslint/infinite-query-property-order */ '@tanstack/query/infinite-query-property-order'?: Linter.RuleEntry<[]>; /** * Ensure correct order of inference-sensitive properties in useMutation() * @see https://tanstack.com/query/latest/docs/eslint/mutation-property-order */ '@tanstack/query/mutation-property-order'?: Linter.RuleEntry<[]>; /** * Disallows rest destructuring in queries * @see https://tanstack.com/query/latest/docs/eslint/no-rest-destructuring */ '@tanstack/query/no-rest-destructuring'?: Linter.RuleEntry<[]>; /** * Disallow putting the result of query hooks directly in a React hook dependency array * @see https://tanstack.com/query/latest/docs/eslint/no-unstable-deps */ '@tanstack/query/no-unstable-deps'?: Linter.RuleEntry<[]>; /** * Ensures queryFn returns a non-undefined value * @see https://tanstack.com/query/latest/docs/eslint/no-void-query-fn */ '@tanstack/query/no-void-query-fn'?: Linter.RuleEntry<[]>; /** * Prefer using queryOptions() to co-locate queryKey and queryFn * @see https://tanstack.com/query/latest/docs/eslint/prefer-query-options */ '@tanstack/query/prefer-query-options'?: Linter.RuleEntry<[]>; /** * Makes sure that QueryClient is stable * @see https://tanstack.com/query/latest/docs/eslint/stable-query-client */ '@tanstack/query/stable-query-client'?: Linter.RuleEntry<[]>; /** * Ensure correct order of inference sensitive properties for createRoute functions * @see https://tanstack.com/router/latest/docs/eslint/create-route-property-order */ '@tanstack/router/create-route-property-order'?: Linter.RuleEntry<[]>; /** * Ensure route param names are valid JavaScript identifiers * @see https://tanstack.com/router/latest/docs/eslint/route-param-names */ '@tanstack/router/route-param-names'?: Linter.RuleEntry<[]>; /** * Require that function overload signatures be consecutive * @see https://typescript-eslint.io/rules/adjacent-overload-signatures */ '@typescript-eslint/adjacent-overload-signatures'?: Linter.RuleEntry<[]>; /** * Require consistently using either `T[]` or `Array` for arrays * @see https://typescript-eslint.io/rules/array-type */ '@typescript-eslint/array-type'?: Linter.RuleEntry; /** * Disallow awaiting a value that is not a Thenable * @see https://typescript-eslint.io/rules/await-thenable */ '@typescript-eslint/await-thenable'?: Linter.RuleEntry<[]>; /** * Disallow `@ts-` comments or require descriptions after directives * @see https://typescript-eslint.io/rules/ban-ts-comment */ '@typescript-eslint/ban-ts-comment'?: Linter.RuleEntry; /** * Disallow `// tslint:` comments * @see https://typescript-eslint.io/rules/ban-tslint-comment */ '@typescript-eslint/ban-tslint-comment'?: Linter.RuleEntry<[]>; /** * Enforce that literals on classes are exposed in a consistent style * @see https://typescript-eslint.io/rules/class-literal-property-style */ '@typescript-eslint/class-literal-property-style'?: Linter.RuleEntry; /** * Enforce that class methods utilize `this` * @see https://typescript-eslint.io/rules/class-methods-use-this */ '@typescript-eslint/class-methods-use-this'?: Linter.RuleEntry; /** * Enforce specifying generic type arguments on type annotation or constructor name of a constructor call * @see https://typescript-eslint.io/rules/consistent-generic-constructors */ '@typescript-eslint/consistent-generic-constructors'?: Linter.RuleEntry; /** * Require or disallow the `Record` type * @see https://typescript-eslint.io/rules/consistent-indexed-object-style */ '@typescript-eslint/consistent-indexed-object-style'?: Linter.RuleEntry; /** * Require `return` statements to either always or never specify values * @see https://typescript-eslint.io/rules/consistent-return */ '@typescript-eslint/consistent-return'?: Linter.RuleEntry; /** * Enforce consistent usage of type assertions * @see https://typescript-eslint.io/rules/consistent-type-assertions */ '@typescript-eslint/consistent-type-assertions'?: Linter.RuleEntry; /** * Enforce type definitions to consistently use either `interface` or `type` * @see https://typescript-eslint.io/rules/consistent-type-definitions */ '@typescript-eslint/consistent-type-definitions'?: Linter.RuleEntry; /** * Enforce consistent usage of type exports * @see https://typescript-eslint.io/rules/consistent-type-exports */ '@typescript-eslint/consistent-type-exports'?: Linter.RuleEntry; /** * Enforce consistent usage of type imports * @see https://typescript-eslint.io/rules/consistent-type-imports */ '@typescript-eslint/consistent-type-imports'?: Linter.RuleEntry; /** * Enforce default parameters to be last * @see https://typescript-eslint.io/rules/default-param-last */ '@typescript-eslint/default-param-last'?: Linter.RuleEntry<[]>; /** * Enforce dot notation whenever possible * @see https://typescript-eslint.io/rules/dot-notation */ '@typescript-eslint/dot-notation'?: Linter.RuleEntry; /** * Require explicit return types on functions and class methods * @see https://typescript-eslint.io/rules/explicit-function-return-type */ '@typescript-eslint/explicit-function-return-type'?: Linter.RuleEntry; /** * Require explicit accessibility modifiers on class properties and methods * @see https://typescript-eslint.io/rules/explicit-member-accessibility */ '@typescript-eslint/explicit-member-accessibility'?: Linter.RuleEntry; /** * Require explicit return and argument types on exported functions' and classes' public class methods * @see https://typescript-eslint.io/rules/explicit-module-boundary-types */ '@typescript-eslint/explicit-module-boundary-types'?: Linter.RuleEntry; /** * Require or disallow initialization in variable declarations * @see https://typescript-eslint.io/rules/init-declarations */ '@typescript-eslint/init-declarations'?: Linter.RuleEntry; /** * Enforce a maximum number of parameters in function definitions * @see https://typescript-eslint.io/rules/max-params */ '@typescript-eslint/max-params'?: Linter.RuleEntry; /** * Require a consistent member declaration order * @see https://typescript-eslint.io/rules/member-ordering */ '@typescript-eslint/member-ordering'?: Linter.RuleEntry; /** * Enforce using a particular method signature syntax * @see https://typescript-eslint.io/rules/method-signature-style */ '@typescript-eslint/method-signature-style'?: Linter.RuleEntry; /** * Enforce naming conventions for everything across a codebase * @see https://typescript-eslint.io/rules/naming-convention */ '@typescript-eslint/naming-convention'?: Linter.RuleEntry; /** * Disallow generic `Array` constructors * @see https://typescript-eslint.io/rules/no-array-constructor */ '@typescript-eslint/no-array-constructor'?: Linter.RuleEntry<[]>; /** * Disallow using the `delete` operator on array values * @see https://typescript-eslint.io/rules/no-array-delete */ '@typescript-eslint/no-array-delete'?: Linter.RuleEntry<[]>; /** * Require `.toString()` and `.toLocaleString()` to only be called on objects which provide useful information when stringified * @see https://typescript-eslint.io/rules/no-base-to-string */ '@typescript-eslint/no-base-to-string'?: Linter.RuleEntry; /** * Disallow non-null assertion in locations that may be confusing * @see https://typescript-eslint.io/rules/no-confusing-non-null-assertion */ '@typescript-eslint/no-confusing-non-null-assertion'?: Linter.RuleEntry<[]>; /** * Require expressions of type void to appear in statement position * @see https://typescript-eslint.io/rules/no-confusing-void-expression */ '@typescript-eslint/no-confusing-void-expression'?: Linter.RuleEntry; /** * Disallow using code marked as `@deprecated` * @see https://typescript-eslint.io/rules/no-deprecated */ '@typescript-eslint/no-deprecated'?: Linter.RuleEntry; /** * Disallow duplicate class members * @see https://typescript-eslint.io/rules/no-dupe-class-members */ '@typescript-eslint/no-dupe-class-members'?: Linter.RuleEntry<[]>; /** * Disallow duplicate enum member values * @see https://typescript-eslint.io/rules/no-duplicate-enum-values */ '@typescript-eslint/no-duplicate-enum-values'?: Linter.RuleEntry<[]>; /** * Disallow duplicate constituents of union or intersection types * @see https://typescript-eslint.io/rules/no-duplicate-type-constituents */ '@typescript-eslint/no-duplicate-type-constituents'?: Linter.RuleEntry; /** * Disallow using the `delete` operator on computed key expressions * @see https://typescript-eslint.io/rules/no-dynamic-delete */ '@typescript-eslint/no-dynamic-delete'?: Linter.RuleEntry<[]>; /** * Disallow empty functions * @see https://typescript-eslint.io/rules/no-empty-function */ '@typescript-eslint/no-empty-function'?: Linter.RuleEntry; /** * Disallow the declaration of empty interfaces * @see https://typescript-eslint.io/rules/no-empty-interface * @deprecated */ '@typescript-eslint/no-empty-interface'?: Linter.RuleEntry; /** * Disallow accidentally using the "empty object" type * @see https://typescript-eslint.io/rules/no-empty-object-type */ '@typescript-eslint/no-empty-object-type'?: Linter.RuleEntry; /** * Disallow the `any` type * @see https://typescript-eslint.io/rules/no-explicit-any */ '@typescript-eslint/no-explicit-any'?: Linter.RuleEntry; /** * Disallow extra non-null assertions * @see https://typescript-eslint.io/rules/no-extra-non-null-assertion */ '@typescript-eslint/no-extra-non-null-assertion'?: Linter.RuleEntry<[]>; /** * Disallow classes used as namespaces * @see https://typescript-eslint.io/rules/no-extraneous-class */ '@typescript-eslint/no-extraneous-class'?: Linter.RuleEntry; /** * Require Promise-like statements to be handled appropriately * @see https://typescript-eslint.io/rules/no-floating-promises */ '@typescript-eslint/no-floating-promises'?: Linter.RuleEntry; /** * Disallow iterating over an array with a for-in loop * @see https://typescript-eslint.io/rules/no-for-in-array */ '@typescript-eslint/no-for-in-array'?: Linter.RuleEntry<[]>; /** * Disallow the use of `eval()`-like functions * @see https://typescript-eslint.io/rules/no-implied-eval */ '@typescript-eslint/no-implied-eval'?: Linter.RuleEntry<[]>; /** * Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers * @see https://typescript-eslint.io/rules/no-import-type-side-effects */ '@typescript-eslint/no-import-type-side-effects'?: Linter.RuleEntry<[]>; /** * Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean * @see https://typescript-eslint.io/rules/no-inferrable-types */ '@typescript-eslint/no-inferrable-types'?: Linter.RuleEntry; /** * Disallow `this` keywords outside of classes or class-like objects * @see https://typescript-eslint.io/rules/no-invalid-this */ '@typescript-eslint/no-invalid-this'?: Linter.RuleEntry; /** * Disallow `void` type outside of generic or return types * @see https://typescript-eslint.io/rules/no-invalid-void-type */ '@typescript-eslint/no-invalid-void-type'?: Linter.RuleEntry; /** * Disallow function declarations that contain unsafe references inside loop statements * @see https://typescript-eslint.io/rules/no-loop-func */ '@typescript-eslint/no-loop-func'?: Linter.RuleEntry<[]>; /** * Disallow literal numbers that lose precision * @see https://typescript-eslint.io/rules/no-loss-of-precision * @deprecated */ '@typescript-eslint/no-loss-of-precision'?: Linter.RuleEntry<[]>; /** * Disallow magic numbers * @see https://typescript-eslint.io/rules/no-magic-numbers */ '@typescript-eslint/no-magic-numbers'?: Linter.RuleEntry; /** * Disallow the `void` operator except when used to discard a value * @see https://typescript-eslint.io/rules/no-meaningless-void-operator */ '@typescript-eslint/no-meaningless-void-operator'?: Linter.RuleEntry; /** * Enforce valid definition of `new` and `constructor` * @see https://typescript-eslint.io/rules/no-misused-new */ '@typescript-eslint/no-misused-new'?: Linter.RuleEntry<[]>; /** * Disallow Promises in places not designed to handle them * @see https://typescript-eslint.io/rules/no-misused-promises */ '@typescript-eslint/no-misused-promises'?: Linter.RuleEntry; /** * Disallow using the spread operator when it might cause unexpected behavior * @see https://typescript-eslint.io/rules/no-misused-spread */ '@typescript-eslint/no-misused-spread'?: Linter.RuleEntry; /** * Disallow enums from having both number and string members * @see https://typescript-eslint.io/rules/no-mixed-enums */ '@typescript-eslint/no-mixed-enums'?: Linter.RuleEntry<[]>; /** * Disallow TypeScript namespaces * @see https://typescript-eslint.io/rules/no-namespace */ '@typescript-eslint/no-namespace'?: Linter.RuleEntry; /** * Disallow non-null assertions in the left operand of a nullish coalescing operator * @see https://typescript-eslint.io/rules/no-non-null-asserted-nullish-coalescing */ '@typescript-eslint/no-non-null-asserted-nullish-coalescing'?: Linter.RuleEntry<[]>; /** * Disallow non-null assertions after an optional chain expression * @see https://typescript-eslint.io/rules/no-non-null-asserted-optional-chain */ '@typescript-eslint/no-non-null-asserted-optional-chain'?: Linter.RuleEntry<[]>; /** * Disallow non-null assertions using the `!` postfix operator * @see https://typescript-eslint.io/rules/no-non-null-assertion */ '@typescript-eslint/no-non-null-assertion'?: Linter.RuleEntry<[]>; /** * Disallow variable redeclaration * @see https://typescript-eslint.io/rules/no-redeclare */ '@typescript-eslint/no-redeclare'?: Linter.RuleEntry; /** * Disallow members of unions and intersections that do nothing or override type information * @see https://typescript-eslint.io/rules/no-redundant-type-constituents */ '@typescript-eslint/no-redundant-type-constituents'?: Linter.RuleEntry<[]>; /** * Disallow invocation of `require()` * @see https://typescript-eslint.io/rules/no-require-imports */ '@typescript-eslint/no-require-imports'?: Linter.RuleEntry; /** * Disallow specified modules when loaded by `import` * @see https://typescript-eslint.io/rules/no-restricted-imports */ '@typescript-eslint/no-restricted-imports'?: Linter.RuleEntry; /** * Disallow certain types * @see https://typescript-eslint.io/rules/no-restricted-types */ '@typescript-eslint/no-restricted-types'?: Linter.RuleEntry; /** * Disallow variable declarations from shadowing variables declared in the outer scope * @see https://typescript-eslint.io/rules/no-shadow */ '@typescript-eslint/no-shadow'?: Linter.RuleEntry; /** * Disallow aliasing `this` * @see https://typescript-eslint.io/rules/no-this-alias */ '@typescript-eslint/no-this-alias'?: Linter.RuleEntry; /** * Disallow type aliases * @see https://typescript-eslint.io/rules/no-type-alias * @deprecated */ '@typescript-eslint/no-type-alias'?: Linter.RuleEntry; /** * Disallow unnecessary equality comparisons against boolean literals * @see https://typescript-eslint.io/rules/no-unnecessary-boolean-literal-compare */ '@typescript-eslint/no-unnecessary-boolean-literal-compare'?: Linter.RuleEntry; /** * Disallow conditionals where the type is always truthy or always falsy * @see https://typescript-eslint.io/rules/no-unnecessary-condition */ '@typescript-eslint/no-unnecessary-condition'?: Linter.RuleEntry; /** * Disallow unnecessary assignment of constructor property parameter * @see https://typescript-eslint.io/rules/no-unnecessary-parameter-property-assignment */ '@typescript-eslint/no-unnecessary-parameter-property-assignment'?: Linter.RuleEntry<[]>; /** * Disallow unnecessary namespace qualifiers * @see https://typescript-eslint.io/rules/no-unnecessary-qualifier */ '@typescript-eslint/no-unnecessary-qualifier'?: Linter.RuleEntry<[]>; /** * Disallow unnecessary template expressions * @see https://typescript-eslint.io/rules/no-unnecessary-template-expression */ '@typescript-eslint/no-unnecessary-template-expression'?: Linter.RuleEntry<[]>; /** * Disallow type arguments that are equal to the default * @see https://typescript-eslint.io/rules/no-unnecessary-type-arguments */ '@typescript-eslint/no-unnecessary-type-arguments'?: Linter.RuleEntry<[]>; /** * Disallow type assertions that do not change the type of an expression * @see https://typescript-eslint.io/rules/no-unnecessary-type-assertion */ '@typescript-eslint/no-unnecessary-type-assertion'?: Linter.RuleEntry; /** * Disallow unnecessary constraints on generic types * @see https://typescript-eslint.io/rules/no-unnecessary-type-constraint */ '@typescript-eslint/no-unnecessary-type-constraint'?: Linter.RuleEntry<[]>; /** * Disallow conversion idioms when they do not change the type or value of the expression * @see https://typescript-eslint.io/rules/no-unnecessary-type-conversion */ '@typescript-eslint/no-unnecessary-type-conversion'?: Linter.RuleEntry<[]>; /** * Disallow type parameters that aren't used multiple times * @see https://typescript-eslint.io/rules/no-unnecessary-type-parameters */ '@typescript-eslint/no-unnecessary-type-parameters'?: Linter.RuleEntry<[]>; /** * Disallow calling a function with a value with type `any` * @see https://typescript-eslint.io/rules/no-unsafe-argument */ '@typescript-eslint/no-unsafe-argument'?: Linter.RuleEntry<[]>; /** * Disallow assigning a value with type `any` to variables and properties * @see https://typescript-eslint.io/rules/no-unsafe-assignment */ '@typescript-eslint/no-unsafe-assignment'?: Linter.RuleEntry<[]>; /** * Disallow calling a value with type `any` * @see https://typescript-eslint.io/rules/no-unsafe-call */ '@typescript-eslint/no-unsafe-call'?: Linter.RuleEntry<[]>; /** * Disallow unsafe declaration merging * @see https://typescript-eslint.io/rules/no-unsafe-declaration-merging */ '@typescript-eslint/no-unsafe-declaration-merging'?: Linter.RuleEntry<[]>; /** * Disallow comparing an enum value with a non-enum value * @see https://typescript-eslint.io/rules/no-unsafe-enum-comparison */ '@typescript-eslint/no-unsafe-enum-comparison'?: Linter.RuleEntry<[]>; /** * Disallow using the unsafe built-in Function type * @see https://typescript-eslint.io/rules/no-unsafe-function-type */ '@typescript-eslint/no-unsafe-function-type'?: Linter.RuleEntry<[]>; /** * Disallow member access on a value with type `any` * @see https://typescript-eslint.io/rules/no-unsafe-member-access */ '@typescript-eslint/no-unsafe-member-access'?: Linter.RuleEntry; /** * Disallow returning a value with type `any` from a function * @see https://typescript-eslint.io/rules/no-unsafe-return */ '@typescript-eslint/no-unsafe-return'?: Linter.RuleEntry<[]>; /** * Disallow type assertions that narrow a type * @see https://typescript-eslint.io/rules/no-unsafe-type-assertion */ '@typescript-eslint/no-unsafe-type-assertion'?: Linter.RuleEntry<[]>; /** * Require unary negation to take a number * @see https://typescript-eslint.io/rules/no-unsafe-unary-minus */ '@typescript-eslint/no-unsafe-unary-minus'?: Linter.RuleEntry<[]>; /** * Disallow unused expressions * @see https://typescript-eslint.io/rules/no-unused-expressions */ '@typescript-eslint/no-unused-expressions'?: Linter.RuleEntry; /** * Disallow unused private class members * @see https://typescript-eslint.io/rules/no-unused-private-class-members */ '@typescript-eslint/no-unused-private-class-members'?: Linter.RuleEntry<[]>; /** * Disallow unused variables * @see https://typescript-eslint.io/rules/no-unused-vars */ '@typescript-eslint/no-unused-vars'?: Linter.RuleEntry; /** * Disallow the use of variables before they are defined * @see https://typescript-eslint.io/rules/no-use-before-define */ '@typescript-eslint/no-use-before-define'?: Linter.RuleEntry; /** * Disallow unnecessary constructors * @see https://typescript-eslint.io/rules/no-useless-constructor */ '@typescript-eslint/no-useless-constructor'?: Linter.RuleEntry<[]>; /** * Disallow default values that will never be used * @see https://typescript-eslint.io/rules/no-useless-default-assignment */ '@typescript-eslint/no-useless-default-assignment'?: Linter.RuleEntry; /** * Disallow empty exports that don't change anything in a module file * @see https://typescript-eslint.io/rules/no-useless-empty-export */ '@typescript-eslint/no-useless-empty-export'?: Linter.RuleEntry<[]>; /** * Disallow `require` statements except in import statements * @see https://typescript-eslint.io/rules/no-var-requires * @deprecated */ '@typescript-eslint/no-var-requires'?: Linter.RuleEntry; /** * Disallow using confusing built-in primitive class wrappers * @see https://typescript-eslint.io/rules/no-wrapper-object-types */ '@typescript-eslint/no-wrapper-object-types'?: Linter.RuleEntry<[]>; /** * Enforce non-null assertions over explicit type assertions * @see https://typescript-eslint.io/rules/non-nullable-type-assertion-style */ '@typescript-eslint/non-nullable-type-assertion-style'?: Linter.RuleEntry<[]>; /** * Disallow throwing non-`Error` values as exceptions * @see https://typescript-eslint.io/rules/only-throw-error */ '@typescript-eslint/only-throw-error'?: Linter.RuleEntry; /** * Require or disallow parameter properties in class constructors * @see https://typescript-eslint.io/rules/parameter-properties */ '@typescript-eslint/parameter-properties'?: Linter.RuleEntry; /** * Enforce the use of `as const` over literal type * @see https://typescript-eslint.io/rules/prefer-as-const */ '@typescript-eslint/prefer-as-const'?: Linter.RuleEntry<[]>; /** * Require destructuring from arrays and/or objects * @see https://typescript-eslint.io/rules/prefer-destructuring */ '@typescript-eslint/prefer-destructuring'?: Linter.RuleEntry; /** * Require each enum member value to be explicitly initialized * @see https://typescript-eslint.io/rules/prefer-enum-initializers */ '@typescript-eslint/prefer-enum-initializers'?: Linter.RuleEntry<[]>; /** * Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result * @see https://typescript-eslint.io/rules/prefer-find */ '@typescript-eslint/prefer-find'?: Linter.RuleEntry<[]>; /** * Enforce the use of `for-of` loop over the standard `for` loop where possible * @see https://typescript-eslint.io/rules/prefer-for-of */ '@typescript-eslint/prefer-for-of'?: Linter.RuleEntry<[]>; /** * Enforce using function types instead of interfaces with call signatures * @see https://typescript-eslint.io/rules/prefer-function-type */ '@typescript-eslint/prefer-function-type'?: Linter.RuleEntry<[]>; /** * Enforce `includes` method over `indexOf` method * @see https://typescript-eslint.io/rules/prefer-includes */ '@typescript-eslint/prefer-includes'?: Linter.RuleEntry<[]>; /** * Require all enum members to be literal values * @see https://typescript-eslint.io/rules/prefer-literal-enum-member */ '@typescript-eslint/prefer-literal-enum-member'?: Linter.RuleEntry; /** * Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules * @see https://typescript-eslint.io/rules/prefer-namespace-keyword */ '@typescript-eslint/prefer-namespace-keyword'?: Linter.RuleEntry<[]>; /** * Enforce using the nullish coalescing operator instead of logical assignments or chaining * @see https://typescript-eslint.io/rules/prefer-nullish-coalescing */ '@typescript-eslint/prefer-nullish-coalescing'?: Linter.RuleEntry; /** * Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects * @see https://typescript-eslint.io/rules/prefer-optional-chain */ '@typescript-eslint/prefer-optional-chain'?: Linter.RuleEntry; /** * Require using Error objects as Promise rejection reasons * @see https://typescript-eslint.io/rules/prefer-promise-reject-errors */ '@typescript-eslint/prefer-promise-reject-errors'?: Linter.RuleEntry; /** * Require private members to be marked as `readonly` if they're never modified outside of the constructor * @see https://typescript-eslint.io/rules/prefer-readonly */ '@typescript-eslint/prefer-readonly'?: Linter.RuleEntry; /** * Require function parameters to be typed as `readonly` to prevent accidental mutation of inputs * @see https://typescript-eslint.io/rules/prefer-readonly-parameter-types */ '@typescript-eslint/prefer-readonly-parameter-types'?: Linter.RuleEntry; /** * Enforce using type parameter when calling `Array#reduce` instead of using a type assertion * @see https://typescript-eslint.io/rules/prefer-reduce-type-parameter */ '@typescript-eslint/prefer-reduce-type-parameter'?: Linter.RuleEntry<[]>; /** * Enforce `RegExp#exec` over `String#match` if no global flag is provided * @see https://typescript-eslint.io/rules/prefer-regexp-exec */ '@typescript-eslint/prefer-regexp-exec'?: Linter.RuleEntry<[]>; /** * Enforce that `this` is used when only `this` type is returned * @see https://typescript-eslint.io/rules/prefer-return-this-type */ '@typescript-eslint/prefer-return-this-type'?: Linter.RuleEntry<[]>; /** * Enforce using `String#startsWith` and `String#endsWith` over other equivalent methods of checking substrings * @see https://typescript-eslint.io/rules/prefer-string-starts-ends-with */ '@typescript-eslint/prefer-string-starts-ends-with'?: Linter.RuleEntry; /** * Enforce using `@ts-expect-error` over `@ts-ignore` * @see https://typescript-eslint.io/rules/prefer-ts-expect-error * @deprecated */ '@typescript-eslint/prefer-ts-expect-error'?: Linter.RuleEntry<[]>; /** * Require any function or method that returns a Promise to be marked async * @see https://typescript-eslint.io/rules/promise-function-async */ '@typescript-eslint/promise-function-async'?: Linter.RuleEntry; /** * Enforce that `get()` types should be assignable to their equivalent `set()` type * @see https://typescript-eslint.io/rules/related-getter-setter-pairs */ '@typescript-eslint/related-getter-setter-pairs'?: Linter.RuleEntry<[]>; /** * Require `Array#sort` and `Array#toSorted` calls to always provide a `compareFunction` * @see https://typescript-eslint.io/rules/require-array-sort-compare */ '@typescript-eslint/require-array-sort-compare'?: Linter.RuleEntry; /** * Disallow async functions which do not return promises and have no `await` expression * @see https://typescript-eslint.io/rules/require-await */ '@typescript-eslint/require-await'?: Linter.RuleEntry<[]>; /** * Require both operands of addition to be the same type and be `bigint`, `number`, or `string` * @see https://typescript-eslint.io/rules/restrict-plus-operands */ '@typescript-eslint/restrict-plus-operands'?: Linter.RuleEntry; /** * Enforce template literal expressions to be of `string` type * @see https://typescript-eslint.io/rules/restrict-template-expressions */ '@typescript-eslint/restrict-template-expressions'?: Linter.RuleEntry; /** * Enforce consistent awaiting of returned promises * @see https://typescript-eslint.io/rules/return-await */ '@typescript-eslint/return-await'?: Linter.RuleEntry; /** * Enforce constituents of a type union/intersection to be sorted alphabetically * @see https://typescript-eslint.io/rules/sort-type-constituents * @deprecated */ '@typescript-eslint/sort-type-constituents'?: Linter.RuleEntry; /** * Disallow certain types in boolean expressions * @see https://typescript-eslint.io/rules/strict-boolean-expressions */ '@typescript-eslint/strict-boolean-expressions'?: Linter.RuleEntry; /** * Disallow passing a value-returning function in a position accepting a void function * @see https://typescript-eslint.io/rules/strict-void-return */ '@typescript-eslint/strict-void-return'?: Linter.RuleEntry; /** * Require switch-case statements to be exhaustive * @see https://typescript-eslint.io/rules/switch-exhaustiveness-check */ '@typescript-eslint/switch-exhaustiveness-check'?: Linter.RuleEntry; /** * Disallow certain triple slash directives in favor of ES6-style import declarations * @see https://typescript-eslint.io/rules/triple-slash-reference */ '@typescript-eslint/triple-slash-reference'?: Linter.RuleEntry; /** * Require type annotations in certain places * @see https://typescript-eslint.io/rules/typedef * @deprecated */ '@typescript-eslint/typedef'?: Linter.RuleEntry; /** * Enforce unbound methods are called with their expected scope * @see https://typescript-eslint.io/rules/unbound-method */ '@typescript-eslint/unbound-method'?: Linter.RuleEntry; /** * Disallow two overloads that could be unified into one with a union or an optional/rest parameter * @see https://typescript-eslint.io/rules/unified-signatures */ '@typescript-eslint/unified-signatures'?: Linter.RuleEntry; /** * Enforce typing arguments in Promise rejection callbacks as `unknown` * @see https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable */ '@typescript-eslint/use-unknown-in-catch-callback-variable'?: Linter.RuleEntry<[]>; /** * Having line breaks styles to object, array and named imports * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/consistent-chaining.md */ 'antfu/consistent-chaining'?: Linter.RuleEntry; /** * Having line breaks styles to object, array and named imports * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/consistent-list-newline.md */ 'antfu/consistent-list-newline'?: Linter.RuleEntry; /** * Enforce Anthony's style of curly bracket * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/curly.md */ 'antfu/curly'?: Linter.RuleEntry<[]>; /** * Newline after if * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/if-newline.md */ 'antfu/if-newline'?: Linter.RuleEntry<[]>; /** * Fix duplication in imports * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/import-dedupe.md */ 'antfu/import-dedupe'?: Linter.RuleEntry<[]>; /** * Enforce consistent indentation in `unindent` template tag * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/indent-unindent.md */ 'antfu/indent-unindent'?: Linter.RuleEntry; /** * Prevent importing modules in `dist` folder * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/no-import-dist.test.ts */ 'antfu/no-import-dist'?: Linter.RuleEntry<[]>; /** * Prevent importing modules in `node_modules` folder by relative or absolute path * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/no-import-node-modules-by-path.test.ts */ 'antfu/no-import-node-modules-by-path'?: Linter.RuleEntry<[]>; /** * Prevent using top-level await * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/no-top-level-await.test.ts */ 'antfu/no-top-level-await'?: Linter.RuleEntry<[]>; /** * Do not use `exports =` * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/no-ts-export-equal.test.ts */ 'antfu/no-ts-export-equal'?: Linter.RuleEntry<[]>; /** * Enforce top-level functions to be declared with function keyword * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/top-level-function.md */ 'antfu/top-level-function'?: Linter.RuleEntry<[]>; /** * apply `jsx-a11y/alt-text` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/alt-text/ */ 'astro/jsx-a11y/alt-text'?: Linter.RuleEntry; /** * apply `jsx-a11y/anchor-ambiguous-text` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-ambiguous-text/ */ 'astro/jsx-a11y/anchor-ambiguous-text'?: Linter.RuleEntry; /** * apply `jsx-a11y/anchor-has-content` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-has-content/ */ 'astro/jsx-a11y/anchor-has-content'?: Linter.RuleEntry; /** * apply `jsx-a11y/anchor-is-valid` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-is-valid/ */ 'astro/jsx-a11y/anchor-is-valid'?: Linter.RuleEntry; /** * apply `jsx-a11y/aria-activedescendant-has-tabindex` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-activedescendant-has-tabindex/ */ 'astro/jsx-a11y/aria-activedescendant-has-tabindex'?: Linter.RuleEntry; /** * apply `jsx-a11y/aria-props` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-props/ */ 'astro/jsx-a11y/aria-props'?: Linter.RuleEntry; /** * apply `jsx-a11y/aria-proptypes` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-proptypes/ */ 'astro/jsx-a11y/aria-proptypes'?: Linter.RuleEntry; /** * apply `jsx-a11y/aria-role` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-role/ */ 'astro/jsx-a11y/aria-role'?: Linter.RuleEntry; /** * apply `jsx-a11y/aria-unsupported-elements` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-unsupported-elements/ */ 'astro/jsx-a11y/aria-unsupported-elements'?: Linter.RuleEntry; /** * apply `jsx-a11y/autocomplete-valid` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/autocomplete-valid/ */ 'astro/jsx-a11y/autocomplete-valid'?: Linter.RuleEntry; /** * apply `jsx-a11y/click-events-have-key-events` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/click-events-have-key-events/ */ 'astro/jsx-a11y/click-events-have-key-events'?: Linter.RuleEntry; /** * apply `jsx-a11y/control-has-associated-label` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/control-has-associated-label/ */ 'astro/jsx-a11y/control-has-associated-label'?: Linter.RuleEntry; /** * apply `jsx-a11y/heading-has-content` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/heading-has-content/ */ 'astro/jsx-a11y/heading-has-content'?: Linter.RuleEntry; /** * apply `jsx-a11y/html-has-lang` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/html-has-lang/ */ 'astro/jsx-a11y/html-has-lang'?: Linter.RuleEntry; /** * apply `jsx-a11y/iframe-has-title` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/iframe-has-title/ */ 'astro/jsx-a11y/iframe-has-title'?: Linter.RuleEntry; /** * apply `jsx-a11y/img-redundant-alt` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/img-redundant-alt/ */ 'astro/jsx-a11y/img-redundant-alt'?: Linter.RuleEntry; /** * apply `jsx-a11y/interactive-supports-focus` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/interactive-supports-focus/ */ 'astro/jsx-a11y/interactive-supports-focus'?: Linter.RuleEntry; /** * apply `jsx-a11y/label-has-associated-control` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/label-has-associated-control/ */ 'astro/jsx-a11y/label-has-associated-control'?: Linter.RuleEntry; /** * apply `jsx-a11y/lang` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/lang/ */ 'astro/jsx-a11y/lang'?: Linter.RuleEntry; /** * apply `jsx-a11y/media-has-caption` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/media-has-caption/ */ 'astro/jsx-a11y/media-has-caption'?: Linter.RuleEntry; /** * apply `jsx-a11y/mouse-events-have-key-events` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/mouse-events-have-key-events/ */ 'astro/jsx-a11y/mouse-events-have-key-events'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-access-key` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-access-key/ */ 'astro/jsx-a11y/no-access-key'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-aria-hidden-on-focusable` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-aria-hidden-on-focusable/ */ 'astro/jsx-a11y/no-aria-hidden-on-focusable'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-autofocus` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-autofocus/ */ 'astro/jsx-a11y/no-autofocus'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-distracting-elements` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-distracting-elements/ */ 'astro/jsx-a11y/no-distracting-elements'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-interactive-element-to-noninteractive-role` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-interactive-element-to-noninteractive-role/ */ 'astro/jsx-a11y/no-interactive-element-to-noninteractive-role'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-noninteractive-element-interactions` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-element-interactions/ */ 'astro/jsx-a11y/no-noninteractive-element-interactions'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-noninteractive-element-to-interactive-role` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-element-to-interactive-role/ */ 'astro/jsx-a11y/no-noninteractive-element-to-interactive-role'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-noninteractive-tabindex` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-tabindex/ */ 'astro/jsx-a11y/no-noninteractive-tabindex'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-redundant-roles` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-redundant-roles/ */ 'astro/jsx-a11y/no-redundant-roles'?: Linter.RuleEntry; /** * apply `jsx-a11y/no-static-element-interactions` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-static-element-interactions/ */ 'astro/jsx-a11y/no-static-element-interactions'?: Linter.RuleEntry; /** * apply `jsx-a11y/prefer-tag-over-role` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/prefer-tag-over-role/ */ 'astro/jsx-a11y/prefer-tag-over-role'?: Linter.RuleEntry; /** * apply `jsx-a11y/role-has-required-aria-props` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/role-has-required-aria-props/ */ 'astro/jsx-a11y/role-has-required-aria-props'?: Linter.RuleEntry; /** * apply `jsx-a11y/role-supports-aria-props` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/role-supports-aria-props/ */ 'astro/jsx-a11y/role-supports-aria-props'?: Linter.RuleEntry; /** * apply `jsx-a11y/scope` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/scope/ */ 'astro/jsx-a11y/scope'?: Linter.RuleEntry; /** * apply `jsx-a11y/tabindex-no-positive` rule to Astro components * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/tabindex-no-positive/ */ 'astro/jsx-a11y/tabindex-no-positive'?: Linter.RuleEntry; /** * the client:only directive is missing the correct component's framework value * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/missing-client-only-directive-value/ */ 'astro/missing-client-only-directive-value'?: Linter.RuleEntry<[]>; /** * disallow conflicting set directives and child contents * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-conflict-set-directives/ */ 'astro/no-conflict-set-directives'?: Linter.RuleEntry<[]>; /** * disallow using deprecated `Astro.canonicalURL` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-canonicalurl/ */ 'astro/no-deprecated-astro-canonicalurl'?: Linter.RuleEntry<[]>; /** * disallow using deprecated `Astro.fetchContent()` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-fetchcontent/ */ 'astro/no-deprecated-astro-fetchcontent'?: Linter.RuleEntry<[]>; /** * disallow using deprecated `Astro.resolve()` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-resolve/ */ 'astro/no-deprecated-astro-resolve'?: Linter.RuleEntry<[]>; /** * disallow using deprecated `getEntryBySlug()` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-getentrybyslug/ */ 'astro/no-deprecated-getentrybyslug'?: Linter.RuleEntry<[]>; /** * disallow value export * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-exports-from-components/ */ 'astro/no-exports-from-components'?: Linter.RuleEntry<[]>; /** * disallow `prerender` export outside of pages/ directory * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-prerender-export-outside-pages/ */ 'astro/no-prerender-export-outside-pages'?: Linter.RuleEntry<[]>; /** * disallow use of `set:html` to prevent XSS attack * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-set-html-directive/ */ 'astro/no-set-html-directive'?: Linter.RuleEntry<[]>; /** * disallow use of `set:text` * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-set-text-directive/ */ 'astro/no-set-text-directive'?: Linter.RuleEntry<[]>; /** * disallow inline `