@kazupon/eslint-config 0.8.0 → 0.9.1

package/dist/types/gens/typescript.d.ts

@@ -0,0 +1,2253 @@
+import type { Linter } from 'eslint';
+export interface TypescriptRules {
+    /**
+     * 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<[]>;
+    /**
+     * Disallow certain types
+     * @see https://typescript-eslint.io/rules/ban-types
+     */
+    '@typescript-eslint/ban-types'?: Linter.RuleEntry<TypescriptEslintBanTypes>;
+    /**
+     * Disallow or enforce spaces inside of blocks after opening block and before closing block
+     * @see https://typescript-eslint.io/rules/block-spacing
+     * @deprecated
+     */
+    '@typescript-eslint/block-spacing'?: Linter.RuleEntry<TypescriptEslintBlockSpacing>;
+    /**
+     * Enforce consistent brace style for blocks
+     * @see https://typescript-eslint.io/rules/brace-style
+     * @deprecated
+     */
+    '@typescript-eslint/brace-style'?: Linter.RuleEntry<TypescriptEslintBraceStyle>;
+    /**
+     * 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>;
+    /**
+     * Require or disallow trailing commas
+     * @see https://typescript-eslint.io/rules/comma-dangle
+     * @deprecated
+     */
+    '@typescript-eslint/comma-dangle'?: Linter.RuleEntry<TypescriptEslintCommaDangle>;
+    /**
+     * Enforce consistent spacing before and after commas
+     * @see https://typescript-eslint.io/rules/comma-spacing
+     * @deprecated
+     */
+    '@typescript-eslint/comma-spacing'?: Linter.RuleEntry<TypescriptEslintCommaSpacing>;
+    /**
+     * 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 spacing between function identifiers and their invocations
+     * @see https://typescript-eslint.io/rules/func-call-spacing
+     * @deprecated
+     */
+    '@typescript-eslint/func-call-spacing'?: Linter.RuleEntry<TypescriptEslintFuncCallSpacing>;
+    /**
+     * Enforce consistent indentation
+     * @see https://typescript-eslint.io/rules/indent
+     * @deprecated
+     */
+    '@typescript-eslint/indent'?: Linter.RuleEntry<TypescriptEslintIndent>;
+    /**
+     * Require or disallow initialization in variable declarations
+     * @see https://typescript-eslint.io/rules/init-declarations
+     */
+    '@typescript-eslint/init-declarations'?: Linter.RuleEntry<TypescriptEslintInitDeclarations>;
+    /**
+     * Enforce consistent spacing between property names and type annotations in types and interfaces
+     * @see https://typescript-eslint.io/rules/key-spacing
+     * @deprecated
+     */
+    '@typescript-eslint/key-spacing'?: Linter.RuleEntry<TypescriptEslintKeySpacing>;
+    /**
+     * Enforce consistent spacing before and after keywords
+     * @see https://typescript-eslint.io/rules/keyword-spacing
+     * @deprecated
+     */
+    '@typescript-eslint/keyword-spacing'?: Linter.RuleEntry<TypescriptEslintKeywordSpacing>;
+    /**
+     * Require empty lines around comments
+     * @see https://typescript-eslint.io/rules/lines-around-comment
+     * @deprecated
+     */
+    '@typescript-eslint/lines-around-comment'?: Linter.RuleEntry<TypescriptEslintLinesAroundComment>;
+    /**
+     * Require or disallow an empty line between class members
+     * @see https://typescript-eslint.io/rules/lines-between-class-members
+     * @deprecated
+     */
+    '@typescript-eslint/lines-between-class-members'?: Linter.RuleEntry<TypescriptEslintLinesBetweenClassMembers>;
+    /**
+     * 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 specific member delimiter style for interfaces and type literals
+     * @see https://typescript-eslint.io/rules/member-delimiter-style
+     * @deprecated
+     */
+    '@typescript-eslint/member-delimiter-style'?: Linter.RuleEntry<TypescriptEslintMemberDelimiterStyle>;
+    /**
+     * 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()` 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 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
+     */
+    '@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 unnecessary parentheses
+     * @see https://typescript-eslint.io/rules/no-extra-parens
+     * @deprecated
+     */
+    '@typescript-eslint/no-extra-parens'?: Linter.RuleEntry<TypescriptEslintNoExtraParens>;
+    /**
+     * Disallow unnecessary semicolons
+     * @see https://typescript-eslint.io/rules/no-extra-semi
+     * @deprecated
+     */
+    '@typescript-eslint/no-extra-semi'?: 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 methods
+     * @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
+     */
+    '@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 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 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 throwing literals as exceptions
+     * @see https://typescript-eslint.io/rules/no-throw-literal
+     * @deprecated
+     */
+    '@typescript-eslint/no-throw-literal'?: Linter.RuleEntry<TypescriptEslintNoThrowLiteral>;
+    /**
+     * 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 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 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 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<[]>;
+    /**
+     * 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 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 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 unnecessary template expressions
+     * @see https://typescript-eslint.io/rules/no-useless-template-literals
+     * @deprecated
+     */
+    '@typescript-eslint/no-useless-template-literals'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow `require` statements except in import statements
+     * @see https://typescript-eslint.io/rules/no-var-requires
+     */
+    '@typescript-eslint/no-var-requires'?: Linter.RuleEntry<TypescriptEslintNoVarRequires>;
+    /**
+     * Enforce non-null assertions over explicit type casts
+     * @see https://typescript-eslint.io/rules/non-nullable-type-assertion-style
+     */
+    '@typescript-eslint/non-nullable-type-assertion-style'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce consistent spacing inside braces
+     * @see https://typescript-eslint.io/rules/object-curly-spacing
+     * @deprecated
+     */
+    '@typescript-eslint/object-curly-spacing'?: Linter.RuleEntry<TypescriptEslintObjectCurlySpacing>;
+    /**
+     * 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 padding lines between statements
+     * @see https://typescript-eslint.io/rules/padding-line-between-statements
+     * @deprecated
+     */
+    '@typescript-eslint/padding-line-between-statements'?: Linter.RuleEntry<TypescriptEslintPaddingLineBetweenStatements>;
+    /**
+     * 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 casting
+     * @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 the consistent use of either backticks, double, or single quotes
+     * @see https://typescript-eslint.io/rules/quotes
+     * @deprecated
+     */
+    '@typescript-eslint/quotes'?: Linter.RuleEntry<TypescriptEslintQuotes>;
+    /**
+     * 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>;
+    /**
+     * Require or disallow semicolons instead of ASI
+     * @see https://typescript-eslint.io/rules/semi
+     * @deprecated
+     */
+    '@typescript-eslint/semi'?: Linter.RuleEntry<TypescriptEslintSemi>;
+    /**
+     * 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<TypescriptEslintSortTypeConstituents>;
+    /**
+     * Enforce consistent spacing before blocks
+     * @see https://typescript-eslint.io/rules/space-before-blocks
+     * @deprecated
+     */
+    '@typescript-eslint/space-before-blocks'?: Linter.RuleEntry<TypescriptEslintSpaceBeforeBlocks>;
+    /**
+     * Enforce consistent spacing before function parenthesis
+     * @see https://typescript-eslint.io/rules/space-before-function-paren
+     * @deprecated
+     */
+    '@typescript-eslint/space-before-function-paren'?: Linter.RuleEntry<TypescriptEslintSpaceBeforeFunctionParen>;
+    /**
+     * Require spacing around infix operators
+     * @see https://typescript-eslint.io/rules/space-infix-ops
+     * @deprecated
+     */
+    '@typescript-eslint/space-infix-ops'?: Linter.RuleEntry<TypescriptEslintSpaceInfixOps>;
+    /**
+     * Disallow certain types in boolean expressions
+     * @see https://typescript-eslint.io/rules/strict-boolean-expressions
+     */
+    '@typescript-eslint/strict-boolean-expressions'?: Linter.RuleEntry<TypescriptEslintStrictBooleanExpressions>;
+    /**
+     * Require switch-case statements to be exhaustive
+     * @see https://typescript-eslint.io/rules/switch-exhaustiveness-check
+     */
+    '@typescript-eslint/switch-exhaustiveness-check'?: Linter.RuleEntry<TypescriptEslintSwitchExhaustivenessCheck>;
+    /**
+     * 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<TypescriptEslintTripleSlashReference>;
+    /**
+     * Require consistent spacing around type annotations
+     * @see https://typescript-eslint.io/rules/type-annotation-spacing
+     * @deprecated
+     */
+    '@typescript-eslint/type-annotation-spacing'?: Linter.RuleEntry<TypescriptEslintTypeAnnotationSpacing>;
+    /**
+     * Require type annotations in certain places
+     * @see https://typescript-eslint.io/rules/typedef
+     */
+    '@typescript-eslint/typedef'?: Linter.RuleEntry<TypescriptEslintTypedef>;
+    /**
+     * Enforce unbound methods are called with their expected scope
+     * @see https://typescript-eslint.io/rules/unbound-method
+     */
+    '@typescript-eslint/unbound-method'?: Linter.RuleEntry<TypescriptEslintUnboundMethod>;
+    /**
+     * 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<TypescriptEslintUnifiedSignatures>;
+    /**
+     * Enforce typing arguments in `.catch()` 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<[]>;
+}
+type TypescriptEslintArrayType = [] | [
+    {
+        default?: ("array" | "generic" | "array-simple");
+        readonly?: ("array" | "generic" | "array-simple");
+    }
+];
+type TypescriptEslintBanTsComment = [] | [
+    {
+        "ts-expect-error"?: (boolean | "allow-with-description" | {
+            descriptionFormat?: string;
+        });
+        "ts-ignore"?: (boolean | "allow-with-description" | {
+            descriptionFormat?: string;
+        });
+        "ts-nocheck"?: (boolean | "allow-with-description" | {
+            descriptionFormat?: string;
+        });
+        "ts-check"?: (boolean | "allow-with-description" | {
+            descriptionFormat?: string;
+        });
+        minimumDescriptionLength?: number;
+    }
+];
+type TypescriptEslintBanTypes = [] | [
+    {
+        types?: {
+            [k: string]: (null | false | true | string | {
+                message?: string;
+                fixWith?: string;
+                suggest?: string[];
+            }) | undefined;
+        };
+        extendDefaults?: boolean;
+    }
+];
+type TypescriptEslintBlockSpacing = [] | [("always" | "never")];
+type TypescriptEslintBraceStyle = [] | [("1tbs" | "stroustrup" | "allman")] | [
+    ("1tbs" | "stroustrup" | "allman"),
+    {
+        allowSingleLine?: boolean;
+    }
+];
+type TypescriptEslintClassLiteralPropertyStyle = [] | [("fields" | "getters")];
+type TypescriptEslintClassMethodsUseThis = [] | [
+    {
+        exceptMethods?: string[];
+        enforceForClassFields?: boolean;
+        ignoreOverrideMethods?: boolean;
+        ignoreClassesThatImplementAnInterface?: (boolean | "public-fields");
+    }
+];
+type TypescriptEslintCommaDangle = [] | [
+    (_TypescriptEslintCommaDangleValue | {
+        arrays?: _TypescriptEslintCommaDangleValueWithIgnore;
+        objects?: _TypescriptEslintCommaDangleValueWithIgnore;
+        imports?: _TypescriptEslintCommaDangleValueWithIgnore;
+        exports?: _TypescriptEslintCommaDangleValueWithIgnore;
+        functions?: _TypescriptEslintCommaDangleValueWithIgnore;
+        enums?: _TypescriptEslintCommaDangleValueWithIgnore;
+        generics?: _TypescriptEslintCommaDangleValueWithIgnore;
+        tuples?: _TypescriptEslintCommaDangleValueWithIgnore;
+    })
+];
+type _TypescriptEslintCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline");
+type _TypescriptEslintCommaDangleValueWithIgnore = ("always-multiline" | "always" | "never" | "only-multiline" | "ignore");
+type TypescriptEslintCommaSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+    }
+];
+type TypescriptEslintConsistentGenericConstructors = [] | [("type-annotation" | "constructor")];
+type TypescriptEslintConsistentIndexedObjectStyle = [] | [("record" | "index-signature")];
+type TypescriptEslintConsistentReturn = [] | [
+    {
+        treatUndefinedAsUnspecified?: boolean;
+    }
+];
+type TypescriptEslintConsistentTypeAssertions = [] | [
+    ({
+        assertionStyle: "never";
+    } | {
+        assertionStyle: ("as" | "angle-bracket");
+        objectLiteralTypeAssertions?: ("allow" | "allow-as-parameter" | "never");
+    })
+];
+type TypescriptEslintConsistentTypeDefinitions = [] | [("interface" | "type")];
+type TypescriptEslintConsistentTypeExports = [] | [
+    {
+        fixMixedExportsWithInlineTypeSpecifier?: boolean;
+    }
+];
+type TypescriptEslintConsistentTypeImports = [] | [
+    {
+        disallowTypeAnnotations?: boolean;
+        fixStyle?: ("separate-type-imports" | "inline-type-imports");
+        prefer?: ("type-imports" | "no-type-imports");
+    }
+];
+type TypescriptEslintDotNotation = [] | [
+    {
+        allowKeywords?: boolean;
+        allowPattern?: string;
+        allowPrivateClassPropertyAccess?: boolean;
+        allowProtectedClassPropertyAccess?: boolean;
+        allowIndexSignaturePropertyAccess?: boolean;
+    }
+];
+type TypescriptEslintExplicitFunctionReturnType = [] | [
+    {
+        allowConciseArrowFunctionExpressionsStartingWithVoid?: boolean;
+        allowExpressions?: boolean;
+        allowHigherOrderFunctions?: boolean;
+        allowTypedFunctionExpressions?: boolean;
+        allowDirectConstAssertionInArrowFunctions?: boolean;
+        allowFunctionsWithoutTypeParameters?: boolean;
+        allowedNames?: string[];
+        allowIIFEs?: boolean;
+    }
+];
+type TypescriptEslintExplicitMemberAccessibility = [] | [
+    {
+        accessibility?: ("explicit" | "no-public" | "off");
+        overrides?: {
+            accessors?: ("explicit" | "no-public" | "off");
+            constructors?: ("explicit" | "no-public" | "off");
+            methods?: ("explicit" | "no-public" | "off");
+            properties?: ("explicit" | "no-public" | "off");
+            parameterProperties?: ("explicit" | "no-public" | "off");
+        };
+        ignoredMethodNames?: string[];
+    }
+];
+type TypescriptEslintExplicitModuleBoundaryTypes = [] | [
+    {
+        allowArgumentsExplicitlyTypedAsAny?: boolean;
+        allowDirectConstAssertionInArrowFunctions?: boolean;
+        allowedNames?: string[];
+        allowHigherOrderFunctions?: boolean;
+        allowTypedFunctionExpressions?: boolean;
+    }
+];
+type TypescriptEslintFuncCallSpacing = ([] | ["never"] | [] | ["always"] | [
+    "always",
+    {
+        allowNewlines?: boolean;
+    }
+]);
+type TypescriptEslintIndent = [] | [("tab" | number)] | [
+    ("tab" | number),
+    {
+        SwitchCase?: number;
+        VariableDeclarator?: ((number | ("first" | "off")) | {
+            var?: (number | ("first" | "off"));
+            let?: (number | ("first" | "off"));
+            const?: (number | ("first" | "off"));
+        });
+        outerIIFEBody?: (number | "off");
+        MemberExpression?: (number | "off");
+        FunctionDeclaration?: {
+            parameters?: (number | ("first" | "off"));
+            body?: number;
+        };
+        FunctionExpression?: {
+            parameters?: (number | ("first" | "off"));
+            body?: number;
+        };
+        StaticBlock?: {
+            body?: number;
+        };
+        CallExpression?: {
+            arguments?: (number | ("first" | "off"));
+        };
+        ArrayExpression?: (number | ("first" | "off"));
+        ObjectExpression?: (number | ("first" | "off"));
+        ImportDeclaration?: (number | ("first" | "off"));
+        flatTernaryExpressions?: boolean;
+        offsetTernaryExpressions?: boolean;
+        ignoredNodes?: string[];
+        ignoreComments?: boolean;
+    }
+];
+type TypescriptEslintInitDeclarations = ([] | ["always"] | [] | ["never"] | [
+    "never",
+    {
+        ignoreForLoopInit?: boolean;
+    }
+]);
+type TypescriptEslintKeySpacing = [] | [
+    ({
+        align?: (("colon" | "value") | {
+            mode?: ("strict" | "minimum");
+            on?: ("colon" | "value");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        });
+        mode?: ("strict" | "minimum");
+        beforeColon?: boolean;
+        afterColon?: boolean;
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            align?: (("colon" | "value") | {
+                mode?: ("strict" | "minimum");
+                on?: ("colon" | "value");
+                beforeColon?: boolean;
+                afterColon?: boolean;
+            });
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        align?: {
+            mode?: ("strict" | "minimum");
+            on?: ("colon" | "value");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    })
+];
+type TypescriptEslintKeywordSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+        overrides?: {
+            abstract?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            as?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            async?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            await?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            boolean?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            break?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            byte?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            case?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            catch?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            char?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            class?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            const?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            continue?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            debugger?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            default?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            delete?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            do?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            double?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            else?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            enum?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            export?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            extends?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            false?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            final?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            finally?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            float?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            for?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            from?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            function?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            get?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            goto?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            if?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            implements?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            import?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            in?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            instanceof?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            int?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            interface?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            let?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            long?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            native?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            new?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            null?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            of?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            package?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            private?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            protected?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            public?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            return?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            set?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            short?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            static?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            super?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            switch?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            synchronized?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            this?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            throw?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            throws?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            transient?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            true?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            try?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            typeof?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            var?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            void?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            volatile?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            while?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            with?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            yield?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            type?: {
+                before?: boolean;
+                after?: boolean;
+            };
+        };
+    }
+];
+type TypescriptEslintLinesAroundComment = [] | [
+    {
+        beforeBlockComment?: boolean;
+        afterBlockComment?: boolean;
+        beforeLineComment?: boolean;
+        afterLineComment?: boolean;
+        allowBlockStart?: boolean;
+        allowBlockEnd?: boolean;
+        allowClassStart?: boolean;
+        allowClassEnd?: boolean;
+        allowObjectStart?: boolean;
+        allowObjectEnd?: boolean;
+        allowArrayStart?: boolean;
+        allowArrayEnd?: boolean;
+        allowInterfaceStart?: boolean;
+        allowInterfaceEnd?: boolean;
+        allowTypeStart?: boolean;
+        allowTypeEnd?: boolean;
+        allowEnumStart?: boolean;
+        allowEnumEnd?: boolean;
+        allowModuleStart?: boolean;
+        allowModuleEnd?: boolean;
+        ignorePattern?: string;
+        applyDefaultIgnorePatterns?: boolean;
+    }
+];
+type TypescriptEslintLinesBetweenClassMembers = [] | [
+    ({
+        enforce: [
+            {
+                blankLine: ("always" | "never");
+                prev: ("method" | "field" | "*");
+                next: ("method" | "field" | "*");
+            },
+            ...({
+                blankLine: ("always" | "never");
+                prev: ("method" | "field" | "*");
+                next: ("method" | "field" | "*");
+            })[]
+        ];
+    } | ("always" | "never"))
+] | [
+    ({
+        enforce: [
+            {
+                blankLine: ("always" | "never");
+                prev: ("method" | "field" | "*");
+                next: ("method" | "field" | "*");
+            },
+            ...({
+                blankLine: ("always" | "never");
+                prev: ("method" | "field" | "*");
+                next: ("method" | "field" | "*");
+            })[]
+        ];
+    } | ("always" | "never")),
+    {
+        exceptAfterSingleLine?: boolean;
+        exceptAfterOverload?: boolean;
+    }
+];
+type TypescriptEslintMaxParams = [] | [
+    {
+        maximum?: number;
+        max?: number;
+        countVoidThis?: boolean;
+    }
+];
+type TypescriptEslintMemberDelimiterStyle = [] | [
+    {
+        multiline?: {
+            delimiter?: ("none" | "semi" | "comma");
+            requireLast?: boolean;
+        };
+        singleline?: {
+            delimiter?: ("semi" | "comma");
+            requireLast?: boolean;
+        };
+        overrides?: {
+            interface?: _TypescriptEslintMemberDelimiterStyle_DelimiterConfig;
+            typeLiteral?: _TypescriptEslintMemberDelimiterStyle_DelimiterConfig;
+        };
+        multilineDetection?: ("brackets" | "last-member");
+    }
+];
+interface _TypescriptEslintMemberDelimiterStyle_DelimiterConfig {
+    multiline?: {
+        delimiter?: ("none" | "semi" | "comma");
+        requireLast?: boolean;
+    };
+    singleline?: {
+        delimiter?: ("semi" | "comma");
+        requireLast?: boolean;
+    };
+}
+type TypescriptEslintMemberOrdering = [] | [
+    {
+        default?: ("never" | (("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization") | ("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization")[])[] | {
+            memberTypes?: ((("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization") | ("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization")[])[] | "never");
+            order?: ("alphabetically" | "alphabetically-case-insensitive" | "as-written" | "natural" | "natural-case-insensitive");
+            optionalityOrder?: ("optional-first" | "required-first");
+        });
+        classes?: ("never" | (("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization") | ("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization")[])[] | {
+            memberTypes?: ((("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization") | ("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization")[])[] | "never");
+            order?: ("alphabetically" | "alphabetically-case-insensitive" | "as-written" | "natural" | "natural-case-insensitive");
+            optionalityOrder?: ("optional-first" | "required-first");
+        });
+        classExpressions?: ("never" | (("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization") | ("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization")[])[] | {
+            memberTypes?: ((("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization") | ("readonly-signature" | "signature" | "readonly-field" | "public-readonly-field" | "public-decorated-readonly-field" | "decorated-readonly-field" | "static-readonly-field" | "public-static-readonly-field" | "instance-readonly-field" | "public-instance-readonly-field" | "abstract-readonly-field" | "public-abstract-readonly-field" | "protected-readonly-field" | "protected-decorated-readonly-field" | "protected-static-readonly-field" | "protected-instance-readonly-field" | "protected-abstract-readonly-field" | "private-readonly-field" | "private-decorated-readonly-field" | "private-static-readonly-field" | "private-instance-readonly-field" | "#private-readonly-field" | "#private-static-readonly-field" | "#private-instance-readonly-field" | "field" | "public-field" | "public-decorated-field" | "decorated-field" | "static-field" | "public-static-field" | "instance-field" | "public-instance-field" | "abstract-field" | "public-abstract-field" | "protected-field" | "protected-decorated-field" | "protected-static-field" | "protected-instance-field" | "protected-abstract-field" | "private-field" | "private-decorated-field" | "private-static-field" | "private-instance-field" | "#private-field" | "#private-static-field" | "#private-instance-field" | "method" | "public-method" | "public-decorated-method" | "decorated-method" | "static-method" | "public-static-method" | "instance-method" | "public-instance-method" | "abstract-method" | "public-abstract-method" | "protected-method" | "protected-decorated-method" | "protected-static-method" | "protected-instance-method" | "protected-abstract-method" | "private-method" | "private-decorated-method" | "private-static-method" | "private-instance-method" | "#private-method" | "#private-static-method" | "#private-instance-method" | "call-signature" | "constructor" | "public-constructor" | "protected-constructor" | "private-constructor" | "accessor" | "public-accessor" | "public-decorated-accessor" | "decorated-accessor" | "static-accessor" | "public-static-accessor" | "instance-accessor" | "public-instance-accessor" | "abstract-accessor" | "public-abstract-accessor" | "protected-accessor" | "protected-decorated-accessor" | "protected-static-accessor" | "protected-instance-accessor" | "protected-abstract-accessor" | "private-accessor" | "private-decorated-accessor" | "private-static-accessor" | "private-instance-accessor" | "#private-accessor" | "#private-static-accessor" | "#private-instance-accessor" | "get" | "public-get" | "public-decorated-get" | "decorated-get" | "static-get" | "public-static-get" | "instance-get" | "public-instance-get" | "abstract-get" | "public-abstract-get" | "protected-get" | "protected-decorated-get" | "protected-static-get" | "protected-instance-get" | "protected-abstract-get" | "private-get" | "private-decorated-get" | "private-static-get" | "private-instance-get" | "#private-get" | "#private-static-get" | "#private-instance-get" | "set" | "public-set" | "public-decorated-set" | "decorated-set" | "static-set" | "public-static-set" | "instance-set" | "public-instance-set" | "abstract-set" | "public-abstract-set" | "protected-set" | "protected-decorated-set" | "protected-static-set" | "protected-instance-set" | "protected-abstract-set" | "private-set" | "private-decorated-set" | "private-static-set" | "private-instance-set" | "#private-set" | "#private-static-set" | "#private-instance-set" | "static-initialization" | "static-static-initialization" | "public-static-static-initialization" | "instance-static-initialization" | "public-instance-static-initialization" | "abstract-static-initialization" | "public-abstract-static-initialization" | "protected-static-static-initialization" | "protected-instance-static-initialization" | "protected-abstract-static-initialization" | "private-static-static-initialization" | "private-instance-static-initialization" | "#private-static-static-initialization" | "#private-instance-static-initialization")[])[] | "never");
+            order?: ("alphabetically" | "alphabetically-case-insensitive" | "as-written" | "natural" | "natural-case-insensitive");
+            optionalityOrder?: ("optional-first" | "required-first");
+        });
+        interfaces?: ("never" | (("readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor") | ("readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor")[])[] | {
+            memberTypes?: ((("readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor") | ("readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor")[])[] | "never");
+            order?: ("alphabetically" | "alphabetically-case-insensitive" | "as-written" | "natural" | "natural-case-insensitive");
+            optionalityOrder?: ("optional-first" | "required-first");
+        });
+        typeLiterals?: ("never" | (("readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor") | ("readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor")[])[] | {
+            memberTypes?: ((("readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor") | ("readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor")[])[] | "never");
+            order?: ("alphabetically" | "alphabetically-case-insensitive" | "as-written" | "natural" | "natural-case-insensitive");
+            optionalityOrder?: ("optional-first" | "required-first");
+        });
+    }
+];
+type TypescriptEslintMethodSignatureStyle = [] | [("property" | "method")];
+type _TypescriptEslintNamingConventionFormatOptionsConfig = (_TypescriptEslintNamingConventionPredefinedFormats[] | null);
+type _TypescriptEslintNamingConventionPredefinedFormats = ("camelCase" | "strictCamelCase" | "PascalCase" | "StrictPascalCase" | "snake_case" | "UPPER_CASE");
+type _TypescriptEslintNamingConventionUnderscoreOptions = ("forbid" | "allow" | "require" | "requireDouble" | "allowDouble" | "allowSingleOrDouble");
+type _TypescriptEslintNamingConvention_PrefixSuffixConfig = string[];
+type _TypescriptEslintNamingConventionTypeModifiers = ("boolean" | "string" | "number" | "function" | "array");
+type TypescriptEslintNamingConvention = ({
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: ("default" | "variableLike" | "memberLike" | "typeLike" | "method" | "property" | "accessor" | "variable" | "function" | "parameter" | "parameterProperty" | "classicAccessor" | "enumMember" | "classMethod" | "objectLiteralMethod" | "typeMethod" | "classProperty" | "objectLiteralProperty" | "typeProperty" | "autoAccessor" | "class" | "interface" | "typeAlias" | "enum" | "typeParameter" | "import")[];
+    modifiers?: ("const" | "readonly" | "static" | "public" | "protected" | "private" | "#private" | "abstract" | "destructured" | "global" | "exported" | "unused" | "requiresQuotes" | "override" | "async" | "default" | "namespace")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "default";
+    modifiers?: ("const" | "readonly" | "static" | "public" | "protected" | "private" | "#private" | "abstract" | "destructured" | "global" | "exported" | "unused" | "requiresQuotes" | "override" | "async" | "default" | "namespace")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "variableLike";
+    modifiers?: ("unused" | "async")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "variable";
+    modifiers?: ("const" | "destructured" | "exported" | "global" | "unused" | "async")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "function";
+    modifiers?: ("exported" | "global" | "unused" | "async")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "parameter";
+    modifiers?: ("destructured" | "unused")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "memberLike";
+    modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "readonly" | "requiresQuotes" | "static" | "override" | "async")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "classProperty";
+    modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "readonly" | "requiresQuotes" | "static" | "override")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "objectLiteralProperty";
+    modifiers?: ("public" | "requiresQuotes")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "typeProperty";
+    modifiers?: ("public" | "readonly" | "requiresQuotes")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "parameterProperty";
+    modifiers?: ("private" | "protected" | "public" | "readonly")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "property";
+    modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "readonly" | "requiresQuotes" | "static" | "override" | "async")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "classMethod";
+    modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "requiresQuotes" | "static" | "override" | "async")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "objectLiteralMethod";
+    modifiers?: ("public" | "requiresQuotes" | "async")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "typeMethod";
+    modifiers?: ("public" | "requiresQuotes")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "method";
+    modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "requiresQuotes" | "static" | "override" | "async")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "classicAccessor";
+    modifiers?: ("abstract" | "private" | "protected" | "public" | "requiresQuotes" | "static" | "override")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "autoAccessor";
+    modifiers?: ("abstract" | "private" | "protected" | "public" | "requiresQuotes" | "static" | "override")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "accessor";
+    modifiers?: ("abstract" | "private" | "protected" | "public" | "requiresQuotes" | "static" | "override")[];
+    types?: _TypescriptEslintNamingConventionTypeModifiers[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "enumMember";
+    modifiers?: ("requiresQuotes")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "typeLike";
+    modifiers?: ("abstract" | "exported" | "unused")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "class";
+    modifiers?: ("abstract" | "exported" | "unused")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "interface";
+    modifiers?: ("exported" | "unused")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "typeAlias";
+    modifiers?: ("exported" | "unused")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "enum";
+    modifiers?: ("exported" | "unused")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "typeParameter";
+    modifiers?: ("unused")[];
+} | {
+    format: _TypescriptEslintNamingConventionFormatOptionsConfig;
+    custom?: _TypescriptEslintNamingConvention_MatchRegexConfig;
+    leadingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    trailingUnderscore?: _TypescriptEslintNamingConventionUnderscoreOptions;
+    prefix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    suffix?: _TypescriptEslintNamingConvention_PrefixSuffixConfig;
+    failureMessage?: string;
+    filter?: (string | _TypescriptEslintNamingConvention_MatchRegexConfig);
+    selector: "import";
+    modifiers?: ("default" | "namespace")[];
+})[];
+interface _TypescriptEslintNamingConvention_MatchRegexConfig {
+    match: boolean;
+    regex: string;
+}
+type TypescriptEslintNoBaseToString = [] | [
+    {
+        ignoredTypeNames?: string[];
+    }
+];
+type TypescriptEslintNoConfusingVoidExpression = [] | [
+    {
+        ignoreArrowShorthand?: boolean;
+        ignoreVoidOperator?: boolean;
+    }
+];
+type TypescriptEslintNoDuplicateTypeConstituents = [] | [
+    {
+        ignoreIntersections?: boolean;
+        ignoreUnions?: boolean;
+    }
+];
+type TypescriptEslintNoEmptyFunction = [] | [
+    {
+        allow?: ("functions" | "arrowFunctions" | "generatorFunctions" | "methods" | "generatorMethods" | "getters" | "setters" | "constructors" | "private-constructors" | "protected-constructors" | "asyncFunctions" | "asyncMethods" | "decoratedFunctions" | "overrideMethods")[];
+    }
+];
+type TypescriptEslintNoEmptyInterface = [] | [
+    {
+        allowSingleExtends?: boolean;
+    }
+];
+type TypescriptEslintNoEmptyObjectType = [] | [
+    {
+        allowInterfaces?: ("always" | "never" | "with-single-extends");
+        allowObjectTypes?: ("always" | "in-type-alias-with-name" | "never");
+        allowWithName?: string;
+    }
+];
+type TypescriptEslintNoExplicitAny = [] | [
+    {
+        fixToUnknown?: boolean;
+        ignoreRestArgs?: boolean;
+    }
+];
+type TypescriptEslintNoExtraParens = ([] | ["functions"] | [] | ["all"] | [
+    "all",
+    {
+        conditionalAssign?: boolean;
+        ternaryOperandBinaryExpressions?: boolean;
+        nestedBinaryExpressions?: boolean;
+        returnAssign?: boolean;
+        ignoreJSX?: ("none" | "all" | "single-line" | "multi-line");
+        enforceForArrowConditionals?: boolean;
+        enforceForSequenceExpressions?: boolean;
+        enforceForNewInMemberExpressions?: boolean;
+        enforceForFunctionPrototypeMethods?: boolean;
+        allowParensAfterCommentPattern?: string;
+    }
+]);
+type TypescriptEslintNoExtraneousClass = [] | [
+    {
+        allowConstructorOnly?: boolean;
+        allowEmpty?: boolean;
+        allowStaticOnly?: boolean;
+        allowWithDecorator?: boolean;
+    }
+];
+type TypescriptEslintNoFloatingPromises = [] | [
+    {
+        ignoreVoid?: boolean;
+        ignoreIIFE?: boolean;
+        allowForKnownSafePromises?: (string | {
+            from: "file";
+            name: (string | [string, ...(string)[]]);
+            path?: string;
+        } | {
+            from: "lib";
+            name: (string | [string, ...(string)[]]);
+        } | {
+            from: "package";
+            name: (string | [string, ...(string)[]]);
+            package: string;
+        })[];
+    }
+];
+type TypescriptEslintNoInferrableTypes = [] | [
+    {
+        ignoreParameters?: boolean;
+        ignoreProperties?: boolean;
+    }
+];
+type TypescriptEslintNoInvalidThis = [] | [
+    {
+        capIsConstructor?: boolean;
+    }
+];
+type TypescriptEslintNoInvalidVoidType = [] | [
+    {
+        allowInGenericTypeArguments?: (boolean | [string, ...(string)[]]);
+        allowAsThisParameter?: boolean;
+    }
+];
+type TypescriptEslintNoMagicNumbers = [] | [
+    {
+        detectObjects?: boolean;
+        enforceConst?: boolean;
+        ignore?: (number | string)[];
+        ignoreArrayIndexes?: boolean;
+        ignoreDefaultValues?: boolean;
+        ignoreClassFieldInitialValues?: boolean;
+        ignoreNumericLiteralTypes?: boolean;
+        ignoreEnums?: boolean;
+        ignoreReadonlyClassProperties?: boolean;
+        ignoreTypeIndexes?: boolean;
+    }
+];
+type TypescriptEslintNoMeaninglessVoidOperator = [] | [
+    {
+        checkNever?: boolean;
+    }
+];
+type TypescriptEslintNoMisusedPromises = [] | [
+    {
+        checksConditionals?: boolean;
+        checksVoidReturn?: (boolean | {
+            arguments?: boolean;
+            attributes?: boolean;
+            properties?: boolean;
+            returns?: boolean;
+            variables?: boolean;
+        });
+        checksSpreads?: boolean;
+    }
+];
+type TypescriptEslintNoNamespace = [] | [
+    {
+        allowDeclarations?: boolean;
+        allowDefinitionFiles?: boolean;
+    }
+];
+type TypescriptEslintNoRedeclare = [] | [
+    {
+        builtinGlobals?: boolean;
+        ignoreDeclarationMerge?: boolean;
+    }
+];
+type TypescriptEslintNoRequireImports = [] | [
+    {
+        allow?: string[];
+    }
+];
+type TypescriptEslintNoRestrictedImports = ((string | {
+    name: string;
+    message?: string;
+    importNames?: string[];
+    allowImportNames?: string[];
+    allowTypeImports?: boolean;
+})[] | [] | [
+    {
+        paths?: (string | {
+            name: string;
+            message?: string;
+            importNames?: string[];
+            allowImportNames?: string[];
+            allowTypeImports?: boolean;
+        })[];
+        patterns?: (string[] | {
+            importNames?: [string, ...(string)[]];
+            allowImportNames?: [string, ...(string)[]];
+            group: [string, ...(string)[]];
+            importNamePattern?: string;
+            allowImportNamePattern?: string;
+            message?: string;
+            caseSensitive?: boolean;
+            allowTypeImports?: boolean;
+        }[]);
+    }
+]);
+type TypescriptEslintNoShadow = [] | [
+    {
+        builtinGlobals?: boolean;
+        hoist?: ("all" | "functions" | "never");
+        allow?: string[];
+        ignoreOnInitialization?: boolean;
+        ignoreTypeValueShadow?: boolean;
+        ignoreFunctionTypeParameterNameValueShadow?: boolean;
+    }
+];
+type TypescriptEslintNoThisAlias = [] | [
+    {
+        allowDestructuring?: boolean;
+        allowedNames?: string[];
+    }
+];
+type TypescriptEslintNoThrowLiteral = [] | [
+    {
+        allowThrowingAny?: boolean;
+        allowThrowingUnknown?: boolean;
+    }
+];
+type TypescriptEslintNoTypeAlias = [] | [
+    {
+        allowAliases?: ("always" | "never" | "in-unions" | "in-intersections" | "in-unions-and-intersections");
+        allowCallbacks?: ("always" | "never");
+        allowConditionalTypes?: ("always" | "never");
+        allowConstructors?: ("always" | "never");
+        allowLiterals?: ("always" | "never" | "in-unions" | "in-intersections" | "in-unions-and-intersections");
+        allowMappedTypes?: ("always" | "never" | "in-unions" | "in-intersections" | "in-unions-and-intersections");
+        allowTupleTypes?: ("always" | "never" | "in-unions" | "in-intersections" | "in-unions-and-intersections");
+        allowGenerics?: ("always" | "never");
+    }
+];
+type TypescriptEslintNoUnnecessaryBooleanLiteralCompare = [] | [
+    {
+        allowComparingNullableBooleansToTrue?: boolean;
+        allowComparingNullableBooleansToFalse?: boolean;
+    }
+];
+type TypescriptEslintNoUnnecessaryCondition = [] | [
+    {
+        allowConstantLoopConditions?: boolean;
+        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+    }
+];
+type TypescriptEslintNoUnnecessaryTypeAssertion = [] | [
+    {
+        typesToIgnore?: string[];
+    }
+];
+type TypescriptEslintNoUnusedExpressions = [] | [
+    {
+        allowShortCircuit?: boolean;
+        allowTernary?: boolean;
+        allowTaggedTemplates?: boolean;
+        enforceForJSX?: boolean;
+    }
+];
+type TypescriptEslintNoUnusedVars = [] | [
+    (("all" | "local") | {
+        vars?: ("all" | "local");
+        varsIgnorePattern?: string;
+        args?: ("all" | "after-used" | "none");
+        ignoreRestSiblings?: boolean;
+        argsIgnorePattern?: string;
+        caughtErrors?: ("all" | "none");
+        caughtErrorsIgnorePattern?: string;
+        destructuredArrayIgnorePattern?: string;
+    })
+];
+type TypescriptEslintNoUseBeforeDefine = [] | [
+    ("nofunc" | {
+        functions?: boolean;
+        classes?: boolean;
+        enums?: boolean;
+        variables?: boolean;
+        typedefs?: boolean;
+        ignoreTypeReferences?: boolean;
+        allowNamedExports?: boolean;
+    })
+];
+type TypescriptEslintNoVarRequires = [] | [
+    {
+        allow?: string[];
+    }
+];
+type TypescriptEslintObjectCurlySpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        arraysInObjects?: boolean;
+        objectsInObjects?: boolean;
+    }
+];
+type TypescriptEslintOnlyThrowError = [] | [
+    {
+        allowThrowingAny?: boolean;
+        allowThrowingUnknown?: boolean;
+    }
+];
+type _TypescriptEslintPaddingLineBetweenStatementsPaddingType = ("any" | "never" | "always");
+type _TypescriptEslintPaddingLineBetweenStatementsStatementType = (("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "interface" | "type") | [("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "interface" | "type"), ...(("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "interface" | "type"))[]]);
+type TypescriptEslintPaddingLineBetweenStatements = {
+    blankLine: _TypescriptEslintPaddingLineBetweenStatementsPaddingType;
+    prev: _TypescriptEslintPaddingLineBetweenStatementsStatementType;
+    next: _TypescriptEslintPaddingLineBetweenStatementsStatementType;
+}[];
+type TypescriptEslintParameterProperties = [] | [
+    {
+        allow?: ("readonly" | "private" | "protected" | "public" | "private readonly" | "protected readonly" | "public readonly")[];
+        prefer?: ("class-property" | "parameter-property");
+    }
+];
+type TypescriptEslintPreferDestructuring = [] | [
+    ({
+        VariableDeclarator?: {
+            array?: boolean;
+            object?: boolean;
+        };
+        AssignmentExpression?: {
+            array?: boolean;
+            object?: boolean;
+        };
+    } | {
+        array?: boolean;
+        object?: boolean;
+    })
+] | [
+    ({
+        VariableDeclarator?: {
+            array?: boolean;
+            object?: boolean;
+        };
+        AssignmentExpression?: {
+            array?: boolean;
+            object?: boolean;
+        };
+    } | {
+        array?: boolean;
+        object?: boolean;
+    }),
+    {
+        enforceForRenamedProperties?: boolean;
+        enforceForDeclarationWithTypeAnnotation?: boolean;
+        [k: string]: unknown | undefined;
+    }
+];
+type TypescriptEslintPreferLiteralEnumMember = [] | [
+    {
+        allowBitwiseExpressions?: boolean;
+    }
+];
+type TypescriptEslintPreferNullishCoalescing = [] | [
+    {
+        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+        ignoreConditionalTests?: boolean;
+        ignoreMixedLogicalExpressions?: boolean;
+        ignorePrimitives?: ({
+            bigint?: boolean;
+            boolean?: boolean;
+            number?: boolean;
+            string?: boolean;
+            [k: string]: unknown | undefined;
+        } | true);
+        ignoreTernaryTests?: boolean;
+    }
+];
+type TypescriptEslintPreferOptionalChain = [] | [
+    {
+        checkAny?: boolean;
+        checkUnknown?: boolean;
+        checkString?: boolean;
+        checkNumber?: boolean;
+        checkBoolean?: boolean;
+        checkBigInt?: boolean;
+        requireNullish?: boolean;
+        allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing?: boolean;
+    }
+];
+type TypescriptEslintPreferPromiseRejectErrors = [] | [
+    {
+        allowEmptyReject?: boolean;
+    }
+];
+type TypescriptEslintPreferReadonly = [] | [
+    {
+        onlyInlineLambdas?: boolean;
+    }
+];
+type TypescriptEslintPreferReadonlyParameterTypes = [] | [
+    {
+        allow?: (string | {
+            from: "file";
+            name: (string | [string, ...(string)[]]);
+            path?: string;
+        } | {
+            from: "lib";
+            name: (string | [string, ...(string)[]]);
+        } | {
+            from: "package";
+            name: (string | [string, ...(string)[]]);
+            package: string;
+        })[];
+        checkParameterProperties?: boolean;
+        ignoreInferredTypes?: boolean;
+        treatMethodsAsReadonly?: boolean;
+    }
+];
+type TypescriptEslintPreferStringStartsEndsWith = [] | [
+    {
+        allowSingleElementEquality?: ("always" | "never");
+    }
+];
+type TypescriptEslintPromiseFunctionAsync = [] | [
+    {
+        allowAny?: boolean;
+        allowedPromiseNames?: string[];
+        checkArrowFunctions?: boolean;
+        checkFunctionDeclarations?: boolean;
+        checkFunctionExpressions?: boolean;
+        checkMethodDeclarations?: boolean;
+    }
+];
+type TypescriptEslintQuotes = [] | [("single" | "double" | "backtick")] | [
+    ("single" | "double" | "backtick"),
+    ("avoid-escape" | {
+        avoidEscape?: boolean;
+        allowTemplateLiterals?: boolean;
+    })
+];
+type TypescriptEslintRequireArraySortCompare = [] | [
+    {
+        ignoreStringArrays?: boolean;
+    }
+];
+type TypescriptEslintRestrictPlusOperands = [] | [
+    {
+        allowAny?: boolean;
+        allowBoolean?: boolean;
+        allowNullish?: boolean;
+        allowNumberAndString?: boolean;
+        allowRegExp?: boolean;
+        skipCompoundAssignments?: boolean;
+    }
+];
+type TypescriptEslintRestrictTemplateExpressions = [] | [
+    {
+        allowAny?: boolean;
+        allowArray?: boolean;
+        allowBoolean?: boolean;
+        allowNullish?: boolean;
+        allowNumber?: boolean;
+        allowRegExp?: boolean;
+        allowNever?: boolean;
+    }
+];
+type TypescriptEslintReturnAwait = [] | [("in-try-catch" | "always" | "never")];
+type TypescriptEslintSemi = ([] | ["never"] | [
+    "never",
+    {
+        beforeStatementContinuationChars?: ("always" | "any" | "never");
+    }
+] | [] | ["always"] | [
+    "always",
+    {
+        omitLastInOneLineBlock?: boolean;
+        omitLastInOneLineClassBody?: boolean;
+    }
+]);
+type TypescriptEslintSortTypeConstituents = [] | [
+    {
+        checkIntersections?: boolean;
+        checkUnions?: boolean;
+        caseSensitive?: boolean;
+        groupOrder?: ("conditional" | "function" | "import" | "intersection" | "keyword" | "nullish" | "literal" | "named" | "object" | "operator" | "tuple" | "union")[];
+    }
+];
+type TypescriptEslintSpaceBeforeBlocks = [] | [
+    (("always" | "never") | {
+        keywords?: ("always" | "never" | "off");
+        functions?: ("always" | "never" | "off");
+        classes?: ("always" | "never" | "off");
+    })
+];
+type TypescriptEslintSpaceBeforeFunctionParen = [] | [
+    (("always" | "never") | {
+        anonymous?: ("always" | "never" | "ignore");
+        named?: ("always" | "never" | "ignore");
+        asyncArrow?: ("always" | "never" | "ignore");
+    })
+];
+type TypescriptEslintSpaceInfixOps = [] | [
+    {
+        int32Hint?: boolean;
+    }
+];
+type TypescriptEslintStrictBooleanExpressions = [] | [
+    {
+        allowString?: boolean;
+        allowNumber?: boolean;
+        allowNullableObject?: boolean;
+        allowNullableBoolean?: boolean;
+        allowNullableString?: boolean;
+        allowNullableNumber?: boolean;
+        allowNullableEnum?: boolean;
+        allowAny?: boolean;
+        allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean;
+    }
+];
+type TypescriptEslintSwitchExhaustivenessCheck = [] | [
+    {
+        allowDefaultCaseForExhaustiveSwitch?: boolean;
+        requireDefaultForNonUnion?: boolean;
+    }
+];
+type TypescriptEslintTripleSlashReference = [] | [
+    {
+        lib?: ("always" | "never");
+        path?: ("always" | "never");
+        types?: ("always" | "never" | "prefer-import");
+    }
+];
+type TypescriptEslintTypeAnnotationSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+        overrides?: {
+            colon?: _TypescriptEslintTypeAnnotationSpacing_SpacingConfig;
+            arrow?: _TypescriptEslintTypeAnnotationSpacing_SpacingConfig;
+            variable?: _TypescriptEslintTypeAnnotationSpacing_SpacingConfig;
+            parameter?: _TypescriptEslintTypeAnnotationSpacing_SpacingConfig;
+            property?: _TypescriptEslintTypeAnnotationSpacing_SpacingConfig;
+            returnType?: _TypescriptEslintTypeAnnotationSpacing_SpacingConfig;
+        };
+    }
+];
+interface _TypescriptEslintTypeAnnotationSpacing_SpacingConfig {
+    before?: boolean;
+    after?: boolean;
+}
+type TypescriptEslintTypedef = [] | [
+    {
+        arrayDestructuring?: boolean;
+        arrowParameter?: boolean;
+        memberVariableDeclaration?: boolean;
+        objectDestructuring?: boolean;
+        parameter?: boolean;
+        propertyDeclaration?: boolean;
+        variableDeclaration?: boolean;
+        variableDeclarationIgnoreFunction?: boolean;
+    }
+];
+type TypescriptEslintUnboundMethod = [] | [
+    {
+        ignoreStatic?: boolean;
+    }
+];
+type TypescriptEslintUnifiedSignatures = [] | [
+    {
+        ignoreDifferentlyNamedParameters?: boolean;
+    }
+];
+export {};