@rebeccastevens/eslint-config

// Generated by dts-bundle-generator v9.5.1 import { StylisticCustomizeOptions } from '@stylistic/eslint-plugin'; import { ParserOptions } from '@typescript-eslint/parser'; import { TSESLint } from '@typescript-eslint/utils'; import { SharedConfig } from '@typescript-eslint/utils/ts-eslint'; import { ESLint, Linter } from 'eslint'; import { Options as VueBlocksOptions } from 'eslint-processor-vue-blocks'; import { Options as PrettierOptions } from 'prettier'; type LocaleKeyType = "file" | "path" | "key"; type SettingsVueI18nLocaleDir = SettingsVueI18nLocaleDirGlob | SettingsVueI18nLocaleDirObject | Array<SettingsVueI18nLocaleDirGlob | SettingsVueI18nLocaleDirObject>; type SettingsVueI18nLocaleDirGlob = string; interface SettingsVueI18nLocaleDirObject { /** * A glob for specifying files that store localization messages of project. */ pattern: string; /** * Specifies how to determine the locale for localization messages. */ localeKey: LocaleKeyType; /** * Specifies how to determine pattern the locale for localization messages. * * This option means, when `localeKey` is `'path'`, you will need to capture the locale using a regular expression. * You need to use the locale capture as a named capture `?<locale>`, so it’s be able to capture from the path of the locale resources. * If you omit it, it will be captured from the resource path with the same regular expression pattern as `vue-cli-plugin-i18n`. */ localePattern?: string | RegExp; } declare module "eslint" { namespace Linter { interface RulesRecord extends RuleOptions { } } } 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<StylisticArrayBracketNewline>; /** * Enforce consistent spacing inside array brackets * @see https://eslint.style/rules/array-bracket-spacing */ "@stylistic/array-bracket-spacing"?: Linter.RuleEntry<StylisticArrayBracketSpacing>; /** * Enforce line breaks after each array element * @see https://eslint.style/rules/array-element-newline */ "@stylistic/array-element-newline"?: Linter.RuleEntry<StylisticArrayElementNewline>; /** * Require parentheses around arrow function arguments * @see https://eslint.style/rules/arrow-parens */ "@stylistic/arrow-parens"?: Linter.RuleEntry<StylisticArrowParens>; /** * Enforce consistent spacing before and after the arrow in arrow functions * @see https://eslint.style/rules/arrow-spacing */ "@stylistic/arrow-spacing"?: Linter.RuleEntry<StylisticArrowSpacing>; /** * 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<StylisticBlockSpacing>; /** * Enforce consistent brace style for blocks * @see https://eslint.style/rules/brace-style */ "@stylistic/brace-style"?: Linter.RuleEntry<StylisticBraceStyle>; /** * Require or disallow trailing commas * @see https://eslint.style/rules/comma-dangle */ "@stylistic/comma-dangle"?: Linter.RuleEntry<StylisticCommaDangle>; /** * Enforce consistent spacing before and after commas * @see https://eslint.style/rules/comma-spacing */ "@stylistic/comma-spacing"?: Linter.RuleEntry<StylisticCommaSpacing>; /** * Enforce consistent comma style * @see https://eslint.style/rules/comma-style */ "@stylistic/comma-style"?: Linter.RuleEntry<StylisticCommaStyle>; /** * Enforce consistent spacing inside computed property brackets * @see https://eslint.style/rules/computed-property-spacing */ "@stylistic/computed-property-spacing"?: Linter.RuleEntry<StylisticComputedPropertySpacing>; /** * Enforce consistent line breaks after opening and before closing braces * @see https://eslint.style/rules/curly-newline */ "@stylistic/curly-newline"?: Linter.RuleEntry<StylisticCurlyNewline>; /** * Enforce consistent newlines before and after dots * @see https://eslint.style/rules/dot-location */ "@stylistic/dot-location"?: Linter.RuleEntry<StylisticDotLocation>; /** * Require or disallow newline at the end of files * @see https://eslint.style/rules/eol-last */ "@stylistic/eol-last"?: Linter.RuleEntry<StylisticEolLast>; /** * Enforce consistent line break styles for JSX props * @see https://eslint.style/rules/jsx-props-style */ "@stylistic/exp-jsx-props-style"?: Linter.RuleEntry<StylisticExpJsxPropsStyle>; /** * Enforce consistent spacing and line break styles inside brackets. * @see https://eslint.style/rules/list-style */ "@stylistic/exp-list-style"?: Linter.RuleEntry<StylisticExpListStyle>; /** * 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<StylisticFunctionCallArgumentNewline>; /** * Require or disallow spacing between function identifiers and their invocations * @see https://eslint.style/rules/function-call-spacing */ "@stylistic/function-call-spacing"?: Linter.RuleEntry<StylisticFunctionCallSpacing>; /** * Enforce consistent line breaks inside function parentheses * @see https://eslint.style/rules/function-paren-newline */ "@stylistic/function-paren-newline"?: Linter.RuleEntry<StylisticFunctionParenNewline>; /** * Enforce consistent spacing around `*` operators in generator functions * @see https://eslint.style/rules/generator-star-spacing */ "@stylistic/generator-star-spacing"?: Linter.RuleEntry<StylisticGeneratorStarSpacing>; /** * Enforce the location of arrow function bodies * @see https://eslint.style/rules/implicit-arrow-linebreak */ "@stylistic/implicit-arrow-linebreak"?: Linter.RuleEntry<StylisticImplicitArrowLinebreak>; /** * Enforce consistent indentation * @see https://eslint.style/rules/indent */ "@stylistic/indent"?: Linter.RuleEntry<StylisticIndent>; /** * Indentation for binary operators * @see https://eslint.style/rules/indent-binary-ops */ "@stylistic/indent-binary-ops"?: Linter.RuleEntry<StylisticIndentBinaryOps>; /** * 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<StylisticJsxClosingBracketLocation>; /** * Enforce closing tag location for multiline JSX * @see https://eslint.style/rules/jsx-closing-tag-location */ "@stylistic/jsx-closing-tag-location"?: Linter.RuleEntry<StylisticJsxClosingTagLocation>; /** * 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<StylisticJsxCurlyBracePresence>; /** * 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<StylisticJsxCurlyNewline>; /** * 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<StylisticJsxCurlySpacing>; /** * Enforce or disallow spaces around equal signs in JSX attributes * @see https://eslint.style/rules/jsx-equals-spacing */ "@stylistic/jsx-equals-spacing"?: Linter.RuleEntry<StylisticJsxEqualsSpacing>; /** * 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<StylisticJsxFirstPropNewLine>; /** * 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<StylisticJsxFunctionCallNewline>; /** * Enforce JSX indentation. Deprecated, use `indent` rule instead. * @see https://eslint.style/rules/jsx-indent * @deprecated */ "@stylistic/jsx-indent"?: Linter.RuleEntry<StylisticJsxIndent>; /** * Enforce props indentation in JSX * @see https://eslint.style/rules/jsx-indent-props */ "@stylistic/jsx-indent-props"?: Linter.RuleEntry<StylisticJsxIndentProps>; /** * 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<StylisticJsxMaxPropsPerLine>; /** * Require or prevent a new line after jsx elements and expressions. * @see https://eslint.style/rules/jsx-newline */ "@stylistic/jsx-newline"?: Linter.RuleEntry<StylisticJsxNewline>; /** * Require one JSX element per line * @see https://eslint.style/rules/jsx-one-expression-per-line */ "@stylistic/jsx-one-expression-per-line"?: Linter.RuleEntry<StylisticJsxOneExpressionPerLine>; /** * Enforce PascalCase for user-defined JSX components * @see https://eslint.style/rules/jsx-pascal-case */ "@stylistic/jsx-pascal-case"?: Linter.RuleEntry<StylisticJsxPascalCase>; /** * 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<StylisticJsxQuotes>; /** * Disallow extra closing tags for components without children * @see https://eslint.style/rules/jsx-self-closing-comp */ "@stylistic/jsx-self-closing-comp"?: Linter.RuleEntry<StylisticJsxSelfClosingComp>; /** * Enforce props alphabetical sorting * @see https://eslint.style/rules/jsx-sort-props * @deprecated */ "@stylistic/jsx-sort-props"?: Linter.RuleEntry<StylisticJsxSortProps>; /** * 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<StylisticJsxTagSpacing>; /** * Disallow missing parentheses around multiline JSX * @see https://eslint.style/rules/jsx-wrap-multilines */ "@stylistic/jsx-wrap-multilines"?: Linter.RuleEntry<StylisticJsxWrapMultilines>; /** * 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<StylisticKeySpacing>; /** * Enforce consistent spacing before and after keywords * @see https://eslint.style/rules/keyword-spacing */ "@stylistic/keyword-spacing"?: Linter.RuleEntry<StylisticKeywordSpacing>; /** * Enforce position of line comments * @see https://eslint.style/rules/line-comment-position */ "@stylistic/line-comment-position"?: Linter.RuleEntry<StylisticLineCommentPosition>; /** * Enforce consistent linebreak style * @see https://eslint.style/rules/linebreak-style */ "@stylistic/linebreak-style"?: Linter.RuleEntry<StylisticLinebreakStyle>; /** * Require empty lines around comments * @see https://eslint.style/rules/lines-around-comment */ "@stylistic/lines-around-comment"?: Linter.RuleEntry<StylisticLinesAroundComment>; /** * 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<StylisticLinesBetweenClassMembers>; /** * Enforce a maximum line length * @see https://eslint.style/rules/max-len */ "@stylistic/max-len"?: Linter.RuleEntry<StylisticMaxLen>; /** * 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<StylisticMaxStatementsPerLine>; /** * 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<StylisticMemberDelimiterStyle>; /** * Enforce a particular style for multiline comments * @see https://eslint.style/rules/multiline-comment-style */ "@stylistic/multiline-comment-style"?: Linter.RuleEntry<StylisticMultilineCommentStyle>; /** * Enforce newlines between operands of ternary expressions * @see https://eslint.style/rules/multiline-ternary */ "@stylistic/multiline-ternary"?: Linter.RuleEntry<StylisticMultilineTernary>; /** * Enforce or disallow parentheses when invoking a constructor with no arguments * @see https://eslint.style/rules/new-parens */ "@stylistic/new-parens"?: Linter.RuleEntry<StylisticNewParens>; /** * 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<StylisticNewlinePerChainedCall>; /** * Disallow arrow functions where they could be confused with comparisons * @see https://eslint.style/rules/no-confusing-arrow */ "@stylistic/no-confusing-arrow"?: Linter.RuleEntry<StylisticNoConfusingArrow>; /** * Disallow unnecessary parentheses * @see https://eslint.style/rules/no-extra-parens */ "@stylistic/no-extra-parens"?: Linter.RuleEntry<StylisticNoExtraParens>; /** * 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<StylisticNoMixedOperators>; /** * 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<StylisticNoMixedSpacesAndTabs>; /** * Disallow multiple spaces * @see https://eslint.style/rules/no-multi-spaces */ "@stylistic/no-multi-spaces"?: Linter.RuleEntry<StylisticNoMultiSpaces>; /** * Disallow multiple empty lines * @see https://eslint.style/rules/no-multiple-empty-lines */ "@stylistic/no-multiple-empty-lines"?: Linter.RuleEntry<StylisticNoMultipleEmptyLines>; /** * Disallow all tabs * @see https://eslint.style/rules/no-tabs */ "@stylistic/no-tabs"?: Linter.RuleEntry<StylisticNoTabs>; /** * Disallow trailing whitespace at the end of lines * @see https://eslint.style/rules/no-trailing-spaces */ "@stylistic/no-trailing-spaces"?: Linter.RuleEntry<StylisticNoTrailingSpaces>; /** * 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<StylisticNonblockStatementBodyPosition>; /** * Enforce consistent line breaks after opening and before closing braces * @see https://eslint.style/rules/object-curly-newline */ "@stylistic/object-curly-newline"?: Linter.RuleEntry<StylisticObjectCurlyNewline>; /** * Enforce consistent spacing inside braces * @see https://eslint.style/rules/object-curly-spacing */ "@stylistic/object-curly-spacing"?: Linter.RuleEntry<StylisticObjectCurlySpacing>; /** * Enforce placing object properties on separate lines * @see https://eslint.style/rules/object-property-newline */ "@stylistic/object-property-newline"?: Linter.RuleEntry<StylisticObjectPropertyNewline>; /** * 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<StylisticOneVarDeclarationPerLine>; /** * Enforce consistent linebreak style for operators * @see https://eslint.style/rules/operator-linebreak */ "@stylistic/operator-linebreak"?: Linter.RuleEntry<StylisticOperatorLinebreak>; /** * Require or disallow padding within blocks * @see https://eslint.style/rules/padded-blocks */ "@stylistic/padded-blocks"?: Linter.RuleEntry<StylisticPaddedBlocks>; /** * Require or disallow padding lines between statements * @see https://eslint.style/rules/padding-line-between-statements */ "@stylistic/padding-line-between-statements"?: Linter.RuleEntry<StylisticPaddingLineBetweenStatements>; /** * Require quotes around object literal, type literal, interfaces and enums property names * @see https://eslint.style/rules/quote-props */ "@stylistic/quote-props"?: Linter.RuleEntry<StylisticQuoteProps>; /** * Enforce the consistent use of either backticks, double, or single quotes * @see https://eslint.style/rules/quotes */ "@stylistic/quotes"?: Linter.RuleEntry<StylisticQuotes>; /** * Enforce spacing between rest and spread operators and their expressions * @see https://eslint.style/rules/rest-spread-spacing */ "@stylistic/rest-spread-spacing"?: Linter.RuleEntry<StylisticRestSpreadSpacing>; /** * Require or disallow semicolons instead of ASI * @see https://eslint.style/rules/semi */ "@stylistic/semi"?: Linter.RuleEntry<StylisticSemi>; /** * Enforce consistent spacing before and after semicolons * @see https://eslint.style/rules/semi-spacing */ "@stylistic/semi-spacing"?: Linter.RuleEntry<StylisticSemiSpacing>; /** * Enforce location of semicolons * @see https://eslint.style/rules/semi-style */ "@stylistic/semi-style"?: Linter.RuleEntry<StylisticSemiStyle>; /** * Enforce consistent spacing before blocks * @see https://eslint.style/rules/space-before-blocks */ "@stylistic/space-before-blocks"?: Linter.RuleEntry<StylisticSpaceBeforeBlocks>; /** * Enforce consistent spacing before function parenthesis * @see https://eslint.style/rules/space-before-function-paren */ "@stylistic/space-before-function-paren"?: Linter.RuleEntry<StylisticSpaceBeforeFunctionParen>; /** * Enforce consistent spacing inside parentheses * @see https://eslint.style/rules/space-in-parens */ "@stylistic/space-in-parens"?: Linter.RuleEntry<StylisticSpaceInParens>; /** * Require spacing around infix operators * @see https://eslint.style/rules/space-infix-ops */ "@stylistic/space-infix-ops"?: Linter.RuleEntry<StylisticSpaceInfixOps>; /** * Enforce consistent spacing before or after unary operators * @see https://eslint.style/rules/space-unary-ops */ "@stylistic/space-unary-ops"?: Linter.RuleEntry<StylisticSpaceUnaryOps>; /** * Enforce consistent spacing after the `//` or `/*` in a comment * @see https://eslint.style/rules/spaced-comment */ "@stylistic/spaced-comment"?: Linter.RuleEntry<StylisticSpacedComment>; /** * Enforce spacing around colons of switch statements * @see https://eslint.style/rules/switch-colon-spacing */ "@stylistic/switch-colon-spacing"?: Linter.RuleEntry<StylisticSwitchColonSpacing>; /** * Require or disallow spacing around embedded expressions of template strings * @see https://eslint.style/rules/template-curly-spacing */ "@stylistic/template-curly-spacing"?: Linter.RuleEntry<StylisticTemplateCurlySpacing>; /** * Require or disallow spacing between template tags and their literals * @see https://eslint.style/rules/template-tag-spacing */ "@stylistic/template-tag-spacing"?: Linter.RuleEntry<StylisticTemplateTagSpacing>; /** * Require consistent spacing around type annotations * @see https://eslint.style/rules/type-annotation-spacing */ "@stylistic/type-annotation-spacing"?: Linter.RuleEntry<StylisticTypeAnnotationSpacing>; /** * 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<StylisticWrapIife>; /** * 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<StylisticYieldStarSpacing>; /** * 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<T>` for arrays * @see https://typescript-eslint.io/rules/array-type */ "@typescript-eslint/array-type"?: Linter.RuleEntry<TypescriptEslintArrayType>; /** * 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-<directive>` comments or require descriptions after directives * @see https://typescript-eslint.io/rules/ban-ts-comment */ "@typescript-eslint/ban-ts-comment"?: Linter.RuleEntry<TypescriptEslintBanTsComment>; /** * Disallow `// tslint:<rule-flag>` 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<TypescriptEslintClassLiteralPropertyStyle>; /** * Enforce that class methods utilize `this` * @see https://typescript-eslint.io/rules/class-methods-use-this */ "@typescript-eslint/class-methods-use-this"?: Linter.RuleEntry<TypescriptEslintClassMethodsUseThis>; /** * 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<TypescriptEslintConsistentGenericConstructors>; /** * Require or disallow the `Record` type * @see https://typescript-eslint.io/rules/consistent-indexed-object-style */ "@typescript-eslint/consistent-indexed-object-style"?: Linter.RuleEntry<TypescriptEslintConsistentIndexedObjectStyle>; /** * Require `return` statements to either always or never specify values * @see https://typescript-eslint.io/rules/consistent-return */ "@typescript-eslint/consistent-return"?: Linter.RuleEntry<TypescriptEslintConsistentReturn>; /** * Enforce consistent usage of type assertions * @see https://typescript-eslint.io/rules/consistent-type-assertions */ "@typescript-eslint/consistent-type-assertions"?: Linter.RuleEntry<TypescriptEslintConsistentTypeAssertions>; /** * 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<TypescriptEslintConsistentTypeDefinitions>; /** * Enforce consistent usage of type exports * @see https://typescript-eslint.io/rules/consistent-type-exports */ "@typescript-eslint/consistent-type-exports"?: Linter.RuleEntry<TypescriptEslintConsistentTypeExports>; /** * Enforce consistent usage of type imports * @see https://typescript-eslint.io/rules/consistent-type-imports */ "@typescript-eslint/consistent-type-imports"?: Linter.RuleEntry<TypescriptEslintConsistentTypeImports>; /** * 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<TypescriptEslintDotNotation>; /** * 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<TypescriptEslintExplicitFunctionReturnType>; /** * 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<TypescriptEslintExplicitMemberAccessibility>; /** * 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<TypescriptEslintExplicitModuleBoundaryTypes>; /** * Require or disallow initialization in variable declarations * @see https://typescript-eslint.io/rules/init-declarations */ "@typescript-eslint/init-declarations"?: Linter.RuleEntry<TypescriptEslintInitDeclarations>; /** * Enforce a maximum number of parameters in function definitions * @see https://typescript-eslint.io/rules/max-params */ "@typescript-eslint/max-params"?: Linter.RuleEntry<TypescriptEslintMaxParams>; /** * Require a consistent member declaration order * @see https://typescript-eslint.io/rules/member-ordering */ "@typescript-eslint/member-ordering"?: Linter.RuleEntry<TypescriptEslintMemberOrdering>; /** * Enforce using a particular method signature syntax * @see https://typescript-eslint.io/rules/method-signature-style */ "@typescript-eslint/method-signature-style"?: Linter.RuleEntry<TypescriptEslintMethodSignatureStyle>; /** * Enforce naming conventions for everything across a codebase * @see https://typescript-eslint.io/rules/naming-convention */ "@typescript-eslint/naming-convention"?: Linter.RuleEntry<TypescriptEslintNamingConvention>; /** * 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<TypescriptEslintNoBaseToString>; /** * 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<TypescriptEslintNoConfusingVoidExpression>; /** * Disallow using code marked as `@deprecated` * @see https://typescript-eslint.io/rules/no-deprecated */ "@typescript-eslint/no-deprecated"?: Linter.RuleEntry<TypescriptEslintNoDeprecated>; /** * 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<TypescriptEslintNoDuplicateTypeConstituents>; /** * 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<TypescriptEslintNoEmptyFunction>; /** * Disallow the declaration of empty interfaces * @see https://typescript-eslint.io/rules/no-empty-interface * @deprecated */ "@typescript-eslint/no-empty-interface"?: Linter.RuleEntry<TypescriptEslintNoEmptyInterface>; /** * 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<TypescriptEslintNoEmptyObjectType>; /** * Disallow the `any` type * @see https://typescript-eslint.io/rules/no-explicit-any */ "@typescript-eslint/no-explicit-any"?: Linter.RuleEntry<TypescriptEslintNoExplicitAny>; /** * 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<TypescriptEslintNoExtraneousClass>; /** * Require Promise-like statements to be handled appropriately * @see https://typescript-eslint.io/rules/no-floating-promises */ "@typescript-eslint/no-floating-promises"?: Linter.RuleEntry<TypescriptEslintNoFloatingPromises>; /** * 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<TypescriptEslintNoInferrableTypes>; /** * 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<TypescriptEslintNoInvalidThis>; /** * 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<TypescriptEslintNoInvalidVoidType>; /** * 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<TypescriptEslintNoMagicNumbers>; /** * 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<TypescriptEslintNoMeaninglessVoidOperator>; /** * 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<TypescriptEslintNoMisusedPromises>; /** * 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<TypescriptEslintNoMisusedSpread>; /** * 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<TypescriptEslintNoNamespace>; /** * 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<TypescriptEslintNoRedeclare>; /** * 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<TypescriptEslintNoRequireImports>; /** * Disallow specified modules when loaded by `import` * @see https://typescript-eslint.io/rules/no-restricted-imports */ "@typescript-eslint/no-restricted-imports"?: Linter.RuleEntry<TypescriptEslintNoRestrictedImports>; /** * Disallow certain types * @see https://typescript-eslint.io/rules/no-restricted-types */ "@typescript-eslint/no-restricted-types"?: Linter.RuleEntry<TypescriptEslintNoRestrictedTypes>; /** * 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<TypescriptEslintNoShadow>; /** * Disallow aliasing `this` * @see https://typescript-eslint.io/rules/no-this-alias */ "@typescript-eslint/no-this-alias"?: Linter.RuleEntry<TypescriptEslintNoThisAlias>; /** * Disallow type aliases * @see https://typescript-eslint.io/rules/no-type-alias * @deprecated */ "@typescript-eslint/no-type-alias"?: Linter.RuleEntry<TypescriptEslintNoTypeAlias>; /** * 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<TypescriptEslintNoUnnecessaryBooleanLiteralCompare>; /** * 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<TypescriptEslintNoUnnecessaryCondition>; /** * 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<TypescriptEslintNoUnnecessaryTypeAssertion>; /** * 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<TypescriptEslintNoUnsafeMemberAccess>; /** * 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<TypescriptEslintNoUnusedExpressions>; /** * 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<TypescriptEslintNoUnusedVars>; /** * 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<TypescriptEslintNoUseBeforeDefine>; /** * 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<TypescriptEslintNoUselessDefaultAssignment>; /** * 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<TypescriptEslintNoVarRequires>; /** * 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<TypescriptEslintOnlyThrowError>; /** * Require or disallow parameter properties in class constructors * @see https://typescript-eslint.io/rules/parameter-properties */ "@typescript-eslint/parameter-properties"?: Linter.RuleEntry<TypescriptEslintParameterProperties>; /** * 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<TypescriptEslintPreferDestructuring>; /** * 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<TypescriptEslintPreferLiteralEnumMember>; /** * 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<TypescriptEslintPreferNullishCoalescing>; /** * 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<TypescriptEslintPreferOptionalChain>; /** * 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<TypescriptEslintPreferPromiseRejectErrors>; /** * 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<TypescriptEslintPreferReadonly>; /** * 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<TypescriptEslintPreferReadonlyParameterTypes>; /** * 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<TypescriptEslintPreferStringStartsEndsWith>; /** * 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<TypescriptEslintPromiseFunctionAsync>; /** * 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<TypescriptEslintRequireArraySortCompare>; /** * 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<TypescriptEslintRestrictPlusOperands>; /** * 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<TypescriptEslintRestrictTemplateExpressions>; /** * Enforce consistent awaiting of returned promises * @see https://typescript-eslint.io/rules/return-await */ "@typescript-eslint/return-await"?: Linter.RuleEntry<TypescriptEslintReturnAwait>; /** * Enforce constituents of a type union/intersection to be sorted alphabetically * @see https://typescript-eslint.io/rules/sort-t