@tsslint/config 3.0.0-alpha.1 → 3.0.0

package/lib/eslint-types.d.ts

@@ -1,4667 +1,3 @@
-export interface ESLintRulesConfig {
-	/**
-	 * Require that function overload signatures be consecutive
-	 * @see https://typescript-eslint.io/rules/adjacent-overload-signatures
-	 */
-	'@typescript-eslint/adjacent-overload-signatures'?: [],
-	/**
-	 * Require consistently using either `T[]` or `Array<T>` for arrays
-	 * @see https://typescript-eslint.io/rules/array-type
-	 */
-	'@typescript-eslint/array-type'?: [({
-		/**
-		 * The array type expected for mutable cases.
-		 */
-		default?: Def0_arrayOption,
-		/**
-		 * The array type expected for readonly cases. If omitted, the value for `default` will be used.
-		 */
-		readonly?: Def0_arrayOption,
-	})?],
-	/**
-	 * Disallow awaiting a value that is not a Thenable
-	 * @see https://typescript-eslint.io/rules/await-thenable
-	 */
-	'@typescript-eslint/await-thenable'?: [],
-	/**
-	 * Disallow `@ts-<directive>` comments or require descriptions after directives
-	 * @see https://typescript-eslint.io/rules/ban-ts-comment
-	 */
-	'@typescript-eslint/ban-ts-comment'?: [({
-		/**
-		 * A minimum character length for descriptions when `allow-with-description` is enabled.
-		 */
-		minimumDescriptionLength?: number,
-		/**
-		 * Whether allow ts-check directives, and with which restrictions.
-		 */
-		'ts-check'?: Def1_directiveConfigSchema,
-		/**
-		 * Whether and when expect-error directives, and with which restrictions.
-		 */
-		'ts-expect-error'?: Def1_directiveConfigSchema,
-		/**
-		 * Whether allow ts-ignore directives, and with which restrictions.
-		 */
-		'ts-ignore'?: Def1_directiveConfigSchema,
-		/**
-		 * Whether allow ts-nocheck directives, and with which restrictions.
-		 */
-		'ts-nocheck'?: Def1_directiveConfigSchema,
-	})?],
-	/**
-	 * Disallow `// tslint:<rule-flag>` comments
-	 * @see https://typescript-eslint.io/rules/ban-tslint-comment
-	 */
-	'@typescript-eslint/ban-tslint-comment'?: [],
-	/**
-	 * 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'?: [("fields" | "getters")?],
-	/**
-	 * Enforce that class methods utilize `this`
-	 * @see https://typescript-eslint.io/rules/class-methods-use-this
-	 */
-	'@typescript-eslint/class-methods-use-this'?: [({
-		/**
-		 * Enforces that functions used as instance field initializers utilize `this`.
-		 */
-		enforceForClassFields?: boolean,
-		/**
-		 * Allows specified method names to be ignored with this rule.
-		 */
-		exceptMethods?: (string)[],
-		/**
-		 * Whether to ignore class members that are defined within a class that `implements` a type.
-		 */
-		ignoreClassesThatImplementAnInterface?: boolean | "public-fields",
-		/**
-		 * Whether to ignore members marked with the `override` modifier.
-		 */
-		ignoreOverrideMethods?: boolean,
-	})?],
-	/**
-	 * 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'?: [("type-annotation" | "constructor")?],
-	/**
-	 * Require or disallow the `Record` type
-	 * @see https://typescript-eslint.io/rules/consistent-indexed-object-style
-	 */
-	'@typescript-eslint/consistent-indexed-object-style'?: [("record" | "index-signature")?],
-	/**
-	 * Require `return` statements to either always or never specify values
-	 * @see https://typescript-eslint.io/rules/consistent-return
-	 */
-	'@typescript-eslint/consistent-return'?: [({
-		treatUndefinedAsUnspecified?: boolean,
-	})?],
-	/**
-	 * Enforce consistent usage of type assertions
-	 * @see https://typescript-eslint.io/rules/consistent-type-assertions
-	 */
-	'@typescript-eslint/consistent-type-assertions'?: [({
-		/**
-		 * The expected assertion style to enforce.
-		 */
-		assertionStyle: "never",
-	} | {
-		/**
-		 * Whether to always prefer type declarations for array literals used as variable initializers, rather than type assertions.
-		 */
-		arrayLiteralTypeAssertions?: "allow" | "allow-as-parameter" | "never",
-		/**
-		 * The expected assertion style to enforce.
-		 */
-		assertionStyle?: "as" | "angle-bracket",
-		/**
-		 * Whether to always prefer type declarations for object literals used as variable initializers, rather than type assertions.
-		 */
-		objectLiteralTypeAssertions?: "allow" | "allow-as-parameter" | "never",
-	})?],
-	/**
-	 * Enforce type definitions to consistently use either `interface` or `type`
-	 * @see https://typescript-eslint.io/rules/consistent-type-definitions
-	 */
-	'@typescript-eslint/consistent-type-definitions'?: [("interface" | "type")?],
-	/**
-	 * Enforce consistent usage of type exports
-	 * @see https://typescript-eslint.io/rules/consistent-type-exports
-	 */
-	'@typescript-eslint/consistent-type-exports'?: [({
-		/**
-		 * Whether the rule will autofix "mixed" export cases using TS inline type specifiers.
-		 */
-		fixMixedExportsWithInlineTypeSpecifier?: boolean,
-	})?],
-	/**
-	 * Enforce consistent usage of type imports
-	 * @see https://typescript-eslint.io/rules/consistent-type-imports
-	 */
-	'@typescript-eslint/consistent-type-imports'?: [({
-		/**
-		 * Whether to disallow type imports in type annotations (`import()`).
-		 */
-		disallowTypeAnnotations?: boolean,
-		/**
-		 * The expected type modifier to be added when an import is detected as used only in the type position.
-		 */
-		fixStyle?: "separate-type-imports" | "inline-type-imports",
-		/**
-		 * The expected import kind for type-only imports.
-		 */
-		prefer?: "type-imports" | "no-type-imports",
-	})?],
-	/**
-	 * Enforce default parameters to be last
-	 * @see https://typescript-eslint.io/rules/default-param-last
-	 */
-	'@typescript-eslint/default-param-last'?: [],
-	/**
-	 * Enforce dot notation whenever possible
-	 * @see https://typescript-eslint.io/rules/dot-notation
-	 */
-	'@typescript-eslint/dot-notation'?: [({
-		/**
-		 * Whether to allow accessing properties matching an index signature with array notation.
-		 */
-		allowIndexSignaturePropertyAccess?: boolean,
-		/**
-		 * Whether to allow keywords such as ["class"]`.
-		 */
-		allowKeywords?: boolean,
-		/**
-		 * Regular expression of names to allow.
-		 */
-		allowPattern?: string,
-		/**
-		 * Whether to allow accessing class members marked as `private` with array notation.
-		 */
-		allowPrivateClassPropertyAccess?: boolean,
-		/**
-		 * Whether to allow accessing class members marked as `protected` with array notation.
-		 */
-		allowProtectedClassPropertyAccess?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to allow arrow functions that start with the `void` keyword.
-		 */
-		allowConciseArrowFunctionExpressionsStartingWithVoid?: boolean,
-		/**
-		 * Whether to ignore arrow functions immediately returning a `as const` value.
-		 */
-		allowDirectConstAssertionInArrowFunctions?: boolean,
-		/**
-		 * An array of function/method names that will not have their arguments or return values checked.
-		 */
-		allowedNames?: (string)[],
-		/**
-		 * Whether to ignore function expressions (functions which are not part of a declaration).
-		 */
-		allowExpressions?: boolean,
-		/**
-		 * Whether to ignore functions that don't have generic type parameters.
-		 */
-		allowFunctionsWithoutTypeParameters?: boolean,
-		/**
-		 * Whether to ignore functions immediately returning another function expression.
-		 */
-		allowHigherOrderFunctions?: boolean,
-		/**
-		 * Whether to ignore immediately invoked function expressions (IIFEs).
-		 */
-		allowIIFEs?: boolean,
-		/**
-		 * Whether to ignore type annotations on the variable of function expressions.
-		 */
-		allowTypedFunctionExpressions?: boolean,
-	})?],
-	/**
-	 * Require explicit accessibility modifiers on class properties and methods
-	 * @see https://typescript-eslint.io/rules/explicit-member-accessibility
-	 */
-	'@typescript-eslint/explicit-member-accessibility'?: [({
-		/**
-		 * Which accessibility modifier is required to exist or not exist.
-		 */
-		accessibility?: Def2_accessibilityLevel,
-		/**
-		 * Specific method names that may be ignored.
-		 */
-		ignoredMethodNames?: (string)[],
-		/**
-		 * Changes to required accessibility modifiers for specific kinds of class members.
-		 */
-		overrides?: {
-			/**
-			 * Which member accessibility modifier requirements to apply for accessors.
-			 */
-			accessors?: Def2_accessibilityLevel,
-			/**
-			 * Which member accessibility modifier requirements to apply for constructors.
-			 */
-			constructors?: Def2_accessibilityLevel,
-			/**
-			 * Which member accessibility modifier requirements to apply for methods.
-			 */
-			methods?: Def2_accessibilityLevel,
-			/**
-			 * Which member accessibility modifier requirements to apply for parameterProperties.
-			 */
-			parameterProperties?: Def2_accessibilityLevel,
-			/**
-			 * Which member accessibility modifier requirements to apply for properties.
-			 */
-			properties?: Def2_accessibilityLevel,
-		},
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to ignore arguments that are explicitly typed as `any`.
-		 */
-		allowArgumentsExplicitlyTypedAsAny?: boolean,
-		/**
-		 * Whether to ignore return type annotations on body-less arrow functions that return an `as const` type assertion.
-You must still type the parameters of the function.
-		 */
-		allowDirectConstAssertionInArrowFunctions?: boolean,
-		/**
-		 * An array of function/method names that will not have their arguments or return values checked.
-		 */
-		allowedNames?: (string)[],
-		/**
-		 * Whether to ignore return type annotations on functions immediately returning another function expression.
-You must still type the parameters of the function.
-		 */
-		allowHigherOrderFunctions?: boolean,
-		/**
-		 * Whether to ignore return type annotations on functions with overload signatures.
-		 */
-		allowOverloadFunctions?: boolean,
-		/**
-		 * Whether to ignore type annotations on the variable of a function expression.
-		 */
-		allowTypedFunctionExpressions?: boolean,
-	})?],
-	/**
-	 * Require or disallow initialization in variable declarations
-	 * @see https://typescript-eslint.io/rules/init-declarations
-	 */
-	'@typescript-eslint/init-declarations'?: ["always"] | ["never", {
-		ignoreForLoopInit?: boolean,
-	}],
-	/**
-	 * Enforce a maximum number of parameters in function definitions
-	 * @see https://typescript-eslint.io/rules/max-params
-	 */
-	'@typescript-eslint/max-params'?: [({
-		/**
-		 * Whether to count a `this` declaration when the type is `void`.
-		 */
-		countVoidThis?: boolean,
-		/**
-		 * A maximum number of parameters in function definitions.
-		 */
-		max?: number,
-		/**
-		 * (deprecated) A maximum number of parameters in function definitions.
-		 */
-		maximum?: number,
-	})?],
-	/**
-	 * Require a consistent member declaration order
-	 * @see https://typescript-eslint.io/rules/member-ordering
-	 */
-	'@typescript-eslint/member-ordering'?: [({
-		/**
-		 * Which ordering to enforce for classes.
-		 */
-		classes?: Def3_baseConfig,
-		/**
-		 * Which ordering to enforce for classExpressions.
-		 */
-		classExpressions?: Def3_baseConfig,
-		/**
-		 * Which ordering to enforce for default.
-		 */
-		default?: Def3_baseConfig,
-		/**
-		 * Which ordering to enforce for interfaces.
-		 */
-		interfaces?: Def7_typesConfig,
-		/**
-		 * Which ordering to enforce for typeLiterals.
-		 */
-		typeLiterals?: Def7_typesConfig,
-	})?],
-	/**
-	 * Enforce using a particular method signature syntax
-	 * @see https://typescript-eslint.io/rules/method-signature-style
-	 */
-	'@typescript-eslint/method-signature-style'?: [("property" | "method")?],
-	/**
-	 * Enforce naming conventions for everything across a codebase
-	 * @see https://typescript-eslint.io/rules/naming-convention
-	 */
-	'@typescript-eslint/naming-convention'?: ({
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		modifiers?: ("const" | "readonly" | "static" | "public" | "protected" | "private" | "#private" | "abstract" | "destructured" | "global" | "exported" | "unused" | "requiresQuotes" | "override" | "async" | "default" | "namespace")[],
-		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")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "default",
-		modifiers?: ("const" | "readonly" | "static" | "public" | "protected" | "private" | "#private" | "abstract" | "destructured" | "global" | "exported" | "unused" | "requiresQuotes" | "override" | "async" | "default" | "namespace")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "variableLike",
-		modifiers?: ("unused" | "async")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "variable",
-		modifiers?: ("const" | "destructured" | "exported" | "global" | "unused" | "async")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "function",
-		modifiers?: ("exported" | "global" | "unused" | "async")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "parameter",
-		modifiers?: ("destructured" | "unused")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "memberLike",
-		modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "readonly" | "requiresQuotes" | "static" | "override" | "async")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "classProperty",
-		modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "readonly" | "requiresQuotes" | "static" | "override")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "objectLiteralProperty",
-		modifiers?: ("public" | "requiresQuotes")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "typeProperty",
-		modifiers?: ("public" | "readonly" | "requiresQuotes")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "parameterProperty",
-		modifiers?: ("private" | "protected" | "public" | "readonly")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "property",
-		modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "readonly" | "requiresQuotes" | "static" | "override" | "async")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "classMethod",
-		modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "requiresQuotes" | "static" | "override" | "async")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "objectLiteralMethod",
-		modifiers?: ("public" | "requiresQuotes" | "async")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "typeMethod",
-		modifiers?: ("public" | "requiresQuotes")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "method",
-		modifiers?: ("abstract" | "private" | "#private" | "protected" | "public" | "requiresQuotes" | "static" | "override" | "async")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "classicAccessor",
-		modifiers?: ("abstract" | "private" | "protected" | "public" | "requiresQuotes" | "static" | "override")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "autoAccessor",
-		modifiers?: ("abstract" | "private" | "protected" | "public" | "requiresQuotes" | "static" | "override")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "accessor",
-		modifiers?: ("abstract" | "private" | "protected" | "public" | "requiresQuotes" | "static" | "override")[],
-		types?: (Def14_typeModifiers)[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "enumMember",
-		modifiers?: ("requiresQuotes")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "typeLike",
-		modifiers?: ("abstract" | "exported" | "unused")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "class",
-		modifiers?: ("abstract" | "exported" | "unused")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "interface",
-		modifiers?: ("exported" | "unused")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "typeAlias",
-		modifiers?: ("exported" | "unused")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "enum",
-		modifiers?: ("exported" | "unused")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "typeParameter",
-		modifiers?: ("unused")[],
-	} | {
-		custom?: Def9_matchRegexConfig,
-		failureMessage?: string,
-		format: Def10_formatOptionsConfig,
-		leadingUnderscore?: Def12_underscoreOptions,
-		prefix?: Def13_prefixSuffixConfig,
-		suffix?: Def13_prefixSuffixConfig,
-		trailingUnderscore?: Def12_underscoreOptions,
-		filter?: string | Def9_matchRegexConfig,
-		selector: "import",
-		modifiers?: ("default" | "namespace")[],
-	})[],
-	/**
-	 * Disallow generic `Array` constructors
-	 * @see https://typescript-eslint.io/rules/no-array-constructor
-	 */
-	'@typescript-eslint/no-array-constructor'?: [],
-	/**
-	 * Disallow using the `delete` operator on array values
-	 * @see https://typescript-eslint.io/rules/no-array-delete
-	 */
-	'@typescript-eslint/no-array-delete'?: [],
-	/**
-	 * Require `.toString()` and `.toLocaleString()` to only be called on objects which provide useful information when stringified
-	 * @see https://typescript-eslint.io/rules/no-base-to-string
-	 */
-	'@typescript-eslint/no-base-to-string'?: [({
-		/**
-		 * Whether to also check values of type `unknown`
-		 */
-		checkUnknown?: boolean,
-		/**
-		 * Stringified type names to ignore.
-		 */
-		ignoredTypeNames?: (string)[],
-	})?],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to ignore "shorthand" `() =>` arrow functions: those without `{ ... }` braces.
-		 */
-		ignoreArrowShorthand?: boolean,
-		/**
-		 * Whether to ignore returns that start with the `void` operator.
-		 */
-		ignoreVoidOperator?: boolean,
-		/**
-		 * Whether to ignore returns from functions with explicit `void` return types and functions with contextual `void` return types.
-		 */
-		ignoreVoidReturningFunctions?: boolean,
-	})?],
-	/**
-	 * Disallow using code marked as `@deprecated`
-	 * @see https://typescript-eslint.io/rules/no-deprecated
-	 */
-	'@typescript-eslint/no-deprecated'?: [({
-		/**
-		 * Type specifiers that can be allowed.
-		 */
-		allow?: (string | {
-			from: "file",
-			name: string | (string)[],
-			path?: string,
-		} | {
-			from: "lib",
-			name: string | (string)[],
-		} | {
-			from: "package",
-			name: string | (string)[],
-			package: string,
-		})[],
-	})?],
-	/**
-	 * Disallow duplicate class members
-	 * @see https://typescript-eslint.io/rules/no-dupe-class-members
-	 */
-	'@typescript-eslint/no-dupe-class-members'?: [],
-	/**
-	 * Disallow duplicate enum member values
-	 * @see https://typescript-eslint.io/rules/no-duplicate-enum-values
-	 */
-	'@typescript-eslint/no-duplicate-enum-values'?: [],
-	/**
-	 * Disallow duplicate constituents of union or intersection types
-	 * @see https://typescript-eslint.io/rules/no-duplicate-type-constituents
-	 */
-	'@typescript-eslint/no-duplicate-type-constituents'?: [({
-		/**
-		 * Whether to ignore `&` intersections.
-		 */
-		ignoreIntersections?: boolean,
-		/**
-		 * Whether to ignore `|` unions.
-		 */
-		ignoreUnions?: boolean,
-	})?],
-	/**
-	 * Disallow using the `delete` operator on computed key expressions
-	 * @see https://typescript-eslint.io/rules/no-dynamic-delete
-	 */
-	'@typescript-eslint/no-dynamic-delete'?: [],
-	/**
-	 * Disallow empty functions
-	 * @see https://typescript-eslint.io/rules/no-empty-function
-	 */
-	'@typescript-eslint/no-empty-function'?: [({
-		/**
-		 * Locations and kinds of functions that are allowed to be empty.
-		 */
-		allow?: ("functions" | "arrowFunctions" | "generatorFunctions" | "methods" | "generatorMethods" | "getters" | "setters" | "constructors" | "private-constructors" | "protected-constructors" | "asyncFunctions" | "asyncMethods" | "decoratedFunctions" | "overrideMethods")[],
-	})?],
-	/**
-	 * Disallow the declaration of empty interfaces
-	 * @see https://typescript-eslint.io/rules/no-empty-interface
-	 */
-	'@typescript-eslint/no-empty-interface'?: [({
-		/**
-		 * Whether to allow empty interfaces that extend a single other interface.
-		 */
-		allowSingleExtends?: boolean,
-	})?],
-	/**
-	 * Disallow accidentally using the "empty object" type
-	 * @see https://typescript-eslint.io/rules/no-empty-object-type
-	 */
-	'@typescript-eslint/no-empty-object-type'?: [({
-		/**
-		 * Whether to allow empty interfaces.
-		 */
-		allowInterfaces?: "always" | "never" | "with-single-extends",
-		/**
-		 * Whether to allow empty object type literals.
-		 */
-		allowObjectTypes?: "always" | "never",
-		/**
-		 * A stringified regular expression to allow interfaces and object type aliases with the configured name.
-		 */
-		allowWithName?: string,
-	})?],
-	/**
-	 * Disallow the `any` type
-	 * @see https://typescript-eslint.io/rules/no-explicit-any
-	 */
-	'@typescript-eslint/no-explicit-any'?: [({
-		/**
-		 * Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type.
-		 */
-		fixToUnknown?: boolean,
-		/**
-		 * Whether to ignore rest parameter arrays.
-		 */
-		ignoreRestArgs?: boolean,
-	})?],
-	/**
-	 * Disallow extra non-null assertions
-	 * @see https://typescript-eslint.io/rules/no-extra-non-null-assertion
-	 */
-	'@typescript-eslint/no-extra-non-null-assertion'?: [],
-	/**
-	 * Disallow classes used as namespaces
-	 * @see https://typescript-eslint.io/rules/no-extraneous-class
-	 */
-	'@typescript-eslint/no-extraneous-class'?: [({
-		/**
-		 * Whether to allow extraneous classes that contain only a constructor.
-		 */
-		allowConstructorOnly?: boolean,
-		/**
-		 * Whether to allow extraneous classes that have no body (i.e. are empty).
-		 */
-		allowEmpty?: boolean,
-		/**
-		 * Whether to allow extraneous classes that only contain static members.
-		 */
-		allowStaticOnly?: boolean,
-		/**
-		 * Whether to allow extraneous classes that include a decorator.
-		 */
-		allowWithDecorator?: boolean,
-	})?],
-	/**
-	 * Require Promise-like statements to be handled appropriately
-	 * @see https://typescript-eslint.io/rules/no-floating-promises
-	 */
-	'@typescript-eslint/no-floating-promises'?: [({
-		/**
-		 * Type specifiers of functions whose calls are safe to float.
-		 */
-		allowForKnownSafeCalls?: (string | {
-			from: "file",
-			name: string | (string)[],
-			path?: string,
-		} | {
-			from: "lib",
-			name: string | (string)[],
-		} | {
-			from: "package",
-			name: string | (string)[],
-			package: string,
-		})[],
-		/**
-		 * Type specifiers that are known to be safe to float.
-		 */
-		allowForKnownSafePromises?: (string | {
-			from: "file",
-			name: string | (string)[],
-			path?: string,
-		} | {
-			from: "lib",
-			name: string | (string)[],
-		} | {
-			from: "package",
-			name: string | (string)[],
-			package: string,
-		})[],
-		/**
-		 * Whether to check all "Thenable"s, not just the built-in Promise type.
-		 */
-		checkThenables?: boolean,
-		/**
-		 * Whether to ignore async IIFEs (Immediately Invoked Function Expressions).
-		 */
-		ignoreIIFE?: boolean,
-		/**
-		 * Whether to ignore `void` expressions.
-		 */
-		ignoreVoid?: boolean,
-	})?],
-	/**
-	 * 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'?: [],
-	/**
-	 * Disallow the use of `eval()`-like functions
-	 * @see https://typescript-eslint.io/rules/no-implied-eval
-	 */
-	'@typescript-eslint/no-implied-eval'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to ignore function parameters.
-		 */
-		ignoreParameters?: boolean,
-		/**
-		 * Whether to ignore class properties.
-		 */
-		ignoreProperties?: boolean,
-	})?],
-	/**
-	 * Disallow `this` keywords outside of classes or class-like objects
-	 * @see https://typescript-eslint.io/rules/no-invalid-this
-	 */
-	'@typescript-eslint/no-invalid-this'?: [({
-		capIsConstructor?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether a `this` parameter of a function may be `void`.
-		 */
-		allowAsThisParameter?: boolean,
-		/**
-		 * Whether `void` can be used as a valid value for generic type parameters.
-		 */
-		allowInGenericTypeArguments?: boolean | (string)[],
-	})?],
-	/**
-	 * Disallow function declarations that contain unsafe references inside loop statements
-	 * @see https://typescript-eslint.io/rules/no-loop-func
-	 */
-	'@typescript-eslint/no-loop-func'?: [],
-	/**
-	 * Disallow literal numbers that lose precision
-	 * @see https://typescript-eslint.io/rules/no-loss-of-precision
-	 */
-	'@typescript-eslint/no-loss-of-precision'?: [],
-	/**
-	 * Disallow magic numbers
-	 * @see https://typescript-eslint.io/rules/no-magic-numbers
-	 */
-	'@typescript-eslint/no-magic-numbers'?: [({
-		detectObjects?: boolean,
-		enforceConst?: boolean,
-		ignore?: (number | string)[],
-		ignoreArrayIndexes?: boolean,
-		ignoreDefaultValues?: boolean,
-		ignoreClassFieldInitialValues?: boolean,
-		/**
-		 * Whether enums used in TypeScript are considered okay.
-		 */
-		ignoreEnums?: boolean,
-		/**
-		 * Whether numbers used in TypeScript numeric literal types are considered okay.
-		 */
-		ignoreNumericLiteralTypes?: boolean,
-		/**
-		 * Whether `readonly` class properties are considered okay.
-		 */
-		ignoreReadonlyClassProperties?: boolean,
-		/**
-		 * Whether numbers used to index types are okay.
-		 */
-		ignoreTypeIndexes?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to suggest removing `void` when the argument has type `never`.
-		 */
-		checkNever?: boolean,
-	})?],
-	/**
-	 * Enforce valid definition of `new` and `constructor`
-	 * @see https://typescript-eslint.io/rules/no-misused-new
-	 */
-	'@typescript-eslint/no-misused-new'?: [],
-	/**
-	 * Disallow Promises in places not designed to handle them
-	 * @see https://typescript-eslint.io/rules/no-misused-promises
-	 */
-	'@typescript-eslint/no-misused-promises'?: [({
-		/**
-		 * Whether to warn when a Promise is provided to conditional statements.
-		 */
-		checksConditionals?: boolean,
-		/**
-		 * Whether to warn when `...` spreading a `Promise`.
-		 */
-		checksSpreads?: boolean,
-		/**
-		 * Whether to warn when a Promise is returned from a function typed as returning `void`.
-		 */
-		checksVoidReturn?: boolean | {
-			/**
-			 * Disables checking an asynchronous function passed as argument where the parameter type expects a function that returns `void`.
-			 */
-			arguments?: boolean,
-			/**
-			 * Disables checking an asynchronous function passed as a JSX attribute expected to be a function that returns `void`.
-			 */
-			attributes?: boolean,
-			/**
-			 * Disables checking an asynchronous method in a type that extends or implements another type expecting that method to return `void`.
-			 */
-			inheritedMethods?: boolean,
-			/**
-			 * Disables checking an asynchronous function passed as an object property expected to be a function that returns `void`.
-			 */
-			properties?: boolean,
-			/**
-			 * Disables checking an asynchronous function returned in a function whose return type is a function that returns `void`.
-			 */
-			returns?: boolean,
-			/**
-			 * Disables checking an asynchronous function used as a variable whose return type is a function that returns `void`.
-			 */
-			variables?: boolean,
-		},
-	})?],
-	/**
-	 * Disallow using the spread operator when it might cause unexpected behavior
-	 * @see https://typescript-eslint.io/rules/no-misused-spread
-	 */
-	'@typescript-eslint/no-misused-spread'?: [({
-		/**
-		 * An array of type specifiers that are known to be safe to spread.
-		 */
-		allow?: (string | {
-			from: "file",
-			name: string | (string)[],
-			path?: string,
-		} | {
-			from: "lib",
-			name: string | (string)[],
-		} | {
-			from: "package",
-			name: string | (string)[],
-			package: string,
-		})[],
-	})?],
-	/**
-	 * Disallow enums from having both number and string members
-	 * @see https://typescript-eslint.io/rules/no-mixed-enums
-	 */
-	'@typescript-eslint/no-mixed-enums'?: [],
-	/**
-	 * Disallow TypeScript namespaces
-	 * @see https://typescript-eslint.io/rules/no-namespace
-	 */
-	'@typescript-eslint/no-namespace'?: [({
-		/**
-		 * Whether to allow `declare` with custom TypeScript namespaces.
-		 */
-		allowDeclarations?: boolean,
-		/**
-		 * Whether to allow `declare` with custom TypeScript namespaces inside definition files.
-		 */
-		allowDefinitionFiles?: boolean,
-	})?],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * Disallow non-null assertions using the `!` postfix operator
-	 * @see https://typescript-eslint.io/rules/no-non-null-assertion
-	 */
-	'@typescript-eslint/no-non-null-assertion'?: [],
-	/**
-	 * Disallow variable redeclaration
-	 * @see https://typescript-eslint.io/rules/no-redeclare
-	 */
-	'@typescript-eslint/no-redeclare'?: [({
-		/**
-		 * Whether to report shadowing of built-in global variables.
-		 */
-		builtinGlobals?: boolean,
-		/**
-		 * Whether to ignore declaration merges between certain TypeScript declaration types.
-		 */
-		ignoreDeclarationMerge?: boolean,
-	})?],
-	/**
-	 * 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'?: [],
-	/**
-	 * Disallow invocation of `require()`
-	 * @see https://typescript-eslint.io/rules/no-require-imports
-	 */
-	'@typescript-eslint/no-require-imports'?: [({
-		/**
-		 * Patterns of import paths to allow requiring from.
-		 */
-		allow?: (string)[],
-		/**
-		 * Allows `require` statements in import declarations.
-		 */
-		allowAsImport?: boolean,
-	})?],
-	/**
-	 * Disallow specified modules when loaded by `import`
-	 * @see https://typescript-eslint.io/rules/no-restricted-imports
-	 */
-	'@typescript-eslint/no-restricted-imports'?: (string | {
-		name: string,
-		message?: string,
-		importNames?: (string)[],
-		allowImportNames?: (string)[],
-		/**
-		 * Whether to allow type-only imports for a path.
-		 */
-		allowTypeImports?: boolean,
-	})[] | [{
-		paths?: (string | {
-			name: string,
-			message?: string,
-			importNames?: (string)[],
-			allowImportNames?: (string)[],
-			/**
-			 * Whether to allow type-only imports for a path.
-			 */
-			allowTypeImports?: boolean,
-		})[],
-		patterns?: (string)[] | ({
-			importNames?: (string)[],
-			allowImportNames?: (string)[],
-			group?: (string)[],
-			regex?: string,
-			importNamePattern?: string,
-			allowImportNamePattern?: string,
-			message?: string,
-			caseSensitive?: boolean,
-			/**
-			 * Whether to allow type-only imports for a path.
-			 */
-			allowTypeImports?: boolean,
-		})[],
-	}],
-	/**
-	 * Disallow certain types
-	 * @see https://typescript-eslint.io/rules/no-restricted-types
-	 */
-	'@typescript-eslint/no-restricted-types'?: [({
-		/**
-		 * An object whose keys are the types you want to ban, and the values are error messages.
-		 */
-		types?: { [key: string]: unknown },
-	})?],
-	/**
-	 * Disallow variable declarations from shadowing variables declared in the outer scope
-	 * @see https://typescript-eslint.io/rules/no-shadow
-	 */
-	'@typescript-eslint/no-shadow'?: [({
-		/**
-		 * Identifier names for which shadowing is allowed.
-		 */
-		allow?: (string)[],
-		/**
-		 * Whether to report shadowing of built-in global variables.
-		 */
-		builtinGlobals?: boolean,
-		/**
-		 * Whether to report shadowing before outer functions or variables are defined.
-		 */
-		hoist?: "all" | "functions" | "functions-and-types" | "never" | "types",
-		/**
-		 * Whether to ignore function parameters named the same as a variable.
-		 */
-		ignoreFunctionTypeParameterNameValueShadow?: boolean,
-		/**
-		 * Whether to ignore the variable initializers when the shadowed variable is presumably still unitialized.
-		 */
-		ignoreOnInitialization?: boolean,
-		/**
-		 * Whether to ignore types named the same as a variable.
-		 */
-		ignoreTypeValueShadow?: boolean,
-	})?],
-	/**
-	 * Disallow aliasing `this`
-	 * @see https://typescript-eslint.io/rules/no-this-alias
-	 */
-	'@typescript-eslint/no-this-alias'?: [({
-		/**
-		 * Whether to ignore destructurings, such as `const { props, state } = this`.
-		 */
-		allowDestructuring?: boolean,
-		/**
-		 * Names to ignore, such as ["self"] for `const self = this;`.
-		 */
-		allowedNames?: (string)[],
-	})?],
-	/**
-	 * Disallow type aliases
-	 * @see https://typescript-eslint.io/rules/no-type-alias
-	 */
-	'@typescript-eslint/no-type-alias'?: [({
-		/**
-		 * Whether to allow direct one-to-one type aliases.
-		 */
-		allowAliases?: Def15_expandedOptions,
-		/**
-		 * Whether to allow type aliases for callbacks.
-		 */
-		allowCallbacks?: Def16_simpleOptions,
-		/**
-		 * Whether to allow type aliases for conditional types.
-		 */
-		allowConditionalTypes?: Def16_simpleOptions,
-		/**
-		 * Whether to allow type aliases with constructors.
-		 */
-		allowConstructors?: Def16_simpleOptions,
-		/**
-		 * Whether to allow type aliases with generic types.
-		 */
-		allowGenerics?: Def16_simpleOptions,
-		/**
-		 * Whether to allow type aliases with object literal types.
-		 */
-		allowLiterals?: Def15_expandedOptions,
-		/**
-		 * Whether to allow type aliases with mapped types.
-		 */
-		allowMappedTypes?: Def15_expandedOptions,
-		/**
-		 * Whether to allow type aliases with tuple types.
-		 */
-		allowTupleTypes?: Def15_expandedOptions,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to allow comparisons between nullable boolean variables and `false`.
-		 */
-		allowComparingNullableBooleansToFalse?: boolean,
-		/**
-		 * Whether to allow comparisons between nullable boolean variables and `true`.
-		 */
-		allowComparingNullableBooleansToTrue?: boolean,
-		/**
-		 * Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.
-		 */
-		allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to ignore constant loop conditions, such as `while (true)`.
-		 */
-		allowConstantLoopConditions?: boolean | "always" | "never" | "only-allowed-literals",
-		/**
-		 * Whether to not error when running with a tsconfig that has strictNullChecks turned.
-		 */
-		allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean,
-		/**
-		 * Whether to check the asserted argument of a type predicate function for unnecessary conditions
-		 */
-		checkTypePredicates?: boolean,
-	})?],
-	/**
-	 * Disallow unnecessary assignment of constructor property parameter
-	 * @see https://typescript-eslint.io/rules/no-unnecessary-parameter-property-assignment
-	 */
-	'@typescript-eslint/no-unnecessary-parameter-property-assignment'?: [],
-	/**
-	 * Disallow unnecessary namespace qualifiers
-	 * @see https://typescript-eslint.io/rules/no-unnecessary-qualifier
-	 */
-	'@typescript-eslint/no-unnecessary-qualifier'?: [],
-	/**
-	 * Disallow unnecessary template expressions
-	 * @see https://typescript-eslint.io/rules/no-unnecessary-template-expression
-	 */
-	'@typescript-eslint/no-unnecessary-template-expression'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to check literal const assertions.
-		 */
-		checkLiteralConstAssertions?: boolean,
-		/**
-		 * A list of type names to ignore.
-		 */
-		typesToIgnore?: (string)[],
-	})?],
-	/**
-	 * Disallow unnecessary constraints on generic types
-	 * @see https://typescript-eslint.io/rules/no-unnecessary-type-constraint
-	 */
-	'@typescript-eslint/no-unnecessary-type-constraint'?: [],
-	/**
-	 * Disallow conversion idioms when they do not change the type or value of the expression
-	 * @see https://typescript-eslint.io/rules/no-unnecessary-type-conversion
-	 */
-	'@typescript-eslint/no-unnecessary-type-conversion'?: [],
-	/**
-	 * Disallow type parameters that aren't used multiple times
-	 * @see https://typescript-eslint.io/rules/no-unnecessary-type-parameters
-	 */
-	'@typescript-eslint/no-unnecessary-type-parameters'?: [],
-	/**
-	 * Disallow calling a function with a value with type `any`
-	 * @see https://typescript-eslint.io/rules/no-unsafe-argument
-	 */
-	'@typescript-eslint/no-unsafe-argument'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * Disallow calling a value with type `any`
-	 * @see https://typescript-eslint.io/rules/no-unsafe-call
-	 */
-	'@typescript-eslint/no-unsafe-call'?: [],
-	/**
-	 * Disallow unsafe declaration merging
-	 * @see https://typescript-eslint.io/rules/no-unsafe-declaration-merging
-	 */
-	'@typescript-eslint/no-unsafe-declaration-merging'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * Disallow using the unsafe built-in Function type
-	 * @see https://typescript-eslint.io/rules/no-unsafe-function-type
-	 */
-	'@typescript-eslint/no-unsafe-function-type'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to allow `?.` optional chains on `any` values.
-		 */
-		allowOptionalChaining?: boolean,
-	})?],
-	/**
-	 * Disallow returning a value with type `any` from a function
-	 * @see https://typescript-eslint.io/rules/no-unsafe-return
-	 */
-	'@typescript-eslint/no-unsafe-return'?: [],
-	/**
-	 * Disallow type assertions that narrow a type
-	 * @see https://typescript-eslint.io/rules/no-unsafe-type-assertion
-	 */
-	'@typescript-eslint/no-unsafe-type-assertion'?: [],
-	/**
-	 * Require unary negation to take a number
-	 * @see https://typescript-eslint.io/rules/no-unsafe-unary-minus
-	 */
-	'@typescript-eslint/no-unsafe-unary-minus'?: [],
-	/**
-	 * Disallow unused expressions
-	 * @see https://typescript-eslint.io/rules/no-unused-expressions
-	 */
-	'@typescript-eslint/no-unused-expressions'?: [({
-		allowShortCircuit?: boolean,
-		allowTernary?: boolean,
-		allowTaggedTemplates?: boolean,
-		enforceForJSX?: boolean,
-		ignoreDirectives?: boolean,
-	})?],
-	/**
-	 * Disallow unused private class members
-	 * @see https://typescript-eslint.io/rules/no-unused-private-class-members
-	 */
-	'@typescript-eslint/no-unused-private-class-members'?: [],
-	/**
-	 * Disallow unused variables
-	 * @see https://typescript-eslint.io/rules/no-unused-vars
-	 */
-	'@typescript-eslint/no-unused-vars'?: [("all" | "local" | {
-		/**
-		 * Whether to check all, some, or no arguments.
-		 */
-		args?: "all" | "after-used" | "none",
-		/**
-		 * Regular expressions of argument names to not check for usage.
-		 */
-		argsIgnorePattern?: string,
-		/**
-		 * Whether to check catch block arguments.
-		 */
-		caughtErrors?: "all" | "none",
-		/**
-		 * Regular expressions of catch block argument names to not check for usage.
-		 */
-		caughtErrorsIgnorePattern?: string,
-		/**
-		 * Regular expressions of destructured array variable names to not check for usage.
-		 */
-		destructuredArrayIgnorePattern?: string,
-		/**
-		 * Configurable automatic fixes for different types of unused variables.
-		 */
-		enableAutofixRemoval?: {
-			/**
-			 * Whether to enable automatic removal of unused imports.
-			 */
-			imports?: boolean,
-		},
-		/**
-		 * Whether to ignore classes with at least one static initialization block.
-		 */
-		ignoreClassWithStaticInitBlock?: boolean,
-		/**
-		 * Whether to ignore sibling properties in `...` destructurings.
-		 */
-		ignoreRestSiblings?: boolean,
-		/**
-		 * Whether to ignore using or await using declarations.
-		 */
-		ignoreUsingDeclarations?: boolean,
-		/**
-		 * Whether to report variables that match any of the valid ignore pattern options if they have been used.
-		 */
-		reportUsedIgnorePattern?: boolean,
-		/**
-		 * Whether to check all variables or only locally-declared variables.
-		 */
-		vars?: "all" | "local",
-		/**
-		 * Regular expressions of variable names to not check for usage.
-		 */
-		varsIgnorePattern?: string,
-	})?],
-	/**
-	 * 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'?: [("nofunc" | {
-		/**
-		 * Whether to ignore named exports.
-		 */
-		allowNamedExports?: boolean,
-		/**
-		 * Whether to ignore references to class declarations.
-		 */
-		classes?: boolean,
-		/**
-		 * Whether to check references to enums.
-		 */
-		enums?: boolean,
-		/**
-		 * Whether to ignore references to function declarations.
-		 */
-		functions?: boolean,
-		/**
-		 * Whether to ignore type references, such as in type annotations and assertions.
-		 */
-		ignoreTypeReferences?: boolean,
-		/**
-		 * Whether to check references to types.
-		 */
-		typedefs?: boolean,
-		/**
-		 * Whether to ignore references to variables.
-		 */
-		variables?: boolean,
-	})?],
-	/**
-	 * Disallow unnecessary constructors
-	 * @see https://typescript-eslint.io/rules/no-useless-constructor
-	 */
-	'@typescript-eslint/no-useless-constructor'?: [],
-	/**
-	 * Disallow default values that will never be used
-	 * @see https://typescript-eslint.io/rules/no-useless-default-assignment
-	 */
-	'@typescript-eslint/no-useless-default-assignment'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * Disallow `require` statements except in import statements
-	 * @see https://typescript-eslint.io/rules/no-var-requires
-	 */
-	'@typescript-eslint/no-var-requires'?: [({
-		/**
-		 * Patterns of import paths to allow requiring from.
-		 */
-		allow?: (string)[],
-	})?],
-	/**
-	 * Disallow using confusing built-in primitive class wrappers
-	 * @see https://typescript-eslint.io/rules/no-wrapper-object-types
-	 */
-	'@typescript-eslint/no-wrapper-object-types'?: [],
-	/**
-	 * Enforce non-null assertions over explicit type assertions
-	 * @see https://typescript-eslint.io/rules/non-nullable-type-assertion-style
-	 */
-	'@typescript-eslint/non-nullable-type-assertion-style'?: [],
-	/**
-	 * Disallow throwing non-`Error` values as exceptions
-	 * @see https://typescript-eslint.io/rules/only-throw-error
-	 */
-	'@typescript-eslint/only-throw-error'?: [({
-		/**
-		 * Type specifiers that can be thrown.
-		 */
-		allow?: (string | {
-			from: "file",
-			name: string | (string)[],
-			path?: string,
-		} | {
-			from: "lib",
-			name: string | (string)[],
-		} | {
-			from: "package",
-			name: string | (string)[],
-			package: string,
-		})[],
-		/**
-		 * Whether to allow rethrowing caught values that are not `Error` objects.
-		 */
-		allowRethrowing?: boolean,
-		/**
-		 * Whether to always allow throwing values typed as `any`.
-		 */
-		allowThrowingAny?: boolean,
-		/**
-		 * Whether to always allow throwing values typed as `unknown`.
-		 */
-		allowThrowingUnknown?: boolean,
-	})?],
-	/**
-	 * Require or disallow parameter properties in class constructors
-	 * @see https://typescript-eslint.io/rules/parameter-properties
-	 */
-	'@typescript-eslint/parameter-properties'?: [({
-		/**
-		 * Whether to allow certain kinds of properties to be ignored.
-		 */
-		allow?: (Def17_modifier)[],
-		/**
-		 * Whether to prefer class properties or parameter properties.
-		 */
-		prefer?: "class-property" | "parameter-property",
-	})?],
-	/**
-	 * Enforce the use of `as const` over literal type
-	 * @see https://typescript-eslint.io/rules/prefer-as-const
-	 */
-	'@typescript-eslint/prefer-as-const'?: [],
-	/**
-	 * Require destructuring from arrays and/or objects
-	 * @see https://typescript-eslint.io/rules/prefer-destructuring
-	 */
-	'@typescript-eslint/prefer-destructuring'?: [({
-		AssignmentExpression?: {
-			array?: boolean,
-			object?: boolean,
-		},
-		VariableDeclarator?: {
-			array?: boolean,
-			object?: boolean,
-		},
-	} | {
-		array?: boolean,
-		object?: boolean,
-	})?, ({
-		/**
-		 * Whether to enforce destructuring on variable declarations with type annotations.
-		 */
-		enforceForDeclarationWithTypeAnnotation?: boolean,
-		/**
-		 * Whether to enforce destructuring that use a different variable name than the property name.
-		 */
-		enforceForRenamedProperties?: boolean,
-	})?],
-	/**
-	 * Require each enum member value to be explicitly initialized
-	 * @see https://typescript-eslint.io/rules/prefer-enum-initializers
-	 */
-	'@typescript-eslint/prefer-enum-initializers'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * Enforce using function types instead of interfaces with call signatures
-	 * @see https://typescript-eslint.io/rules/prefer-function-type
-	 */
-	'@typescript-eslint/prefer-function-type'?: [],
-	/**
-	 * Enforce `includes` method over `indexOf` method
-	 * @see https://typescript-eslint.io/rules/prefer-includes
-	 */
-	'@typescript-eslint/prefer-includes'?: [],
-	/**
-	 * Require all enum members to be literal values
-	 * @see https://typescript-eslint.io/rules/prefer-literal-enum-member
-	 */
-	'@typescript-eslint/prefer-literal-enum-member'?: [({
-		/**
-		 * Whether to allow using bitwise expressions in enum initializers.
-		 */
-		allowBitwiseExpressions?: boolean,
-	})?],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.
-		 */
-		allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean,
-		/**
-		 * Whether to ignore arguments to the `Boolean` constructor
-		 */
-		ignoreBooleanCoercion?: boolean,
-		/**
-		 * Whether to ignore cases that are located within a conditional test.
-		 */
-		ignoreConditionalTests?: boolean,
-		/**
-		 * Whether to ignore any if statements that could be simplified by using the nullish coalescing operator.
-		 */
-		ignoreIfStatements?: boolean,
-		/**
-		 * Whether to ignore any logical or expressions that are part of a mixed logical expression (with `&&`).
-		 */
-		ignoreMixedLogicalExpressions?: boolean,
-		/**
-		 * Whether to ignore all (`true`) or some (an object with properties) primitive types.
-		 */
-		ignorePrimitives?: {
-			/**
-			 * Ignore bigint primitive types.
-			 */
-			bigint?: boolean,
-			/**
-			 * Ignore boolean primitive types.
-			 */
-			boolean?: boolean,
-			/**
-			 * Ignore number primitive types.
-			 */
-			number?: boolean,
-			/**
-			 * Ignore string primitive types.
-			 */
-			string?: boolean,
-		} | true,
-		/**
-		 * Whether to ignore any ternary expressions that could be simplified by using the nullish coalescing operator.
-		 */
-		ignoreTernaryTests?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Allow autofixers that will change the return type of the expression. This option is considered unsafe as it may break the build.
-		 */
-		allowPotentiallyUnsafeFixesThatModifyTheReturnTypeIKnowWhatImDoing?: boolean,
-		/**
-		 * Check operands that are typed as `any` when inspecting "loose boolean" operands.
-		 */
-		checkAny?: boolean,
-		/**
-		 * Check operands that are typed as `bigint` when inspecting "loose boolean" operands.
-		 */
-		checkBigInt?: boolean,
-		/**
-		 * Check operands that are typed as `boolean` when inspecting "loose boolean" operands.
-		 */
-		checkBoolean?: boolean,
-		/**
-		 * Check operands that are typed as `number` when inspecting "loose boolean" operands.
-		 */
-		checkNumber?: boolean,
-		/**
-		 * Check operands that are typed as `string` when inspecting "loose boolean" operands.
-		 */
-		checkString?: boolean,
-		/**
-		 * Check operands that are typed as `unknown` when inspecting "loose boolean" operands.
-		 */
-		checkUnknown?: boolean,
-		/**
-		 * Skip operands that are not typed with `null` and/or `undefined` when inspecting "loose boolean" operands.
-		 */
-		requireNullish?: boolean,
-	})?],
-	/**
-	 * Require using Error objects as Promise rejection reasons
-	 * @see https://typescript-eslint.io/rules/prefer-promise-reject-errors
-	 */
-	'@typescript-eslint/prefer-promise-reject-errors'?: [({
-		/**
-		 * Whether to allow calls to `Promise.reject()` with no arguments.
-		 */
-		allowEmptyReject?: boolean,
-		/**
-		 * Whether to always allow throwing values typed as `any`.
-		 */
-		allowThrowingAny?: boolean,
-		/**
-		 * Whether to always allow throwing values typed as `unknown`.
-		 */
-		allowThrowingUnknown?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to restrict checking only to members immediately assigned a lambda value.
-		 */
-		onlyInlineLambdas?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * An array of type specifiers to ignore.
-		 */
-		allow?: (string | {
-			from: "file",
-			name: string | (string)[],
-			path?: string,
-		} | {
-			from: "lib",
-			name: string | (string)[],
-		} | {
-			from: "package",
-			name: string | (string)[],
-			package: string,
-		})[],
-		/**
-		 * Whether to check class parameter properties.
-		 */
-		checkParameterProperties?: boolean,
-		/**
-		 * Whether to ignore parameters which don't explicitly specify a type.
-		 */
-		ignoreInferredTypes?: boolean,
-		/**
-		 * Whether to treat all mutable methods as though they are readonly.
-		 */
-		treatMethodsAsReadonly?: boolean,
-	})?],
-	/**
-	 * Enforce using type parameter when calling `Array#reduce` instead of using a type assertion
-	 * @see https://typescript-eslint.io/rules/prefer-reduce-type-parameter
-	 */
-	'@typescript-eslint/prefer-reduce-type-parameter'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to allow equality checks against the first or last element of a string.
-		 */
-		allowSingleElementEquality?: "always" | "never",
-	})?],
-	/**
-	 * Enforce using `@ts-expect-error` over `@ts-ignore`
-	 * @see https://typescript-eslint.io/rules/prefer-ts-expect-error
-	 */
-	'@typescript-eslint/prefer-ts-expect-error'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to consider `any` and `unknown` to be Promises.
-		 */
-		allowAny?: boolean,
-		/**
-		 * Any extra names of classes or interfaces to be considered Promises.
-		 */
-		allowedPromiseNames?: (string)[],
-		/**
-		 * Whether to check arrow functions.
-		 */
-		checkArrowFunctions?: boolean,
-		/**
-		 * Whether to check standalone function declarations.
-		 */
-		checkFunctionDeclarations?: boolean,
-		/**
-		 * Whether to check inline function expressions
-		 */
-		checkFunctionExpressions?: boolean,
-		/**
-		 * Whether to check methods on classes and object literals.
-		 */
-		checkMethodDeclarations?: boolean,
-	})?],
-	/**
-	 * Enforce that `get()` types should be assignable to their equivalent `set()` type
-	 * @see https://typescript-eslint.io/rules/related-getter-setter-pairs
-	 */
-	'@typescript-eslint/related-getter-setter-pairs'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to ignore arrays in which all elements are strings.
-		 */
-		ignoreStringArrays?: boolean,
-	})?],
-	/**
-	 * 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'?: [],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether to allow `any` typed values.
-		 */
-		allowAny?: boolean,
-		/**
-		 * Whether to allow `boolean` typed values.
-		 */
-		allowBoolean?: boolean,
-		/**
-		 * Whether to allow potentially `null` or `undefined` typed values.
-		 */
-		allowNullish?: boolean,
-		/**
-		 * Whether to allow `bigint`/`number` typed values and `string` typed values to be added together.
-		 */
-		allowNumberAndString?: boolean,
-		/**
-		 * Whether to allow `regexp` typed values.
-		 */
-		allowRegExp?: boolean,
-		/**
-		 * Whether to skip compound assignments such as `+=`.
-		 */
-		skipCompoundAssignments?: boolean,
-	})?],
-	/**
-	 * Enforce template literal expressions to be of `string` type
-	 * @see https://typescript-eslint.io/rules/restrict-template-expressions
-	 */
-	'@typescript-eslint/restrict-template-expressions'?: [({
-		/**
-		 * Whether to allow `any` typed values in template expressions.
-		 */
-		allowAny?: boolean,
-		/**
-		 * Whether to allow `array` typed values in template expressions.
-		 */
-		allowArray?: boolean,
-		/**
-		 * Whether to allow `boolean` typed values in template expressions.
-		 */
-		allowBoolean?: boolean,
-		/**
-		 * Whether to allow `nullish` typed values in template expressions.
-		 */
-		allowNullish?: boolean,
-		/**
-		 * Whether to allow `number` typed values in template expressions.
-		 */
-		allowNumber?: boolean,
-		/**
-		 * Whether to allow `regexp` typed values in template expressions.
-		 */
-		allowRegExp?: boolean,
-		/**
-		 * Whether to allow `never` typed values in template expressions.
-		 */
-		allowNever?: boolean,
-		/**
-		 * Types to allow in template expressions.
-		 */
-		allow?: (string | {
-			from: "file",
-			name: string | (string)[],
-			path?: string,
-		} | {
-			from: "lib",
-			name: string | (string)[],
-		} | {
-			from: "package",
-			name: string | (string)[],
-			package: string,
-		})[],
-	})?],
-	/**
-	 * Enforce consistent awaiting of returned promises
-	 * @see https://typescript-eslint.io/rules/return-await
-	 */
-	'@typescript-eslint/return-await'?: [(string)?],
-	/**
-	 * Enforce constituents of a type union/intersection to be sorted alphabetically
-	 * @see https://typescript-eslint.io/rules/sort-type-constituents
-	 */
-	'@typescript-eslint/sort-type-constituents'?: [({
-		/**
-		 * Whether to sort using case sensitive string comparisons.
-		 */
-		caseSensitive?: boolean,
-		/**
-		 * Whether to check intersection types (`&`).
-		 */
-		checkIntersections?: boolean,
-		/**
-		 * Whether to check union types (`|`).
-		 */
-		checkUnions?: boolean,
-		/**
-		 * Ordering of the groups.
-		 */
-		groupOrder?: ("conditional" | "function" | "import" | "intersection" | "keyword" | "nullish" | "literal" | "named" | "object" | "operator" | "tuple" | "union")[],
-	})?],
-	/**
-	 * Disallow certain types in boolean expressions
-	 * @see https://typescript-eslint.io/rules/strict-boolean-expressions
-	 */
-	'@typescript-eslint/strict-boolean-expressions'?: [({
-		/**
-		 * Whether to allow `any`s in a boolean context.
-		 */
-		allowAny?: boolean,
-		/**
-		 * Whether to allow nullable `boolean`s in a boolean context.
-		 */
-		allowNullableBoolean?: boolean,
-		/**
-		 * Whether to allow nullable `enum`s in a boolean context.
-		 */
-		allowNullableEnum?: boolean,
-		/**
-		 * Whether to allow nullable `number`s in a boolean context.
-		 */
-		allowNullableNumber?: boolean,
-		/**
-		 * Whether to allow nullable `object`s, `symbol`s, and functions in a boolean context.
-		 */
-		allowNullableObject?: boolean,
-		/**
-		 * Whether to allow nullable `string`s in a boolean context.
-		 */
-		allowNullableString?: boolean,
-		/**
-		 * Whether to allow `number`s in a boolean context.
-		 */
-		allowNumber?: boolean,
-		/**
-		 * Unless this is set to `true`, the rule will error on every file whose `tsconfig.json` does _not_ have the `strictNullChecks` compiler option (or `strict`) set to `true`.
-		 */
-		allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing?: boolean,
-		/**
-		 * Whether to allow `string`s in a boolean context.
-		 */
-		allowString?: boolean,
-	})?],
-	/**
-	 * Disallow passing a value-returning function in a position accepting a void function
-	 * @see https://typescript-eslint.io/rules/strict-void-return
-	 */
-	'@typescript-eslint/strict-void-return'?: [({
-		/**
-		 * Whether to allow functions returning `any` to be used in place expecting a `void` function.
-		 */
-		allowReturnAny?: boolean,
-	})?],
-	/**
-	 * Require switch-case statements to be exhaustive
-	 * @see https://typescript-eslint.io/rules/switch-exhaustiveness-check
-	 */
-	'@typescript-eslint/switch-exhaustiveness-check'?: [({
-		/**
-		 * If 'true', allow 'default' cases on switch statements with exhaustive cases.
-		 */
-		allowDefaultCaseForExhaustiveSwitch?: boolean,
-		/**
-		 * If 'true', the 'default' clause is used to determine whether the switch statement is exhaustive for union type
-		 */
-		considerDefaultExhaustiveForUnions?: boolean,
-		/**
-		 * Regular expression for a comment that can indicate an intentionally omitted default case.
-		 */
-		defaultCaseCommentPattern?: string,
-		/**
-		 * If 'true', require a 'default' clause for switches on non-union types.
-		 */
-		requireDefaultForNonUnion?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * What to enforce for `/// <reference lib="..." />` references.
-		 */
-		lib?: "always" | "never",
-		/**
-		 * What to enforce for `/// <reference path="..." />` references.
-		 */
-		path?: "always" | "never",
-		/**
-		 * What to enforce for `/// <reference types="..." />` references.
-		 */
-		types?: "always" | "never" | "prefer-import",
-	})?],
-	/**
-	 * Require type annotations in certain places
-	 * @see https://typescript-eslint.io/rules/typedef
-	 */
-	'@typescript-eslint/typedef'?: [({
-		/**
-		 * Whether to enforce type annotations on variables declared using array destructuring.
-		 */
-		arrayDestructuring?: boolean,
-		/**
-		 * Whether to enforce type annotations for parameters of arrow functions.
-		 */
-		arrowParameter?: boolean,
-		/**
-		 * Whether to enforce type annotations on member variables of classes.
-		 */
-		memberVariableDeclaration?: boolean,
-		/**
-		 * Whether to enforce type annotations on variables declared using object destructuring.
-		 */
-		objectDestructuring?: boolean,
-		/**
-		 * Whether to enforce type annotations for parameters of functions and methods.
-		 */
-		parameter?: boolean,
-		/**
-		 * Whether to enforce type annotations for properties of interfaces and types.
-		 */
-		propertyDeclaration?: boolean,
-		/**
-		 * Whether to enforce type annotations for variable declarations, excluding array and object destructuring.
-		 */
-		variableDeclaration?: boolean,
-		/**
-		 * Whether to ignore variable declarations for non-arrow and arrow functions.
-		 */
-		variableDeclarationIgnoreFunction?: boolean,
-	})?],
-	/**
-	 * Enforce unbound methods are called with their expected scope
-	 * @see https://typescript-eslint.io/rules/unbound-method
-	 */
-	'@typescript-eslint/unbound-method'?: [({
-		/**
-		 * Whether to skip checking whether `static` methods are correctly bound.
-		 */
-		ignoreStatic?: boolean,
-	})?],
-	/**
-	 * 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'?: [({
-		/**
-		 * Whether two parameters with different names at the same index should be considered different even if their types are the same.
-		 */
-		ignoreDifferentlyNamedParameters?: boolean,
-		/**
-		 * Whether two overloads with different JSDoc comments should be considered different even if their parameter and return types are the same.
-		 */
-		ignoreOverloadsWithDifferentJSDoc?: boolean,
-	})?],
-	/**
-	 * Enforce typing arguments in Promise rejection callbacks as `unknown`
-	 * @see https://typescript-eslint.io/rules/use-unknown-in-catch-callback-variable
-	 */
-	'@typescript-eslint/use-unknown-in-catch-callback-variable'?: [],
-	/**
-	 * Enforce getter and setter pairs in objects and classes
-	 * @see https://eslint.org/docs/latest/rules/accessor-pairs
-	 */
-	'accessor-pairs'?: [({
-		getWithoutSet?: boolean,
-		setWithoutGet?: boolean,
-		enforceForClassMembers?: boolean,
-	})?],
-	/**
-	 * Enforce linebreaks after opening and before closing array brackets
-	 * @see https://eslint.org/docs/latest/rules/array-bracket-newline
-	 */
-	'array-bracket-newline'?: [("always" | "never" | "consistent" | {
-		multiline?: boolean,
-		minItems?: number | null,
-	})?],
-	/**
-	 * Enforce consistent spacing inside array brackets
-	 * @see https://eslint.org/docs/latest/rules/array-bracket-spacing
-	 */
-	'array-bracket-spacing'?: [("always" | "never")?, ({
-		singleValue?: boolean,
-		objectsInArrays?: boolean,
-		arraysInArrays?: boolean,
-	})?],
-	/**
-	 * Enforce `return` statements in callbacks of array methods
-	 * @see https://eslint.org/docs/latest/rules/array-callback-return
-	 */
-	'array-callback-return'?: [({
-		allowImplicit?: boolean,
-		checkForEach?: boolean,
-		allowVoid?: boolean,
-	})?],
-	/**
-	 * Enforce line breaks after each array element
-	 * @see https://eslint.org/docs/latest/rules/array-element-newline
-	 */
-	'array-element-newline'?: [Def18_basicConfig | {
-		ArrayExpression?: Def18_basicConfig,
-		ArrayPattern?: Def18_basicConfig,
-	}],
-	/**
-	 * Require braces around arrow function bodies
-	 * @see https://eslint.org/docs/latest/rules/arrow-body-style
-	 */
-	'arrow-body-style'?: ["always" | "never"] | ["as-needed", {
-		requireReturnForObjectLiteral?: boolean,
-	}],
-	/**
-	 * Require parentheses around arrow function arguments
-	 * @see https://eslint.org/docs/latest/rules/arrow-parens
-	 */
-	'arrow-parens'?: [("always" | "as-needed")?, ({
-		requireForBlockBody?: boolean,
-	})?],
-	/**
-	 * Enforce consistent spacing before and after the arrow in arrow functions
-	 * @see https://eslint.org/docs/latest/rules/arrow-spacing
-	 */
-	'arrow-spacing'?: [({
-		before?: boolean,
-		after?: boolean,
-	})?],
-	/**
-	 * Enforce the use of variables within the scope they are defined
-	 * @see https://eslint.org/docs/latest/rules/block-scoped-var
-	 */
-	'block-scoped-var'?: [],
-	/**
-	 * Disallow or enforce spaces inside of blocks after opening block and before closing block
-	 * @see https://eslint.org/docs/latest/rules/block-spacing
-	 */
-	'block-spacing'?: [("always" | "never")?],
-	/**
-	 * Enforce consistent brace style for blocks
-	 * @see https://eslint.org/docs/latest/rules/brace-style
-	 */
-	'brace-style'?: [("1tbs" | "stroustrup" | "allman")?, ({
-		allowSingleLine?: boolean,
-	})?],
-	/**
-	 * Require `return` statements after callbacks
-	 * @see https://eslint.org/docs/latest/rules/callback-return
-	 */
-	'callback-return'?: [((string)[])?],
-	/**
-	 * Enforce camelcase naming convention
-	 * @see https://eslint.org/docs/latest/rules/camelcase
-	 */
-	'camelcase'?: [({
-		ignoreDestructuring?: boolean,
-		ignoreImports?: boolean,
-		ignoreGlobals?: boolean,
-		properties?: "always" | "never",
-		allow?: (string)[],
-	})?],
-	/**
-	 * Enforce or disallow capitalization of the first letter of a comment
-	 * @see https://eslint.org/docs/latest/rules/capitalized-comments
-	 */
-	'capitalized-comments'?: [("always" | "never")?, ({
-		ignorePattern?: string,
-		ignoreInlineComments?: boolean,
-		ignoreConsecutiveComments?: boolean,
-	} | {
-		line?: {
-			ignorePattern?: string,
-			ignoreInlineComments?: boolean,
-			ignoreConsecutiveComments?: boolean,
-		},
-		block?: {
-			ignorePattern?: string,
-			ignoreInlineComments?: boolean,
-			ignoreConsecutiveComments?: boolean,
-		},
-	})?],
-	/**
-	 * Enforce that class methods utilize `this`
-	 * @see https://eslint.org/docs/latest/rules/class-methods-use-this
-	 */
-	'class-methods-use-this'?: [({
-		exceptMethods?: (string)[],
-		enforceForClassFields?: boolean,
-		ignoreOverrideMethods?: boolean,
-		ignoreClassesWithImplements?: "all" | "public-fields",
-	})?],
-	/**
-	 * Require or disallow trailing commas
-	 * @see https://eslint.org/docs/latest/rules/comma-dangle
-	 */
-	'comma-dangle'?: [Def19_value | {
-		arrays?: Def20_valueWithIgnore,
-		objects?: Def20_valueWithIgnore,
-		imports?: Def20_valueWithIgnore,
-		exports?: Def20_valueWithIgnore,
-		functions?: Def20_valueWithIgnore,
-	}],
-	/**
-	 * Enforce consistent spacing before and after commas
-	 * @see https://eslint.org/docs/latest/rules/comma-spacing
-	 */
-	'comma-spacing'?: [({
-		before?: boolean,
-		after?: boolean,
-	})?],
-	/**
-	 * Enforce consistent comma style
-	 * @see https://eslint.org/docs/latest/rules/comma-style
-	 */
-	'comma-style'?: [("first" | "last")?, ({
-		exceptions?: { [key: string]: unknown },
-	})?],
-	/**
-	 * Enforce a maximum cyclomatic complexity allowed in a program
-	 * @see https://eslint.org/docs/latest/rules/complexity
-	 */
-	'complexity'?: [(number | {
-		maximum?: number,
-		max?: number,
-		variant?: "classic" | "modified",
-	})?],
-	/**
-	 * Enforce consistent spacing inside computed property brackets
-	 * @see https://eslint.org/docs/latest/rules/computed-property-spacing
-	 */
-	'computed-property-spacing'?: [("always" | "never")?, ({
-		enforceForClassMembers?: boolean,
-	})?],
-	/**
-	 * Require `return` statements to either always or never specify values
-	 * @see https://eslint.org/docs/latest/rules/consistent-return
-	 */
-	'consistent-return'?: [({
-		treatUndefinedAsUnspecified?: boolean,
-	})?],
-	/**
-	 * Enforce consistent naming when capturing the current execution context
-	 * @see https://eslint.org/docs/latest/rules/consistent-this
-	 */
-	'consistent-this'?: (string)[],
-	/**
-	 * Require `super()` calls in constructors
-	 * @see https://eslint.org/docs/latest/rules/constructor-super
-	 */
-	'constructor-super'?: [],
-	/**
-	 * Enforce consistent brace style for all control statements
-	 * @see https://eslint.org/docs/latest/rules/curly
-	 */
-	'curly'?: ["all"] | ["multi" | "multi-line" | "multi-or-nest", "consistent"],
-	/**
-	 * Enforce `default` clauses in `switch` statements to be last
-	 * @see https://eslint.org/docs/latest/rules/default-case-last
-	 */
-	'default-case-last'?: [],
-	/**
-	 * Require `default` cases in `switch` statements
-	 * @see https://eslint.org/docs/latest/rules/default-case
-	 */
-	'default-case'?: [({
-		commentPattern?: string,
-	})?],
-	/**
-	 * Enforce default parameters to be last
-	 * @see https://eslint.org/docs/latest/rules/default-param-last
-	 */
-	'default-param-last'?: [],
-	/**
-	 * Enforce consistent newlines before and after dots
-	 * @see https://eslint.org/docs/latest/rules/dot-location
-	 */
-	'dot-location'?: [("object" | "property")?],
-	/**
-	 * Enforce dot notation whenever possible
-	 * @see https://eslint.org/docs/latest/rules/dot-notation
-	 */
-	'dot-notation'?: [({
-		allowKeywords?: boolean,
-		allowPattern?: string,
-	})?],
-	/**
-	 * Require or disallow newline at the end of files
-	 * @see https://eslint.org/docs/latest/rules/eol-last
-	 */
-	'eol-last'?: [("always" | "never" | "unix" | "windows")?],
-	/**
-	 * Require the use of `===` and `!==`
-	 * @see https://eslint.org/docs/latest/rules/eqeqeq
-	 */
-	'eqeqeq'?: ["always", {
-		null?: "always" | "never" | "ignore",
-	}] | ["smart" | "allow-null"],
-	/**
-	 * Enforce `for` loop update clause moving the counter in the right direction
-	 * @see https://eslint.org/docs/latest/rules/for-direction
-	 */
-	'for-direction'?: [],
-	/**
-	 * Require or disallow spacing between function identifiers and their invocations
-	 * @see https://eslint.org/docs/latest/rules/func-call-spacing
-	 */
-	'func-call-spacing'?: ["never"] | ["always", {
-		allowNewlines?: boolean,
-	}],
-	/**
-	 * Require function names to match the name of the variable or property to which they are assigned
-	 * @see https://eslint.org/docs/latest/rules/func-name-matching
-	 */
-	'func-name-matching'?: ["always" | "never", {
-		considerPropertyDescriptor?: boolean,
-		includeCommonJSModuleExports?: boolean,
-	}] | [{
-		considerPropertyDescriptor?: boolean,
-		includeCommonJSModuleExports?: boolean,
-	}],
-	/**
-	 * Require or disallow named `function` expressions
-	 * @see https://eslint.org/docs/latest/rules/func-names
-	 */
-	'func-names'?: unknown,
-	/**
-	 * Enforce the consistent use of either `function` declarations or expressions assigned to variables
-	 * @see https://eslint.org/docs/latest/rules/func-style
-	 */
-	'func-style'?: [("declaration" | "expression")?, ({
-		allowArrowFunctions?: boolean,
-		overrides?: {
-			namedExports?: "declaration" | "expression" | "ignore",
-		},
-	})?],
-	/**
-	 * Enforce line breaks between arguments of a function call
-	 * @see https://eslint.org/docs/latest/rules/function-call-argument-newline
-	 */
-	'function-call-argument-newline'?: [("always" | "never" | "consistent")?],
-	/**
-	 * Enforce consistent line breaks inside function parentheses
-	 * @see https://eslint.org/docs/latest/rules/function-paren-newline
-	 */
-	'function-paren-newline'?: [("always" | "never" | "consistent" | "multiline" | "multiline-arguments" | {
-		minItems?: number,
-	})?],
-	/**
-	 * Enforce consistent spacing around `*` operators in generator functions
-	 * @see https://eslint.org/docs/latest/rules/generator-star-spacing
-	 */
-	'generator-star-spacing'?: [("before" | "after" | "both" | "neither" | {
-		before?: boolean,
-		after?: boolean,
-		named?: "before" | "after" | "both" | "neither" | {
-			before?: boolean,
-			after?: boolean,
-		},
-		anonymous?: "before" | "after" | "both" | "neither" | {
-			before?: boolean,
-			after?: boolean,
-		},
-		method?: "before" | "after" | "both" | "neither" | {
-			before?: boolean,
-			after?: boolean,
-		},
-	})?],
-	/**
-	 * Enforce `return` statements in getters
-	 * @see https://eslint.org/docs/latest/rules/getter-return
-	 */
-	'getter-return'?: [({
-		allowImplicit?: boolean,
-	})?],
-	/**
-	 * Require `require()` calls to be placed at top-level module scope
-	 * @see https://eslint.org/docs/latest/rules/global-require
-	 */
-	'global-require'?: [],
-	/**
-	 * Require grouped accessor pairs in object literals and classes
-	 * @see https://eslint.org/docs/latest/rules/grouped-accessor-pairs
-	 */
-	'grouped-accessor-pairs'?: [("anyOrder" | "getBeforeSet" | "setBeforeGet")?],
-	/**
-	 * Require `for-in` loops to include an `if` statement
-	 * @see https://eslint.org/docs/latest/rules/guard-for-in
-	 */
-	'guard-for-in'?: [],
-	/**
-	 * Require error handling in callbacks
-	 * @see https://eslint.org/docs/latest/rules/handle-callback-err
-	 */
-	'handle-callback-err'?: [(string)?],
-	/**
-	 * Disallow specified identifiers
-	 * @see https://eslint.org/docs/latest/rules/id-blacklist
-	 */
-	'id-blacklist'?: (string)[],
-	/**
-	 * Disallow specified identifiers
-	 * @see https://eslint.org/docs/latest/rules/id-denylist
-	 */
-	'id-denylist'?: (string)[],
-	/**
-	 * Enforce minimum and maximum identifier lengths
-	 * @see https://eslint.org/docs/latest/rules/id-length
-	 */
-	'id-length'?: [({
-		min?: number,
-		max?: number,
-		exceptions?: (string)[],
-		exceptionPatterns?: (string)[],
-		properties?: "always" | "never",
-	})?],
-	/**
-	 * Require identifiers to match a specified regular expression
-	 * @see https://eslint.org/docs/latest/rules/id-match
-	 */
-	'id-match'?: [(string)?, ({
-		properties?: boolean,
-		classFields?: boolean,
-		onlyDeclarations?: boolean,
-		ignoreDestructuring?: boolean,
-	})?],
-	/**
-	 * Enforce the location of arrow function bodies
-	 * @see https://eslint.org/docs/latest/rules/implicit-arrow-linebreak
-	 */
-	'implicit-arrow-linebreak'?: [("beside" | "below")?],
-	/**
-	 * Enforce consistent indentation
-	 * @see https://eslint.org/docs/latest/rules/indent-legacy
-	 */
-	'indent-legacy'?: [("tab" | number)?, ({
-		SwitchCase?: number,
-		VariableDeclarator?: number | {
-			var?: number,
-			let?: number,
-			const?: number,
-		},
-		outerIIFEBody?: number,
-		MemberExpression?: number,
-		FunctionDeclaration?: {
-			parameters?: number | "first",
-			body?: number,
-		},
-		FunctionExpression?: {
-			parameters?: number | "first",
-			body?: number,
-		},
-		CallExpression?: {
-			parameters?: number | "first",
-		},
-		ArrayExpression?: number | "first",
-		ObjectExpression?: number | "first",
-	})?],
-	/**
-	 * Enforce consistent indentation
-	 * @see https://eslint.org/docs/latest/rules/indent
-	 */
-	'indent'?: [("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,
-	})?],
-	'index'?: any[],
-	/**
-	 * Require or disallow initialization in variable declarations
-	 * @see https://eslint.org/docs/latest/rules/init-declarations
-	 */
-	'init-declarations'?: ["always"] | ["never", {
-		ignoreForLoopInit?: boolean,
-	}],
-	/**
-	 * Enforce the consistent use of either double or single quotes in JSX attributes
-	 * @see https://eslint.org/docs/latest/rules/jsx-quotes
-	 */
-	'jsx-quotes'?: [("prefer-single" | "prefer-double")?],
-	/**
-	 * Enforce consistent spacing between keys and values in object literal properties
-	 * @see https://eslint.org/docs/latest/rules/key-spacing
-	 */
-	'key-spacing'?: [({
-		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,
-		},
-	})?],
-	/**
-	 * Enforce consistent spacing before and after keywords
-	 * @see https://eslint.org/docs/latest/rules/keyword-spacing
-	 */
-	'keyword-spacing'?: [({
-		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,
-			},
-		},
-	})?],
-	/**
-	 * Enforce position of line comments
-	 * @see https://eslint.org/docs/latest/rules/line-comment-position
-	 */
-	'line-comment-position'?: [("above" | "beside" | {
-		position?: "above" | "beside",
-		ignorePattern?: string,
-		applyDefaultPatterns?: boolean,
-		applyDefaultIgnorePatterns?: boolean,
-	})?],
-	/**
-	 * Enforce consistent linebreak style
-	 * @see https://eslint.org/docs/latest/rules/linebreak-style
-	 */
-	'linebreak-style'?: [("unix" | "windows")?],
-	/**
-	 * Require empty lines around comments
-	 * @see https://eslint.org/docs/latest/rules/lines-around-comment
-	 */
-	'lines-around-comment'?: [({
-		beforeBlockComment?: boolean,
-		afterBlockComment?: boolean,
-		beforeLineComment?: boolean,
-		afterLineComment?: boolean,
-		allowBlockStart?: boolean,
-		allowBlockEnd?: boolean,
-		allowClassStart?: boolean,
-		allowClassEnd?: boolean,
-		allowObjectStart?: boolean,
-		allowObjectEnd?: boolean,
-		allowArrayStart?: boolean,
-		allowArrayEnd?: boolean,
-		ignorePattern?: string,
-		applyDefaultIgnorePatterns?: boolean,
-		afterHashbangComment?: boolean,
-	})?],
-	/**
-	 * Require or disallow newlines around directives
-	 * @see https://eslint.org/docs/latest/rules/lines-around-directive
-	 */
-	'lines-around-directive'?: [("always" | "never" | {
-		before?: "always" | "never",
-		after?: "always" | "never",
-	})?],
-	/**
-	 * Require or disallow an empty line between class members
-	 * @see https://eslint.org/docs/latest/rules/lines-between-class-members
-	 */
-	'lines-between-class-members'?: [({
-		enforce: ({
-			blankLine: "always" | "never",
-			prev: "method" | "field" | "*",
-			next: "method" | "field" | "*",
-		})[],
-	} | "always" | "never")?, ({
-		exceptAfterSingleLine?: boolean,
-	})?],
-	/**
-	 * Require or disallow logical assignment operator shorthand
-	 * @see https://eslint.org/docs/latest/rules/logical-assignment-operators
-	 */
-	'logical-assignment-operators'?: any[],
-	/**
-	 * Enforce a maximum number of classes per file
-	 * @see https://eslint.org/docs/latest/rules/max-classes-per-file
-	 */
-	'max-classes-per-file'?: [(number | {
-		ignoreExpressions?: boolean,
-		max?: number,
-	})?],
-	/**
-	 * Enforce a maximum depth that blocks can be nested
-	 * @see https://eslint.org/docs/latest/rules/max-depth
-	 */
-	'max-depth'?: [(number | {
-		maximum?: number,
-		max?: number,
-	})?],
-	/**
-	 * Enforce a maximum line length
-	 * @see https://eslint.org/docs/latest/rules/max-len
-	 */
-	'max-len'?: [({
-		code?: number,
-		comments?: number,
-		tabWidth?: number,
-		ignorePattern?: string,
-		ignoreComments?: boolean,
-		ignoreStrings?: boolean,
-		ignoreUrls?: boolean,
-		ignoreTemplateLiterals?: boolean,
-		ignoreRegExpLiterals?: boolean,
-		ignoreTrailingComments?: boolean,
-	} | number)?, ({
-		code?: number,
-		comments?: number,
-		tabWidth?: number,
-		ignorePattern?: string,
-		ignoreComments?: boolean,
-		ignoreStrings?: boolean,
-		ignoreUrls?: boolean,
-		ignoreTemplateLiterals?: boolean,
-		ignoreRegExpLiterals?: boolean,
-		ignoreTrailingComments?: boolean,
-	} | number)?, ({
-		code?: number,
-		comments?: number,
-		tabWidth?: number,
-		ignorePattern?: string,
-		ignoreComments?: boolean,
-		ignoreStrings?: boolean,
-		ignoreUrls?: boolean,
-		ignoreTemplateLiterals?: boolean,
-		ignoreRegExpLiterals?: boolean,
-		ignoreTrailingComments?: boolean,
-	})?],
-	/**
-	 * Enforce a maximum number of lines of code in a function
-	 * @see https://eslint.org/docs/latest/rules/max-lines-per-function
-	 */
-	'max-lines-per-function'?: [({
-		max?: number,
-		skipComments?: boolean,
-		skipBlankLines?: boolean,
-		IIFEs?: boolean,
-	} | number)?],
-	/**
-	 * Enforce a maximum number of lines per file
-	 * @see https://eslint.org/docs/latest/rules/max-lines
-	 */
-	'max-lines'?: [(number | {
-		max?: number,
-		skipComments?: boolean,
-		skipBlankLines?: boolean,
-	})?],
-	/**
-	 * Enforce a maximum depth that callbacks can be nested
-	 * @see https://eslint.org/docs/latest/rules/max-nested-callbacks
-	 */
-	'max-nested-callbacks'?: [(number | {
-		maximum?: number,
-		max?: number,
-	})?],
-	/**
-	 * Enforce a maximum number of parameters in function definitions
-	 * @see https://eslint.org/docs/latest/rules/max-params
-	 */
-	'max-params'?: [(number | {
-		maximum?: number,
-		max?: number,
-		/**
-		 * Whether to count a `this` declaration when the type is `void`.
-		 */
-		countVoidThis?: boolean,
-	})?],
-	/**
-	 * Enforce a maximum number of statements allowed per line
-	 * @see https://eslint.org/docs/latest/rules/max-statements-per-line
-	 */
-	'max-statements-per-line'?: [({
-		max?: number,
-	})?],
-	/**
-	 * Enforce a maximum number of statements allowed in function blocks
-	 * @see https://eslint.org/docs/latest/rules/max-statements
-	 */
-	'max-statements'?: [(number | {
-		maximum?: number,
-		max?: number,
-	})?, ({
-		ignoreTopLevelFunctions?: boolean,
-	})?],
-	/**
-	 * Enforce a particular style for multiline comments
-	 * @see https://eslint.org/docs/latest/rules/multiline-comment-style
-	 */
-	'multiline-comment-style'?: ["starred-block" | "bare-block"] | ["separate-lines", {
-		checkJSDoc?: boolean,
-	}],
-	/**
-	 * Enforce newlines between operands of ternary expressions
-	 * @see https://eslint.org/docs/latest/rules/multiline-ternary
-	 */
-	'multiline-ternary'?: [("always" | "always-multiline" | "never")?],
-	/**
-	 * Require constructor names to begin with a capital letter
-	 * @see https://eslint.org/docs/latest/rules/new-cap
-	 */
-	'new-cap'?: [({
-		newIsCap?: boolean,
-		capIsNew?: boolean,
-		newIsCapExceptions?: (string)[],
-		newIsCapExceptionPattern?: string,
-		capIsNewExceptions?: (string)[],
-		capIsNewExceptionPattern?: string,
-		properties?: boolean,
-	})?],
-	/**
-	 * Enforce or disallow parentheses when invoking a constructor with no arguments
-	 * @see https://eslint.org/docs/latest/rules/new-parens
-	 */
-	'new-parens'?: [("always" | "never")?],
-	/**
-	 * Require or disallow an empty line after variable declarations
-	 * @see https://eslint.org/docs/latest/rules/newline-after-var
-	 */
-	'newline-after-var'?: [("never" | "always")?],
-	/**
-	 * Require an empty line before `return` statements
-	 * @see https://eslint.org/docs/latest/rules/newline-before-return
-	 */
-	'newline-before-return'?: [],
-	/**
-	 * Require a newline after each call in a method chain
-	 * @see https://eslint.org/docs/latest/rules/newline-per-chained-call
-	 */
-	'newline-per-chained-call'?: [({
-		ignoreChainWithDepth?: number,
-	})?],
-	/**
-	 * Disallow the use of `alert`, `confirm`, and `prompt`
-	 * @see https://eslint.org/docs/latest/rules/no-alert
-	 */
-	'no-alert'?: [],
-	/**
-	 * Disallow `Array` constructors
-	 * @see https://eslint.org/docs/latest/rules/no-array-constructor
-	 */
-	'no-array-constructor'?: [],
-	/**
-	 * Disallow using an async function as a Promise executor
-	 * @see https://eslint.org/docs/latest/rules/no-async-promise-executor
-	 */
-	'no-async-promise-executor'?: [],
-	/**
-	 * Disallow `await` inside of loops
-	 * @see https://eslint.org/docs/latest/rules/no-await-in-loop
-	 */
-	'no-await-in-loop'?: [],
-	/**
-	 * Disallow bitwise operators
-	 * @see https://eslint.org/docs/latest/rules/no-bitwise
-	 */
-	'no-bitwise'?: [({
-		allow?: ("^" | "|" | "&" | "<<" | ">>" | ">>>" | "^=" | "|=" | "&=" | "<<=" | ">>=" | ">>>=" | "~")[],
-		int32Hint?: boolean,
-	})?],
-	/**
-	 * Disallow use of the `Buffer()` constructor
-	 * @see https://eslint.org/docs/latest/rules/no-buffer-constructor
-	 */
-	'no-buffer-constructor'?: [],
-	/**
-	 * Disallow the use of `arguments.caller` or `arguments.callee`
-	 * @see https://eslint.org/docs/latest/rules/no-caller
-	 */
-	'no-caller'?: [],
-	/**
-	 * Disallow lexical declarations in case clauses
-	 * @see https://eslint.org/docs/latest/rules/no-case-declarations
-	 */
-	'no-case-declarations'?: [],
-	/**
-	 * Disallow `catch` clause parameters from shadowing variables in the outer scope
-	 * @see https://eslint.org/docs/latest/rules/no-catch-shadow
-	 */
-	'no-catch-shadow'?: [],
-	/**
-	 * Disallow reassigning class members
-	 * @see https://eslint.org/docs/latest/rules/no-class-assign
-	 */
-	'no-class-assign'?: [],
-	/**
-	 * Disallow comparing against `-0`
-	 * @see https://eslint.org/docs/latest/rules/no-compare-neg-zero
-	 */
-	'no-compare-neg-zero'?: [],
-	/**
-	 * Disallow assignment operators in conditional expressions
-	 * @see https://eslint.org/docs/latest/rules/no-cond-assign
-	 */
-	'no-cond-assign'?: [("except-parens" | "always")?],
-	/**
-	 * Disallow arrow functions where they could be confused with comparisons
-	 * @see https://eslint.org/docs/latest/rules/no-confusing-arrow
-	 */
-	'no-confusing-arrow'?: [({
-		allowParens?: boolean,
-		onlyOneSimpleParam?: boolean,
-	})?],
-	/**
-	 * Disallow the use of `console`
-	 * @see https://eslint.org/docs/latest/rules/no-console
-	 */
-	'no-console'?: [({
-		allow?: (string)[],
-	})?],
-	/**
-	 * Disallow reassigning `const` variables
-	 * @see https://eslint.org/docs/latest/rules/no-const-assign
-	 */
-	'no-const-assign'?: [],
-	/**
-	 * Disallow expressions where the operation doesn't affect the value
-	 * @see https://eslint.org/docs/latest/rules/no-constant-binary-expression
-	 */
-	'no-constant-binary-expression'?: [],
-	/**
-	 * Disallow constant expressions in conditions
-	 * @see https://eslint.org/docs/latest/rules/no-constant-condition
-	 */
-	'no-constant-condition'?: [({
-		checkLoops?: "all" | "allExceptWhileTrue" | "none" | true | false,
-	})?],
-	/**
-	 * Disallow returning value from constructor
-	 * @see https://eslint.org/docs/latest/rules/no-constructor-return
-	 */
-	'no-constructor-return'?: [],
-	/**
-	 * Disallow `continue` statements
-	 * @see https://eslint.org/docs/latest/rules/no-continue
-	 */
-	'no-continue'?: [],
-	/**
-	 * Disallow control characters in regular expressions
-	 * @see https://eslint.org/docs/latest/rules/no-control-regex
-	 */
-	'no-control-regex'?: [],
-	/**
-	 * Disallow the use of `debugger`
-	 * @see https://eslint.org/docs/latest/rules/no-debugger
-	 */
-	'no-debugger'?: [],
-	/**
-	 * Disallow deleting variables
-	 * @see https://eslint.org/docs/latest/rules/no-delete-var
-	 */
-	'no-delete-var'?: [],
-	/**
-	 * Disallow equal signs explicitly at the beginning of regular expressions
-	 * @see https://eslint.org/docs/latest/rules/no-div-regex
-	 */
-	'no-div-regex'?: [],
-	/**
-	 * Disallow duplicate arguments in `function` definitions
-	 * @see https://eslint.org/docs/latest/rules/no-dupe-args
-	 */
-	'no-dupe-args'?: [],
-	/**
-	 * Disallow duplicate class members
-	 * @see https://eslint.org/docs/latest/rules/no-dupe-class-members
-	 */
-	'no-dupe-class-members'?: [],
-	/**
-	 * Disallow duplicate conditions in if-else-if chains
-	 * @see https://eslint.org/docs/latest/rules/no-dupe-else-if
-	 */
-	'no-dupe-else-if'?: [],
-	/**
-	 * Disallow duplicate keys in object literals
-	 * @see https://eslint.org/docs/latest/rules/no-dupe-keys
-	 */
-	'no-dupe-keys'?: [],
-	/**
-	 * Disallow duplicate case labels
-	 * @see https://eslint.org/docs/latest/rules/no-duplicate-case
-	 */
-	'no-duplicate-case'?: [],
-	/**
-	 * Disallow duplicate module imports
-	 * @see https://eslint.org/docs/latest/rules/no-duplicate-imports
-	 */
-	'no-duplicate-imports'?: [({
-		includeExports?: boolean,
-	})?],
-	/**
-	 * Disallow `else` blocks after `return` statements in `if` statements
-	 * @see https://eslint.org/docs/latest/rules/no-else-return
-	 */
-	'no-else-return'?: [({
-		allowElseIf?: boolean,
-	})?],
-	/**
-	 * Disallow empty character classes in regular expressions
-	 * @see https://eslint.org/docs/latest/rules/no-empty-character-class
-	 */
-	'no-empty-character-class'?: [],
-	/**
-	 * Disallow empty functions
-	 * @see https://eslint.org/docs/latest/rules/no-empty-function
-	 */
-	'no-empty-function'?: [({
-		allow?: ("functions" | "arrowFunctions" | "generatorFunctions" | "methods" | "generatorMethods" | "getters" | "setters" | "constructors" | "asyncFunctions" | "asyncMethods" | "privateConstructors" | "protectedConstructors" | "decoratedFunctions" | "overrideMethods")[],
-	})?],
-	/**
-	 * Disallow empty destructuring patterns
-	 * @see https://eslint.org/docs/latest/rules/no-empty-pattern
-	 */
-	'no-empty-pattern'?: [({
-		allowObjectPatternsAsParameters?: boolean,
-	})?],
-	/**
-	 * Disallow empty static blocks
-	 * @see https://eslint.org/docs/latest/rules/no-empty-static-block
-	 */
-	'no-empty-static-block'?: [],
-	/**
-	 * Disallow empty block statements
-	 * @see https://eslint.org/docs/latest/rules/no-empty
-	 */
-	'no-empty'?: [({
-		allowEmptyCatch?: boolean,
-	})?],
-	/**
-	 * Disallow `null` comparisons without type-checking operators
-	 * @see https://eslint.org/docs/latest/rules/no-eq-null
-	 */
-	'no-eq-null'?: [],
-	/**
-	 * Disallow the use of `eval()`
-	 * @see https://eslint.org/docs/latest/rules/no-eval
-	 */
-	'no-eval'?: [({
-		allowIndirect?: boolean,
-	})?],
-	/**
-	 * Disallow reassigning exceptions in `catch` clauses
-	 * @see https://eslint.org/docs/latest/rules/no-ex-assign
-	 */
-	'no-ex-assign'?: [],
-	/**
-	 * Disallow extending native types
-	 * @see https://eslint.org/docs/latest/rules/no-extend-native
-	 */
-	'no-extend-native'?: [({
-		exceptions?: (string)[],
-	})?],
-	/**
-	 * Disallow unnecessary calls to `.bind()`
-	 * @see https://eslint.org/docs/latest/rules/no-extra-bind
-	 */
-	'no-extra-bind'?: [],
-	/**
-	 * Disallow unnecessary boolean casts
-	 * @see https://eslint.org/docs/latest/rules/no-extra-boolean-cast
-	 */
-	'no-extra-boolean-cast'?: [({
-		enforceForInnerExpressions?: boolean,
-	} | {
-		enforceForLogicalOperands?: boolean,
-	})?],
-	/**
-	 * Disallow unnecessary labels
-	 * @see https://eslint.org/docs/latest/rules/no-extra-label
-	 */
-	'no-extra-label'?: [],
-	/**
-	 * Disallow unnecessary parentheses
-	 * @see https://eslint.org/docs/latest/rules/no-extra-parens
-	 */
-	'no-extra-parens'?: ["functions"] | ["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,
-	}],
-	/**
-	 * Disallow unnecessary semicolons
-	 * @see https://eslint.org/docs/latest/rules/no-extra-semi
-	 */
-	'no-extra-semi'?: [],
-	/**
-	 * Disallow fallthrough of `case` statements
-	 * @see https://eslint.org/docs/latest/rules/no-fallthrough
-	 */
-	'no-fallthrough'?: [({
-		commentPattern?: string,
-		allowEmptyCase?: boolean,
-		reportUnusedFallthroughComment?: boolean,
-	})?],
-	/**
-	 * Disallow leading or trailing decimal points in numeric literals
-	 * @see https://eslint.org/docs/latest/rules/no-floating-decimal
-	 */
-	'no-floating-decimal'?: [],
-	/**
-	 * Disallow reassigning `function` declarations
-	 * @see https://eslint.org/docs/latest/rules/no-func-assign
-	 */
-	'no-func-assign'?: [],
-	/**
-	 * Disallow assignments to native objects or read-only global variables
-	 * @see https://eslint.org/docs/latest/rules/no-global-assign
-	 */
-	'no-global-assign'?: [({
-		exceptions?: (string)[],
-	})?],
-	/**
-	 * Disallow shorthand type conversions
-	 * @see https://eslint.org/docs/latest/rules/no-implicit-coercion
-	 */
-	'no-implicit-coercion'?: [({
-		boolean?: boolean,
-		number?: boolean,
-		string?: boolean,
-		disallowTemplateShorthand?: boolean,
-		allow?: ("~" | "!!" | "+" | "- -" | "-" | "*")[],
-	})?],
-	/**
-	 * Disallow declarations in the global scope
-	 * @see https://eslint.org/docs/latest/rules/no-implicit-globals
-	 */
-	'no-implicit-globals'?: [({
-		lexicalBindings?: boolean,
-	})?],
-	/**
-	 * Disallow the use of `eval()`-like methods
-	 * @see https://eslint.org/docs/latest/rules/no-implied-eval
-	 */
-	'no-implied-eval'?: [],
-	/**
-	 * Disallow assigning to imported bindings
-	 * @see https://eslint.org/docs/latest/rules/no-import-assign
-	 */
-	'no-import-assign'?: [],
-	/**
-	 * Disallow inline comments after code
-	 * @see https://eslint.org/docs/latest/rules/no-inline-comments
-	 */
-	'no-inline-comments'?: [({
-		ignorePattern?: string,
-	})?],
-	/**
-	 * Disallow variable or `function` declarations in nested blocks
-	 * @see https://eslint.org/docs/latest/rules/no-inner-declarations
-	 */
-	'no-inner-declarations'?: [("functions" | "both")?, ({
-		blockScopedFunctions?: "allow" | "disallow",
-	})?],
-	/**
-	 * Disallow invalid regular expression strings in `RegExp` constructors
-	 * @see https://eslint.org/docs/latest/rules/no-invalid-regexp
-	 */
-	'no-invalid-regexp'?: [({
-		allowConstructorFlags?: (string)[],
-	})?],
-	/**
-	 * Disallow use of `this` in contexts where the value of `this` is `undefined`
-	 * @see https://eslint.org/docs/latest/rules/no-invalid-this
-	 */
-	'no-invalid-this'?: [({
-		capIsConstructor?: boolean,
-	})?],
-	/**
-	 * Disallow irregular whitespace
-	 * @see https://eslint.org/docs/latest/rules/no-irregular-whitespace
-	 */
-	'no-irregular-whitespace'?: [({
-		skipComments?: boolean,
-		skipStrings?: boolean,
-		skipTemplates?: boolean,
-		skipRegExps?: boolean,
-		skipJSXText?: boolean,
-	})?],
-	/**
-	 * Disallow the use of the `__iterator__` property
-	 * @see https://eslint.org/docs/latest/rules/no-iterator
-	 */
-	'no-iterator'?: [],
-	/**
-	 * Disallow labels that share a name with a variable
-	 * @see https://eslint.org/docs/latest/rules/no-label-var
-	 */
-	'no-label-var'?: [],
-	/**
-	 * Disallow labeled statements
-	 * @see https://eslint.org/docs/latest/rules/no-labels
-	 */
-	'no-labels'?: [({
-		allowLoop?: boolean,
-		allowSwitch?: boolean,
-	})?],
-	/**
-	 * Disallow unnecessary nested blocks
-	 * @see https://eslint.org/docs/latest/rules/no-lone-blocks
-	 */
-	'no-lone-blocks'?: [],
-	/**
-	 * Disallow `if` statements as the only statement in `else` blocks
-	 * @see https://eslint.org/docs/latest/rules/no-lonely-if
-	 */
-	'no-lonely-if'?: [],
-	/**
-	 * Disallow function declarations that contain unsafe references inside loop statements
-	 * @see https://eslint.org/docs/latest/rules/no-loop-func
-	 */
-	'no-loop-func'?: [],
-	/**
-	 * Disallow literal numbers that lose precision
-	 * @see https://eslint.org/docs/latest/rules/no-loss-of-precision
-	 */
-	'no-loss-of-precision'?: [],
-	/**
-	 * Disallow magic numbers
-	 * @see https://eslint.org/docs/latest/rules/no-magic-numbers
-	 */
-	'no-magic-numbers'?: [({
-		detectObjects?: boolean,
-		enforceConst?: boolean,
-		ignore?: (number | string)[],
-		ignoreArrayIndexes?: boolean,
-		ignoreDefaultValues?: boolean,
-		ignoreClassFieldInitialValues?: boolean,
-	})?],
-	/**
-	 * Disallow characters which are made with multiple code points in character class syntax
-	 * @see https://eslint.org/docs/latest/rules/no-misleading-character-class
-	 */
-	'no-misleading-character-class'?: [({
-		allowEscape?: boolean,
-	})?],
-	/**
-	 * Disallow mixed binary operators
-	 * @see https://eslint.org/docs/latest/rules/no-mixed-operators
-	 */
-	'no-mixed-operators'?: [({
-		groups?: (("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??")[])[],
-		allowSamePrecedence?: boolean,
-	})?],
-	/**
-	 * Disallow `require` calls to be mixed with regular variable declarations
-	 * @see https://eslint.org/docs/latest/rules/no-mixed-requires
-	 */
-	'no-mixed-requires'?: [(boolean | {
-		grouping?: boolean,
-		allowCall?: boolean,
-	})?],
-	/**
-	 * Disallow mixed spaces and tabs for indentation
-	 * @see https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs
-	 */
-	'no-mixed-spaces-and-tabs'?: [("smart-tabs" | true | false)?],
-	/**
-	 * Disallow use of chained assignment expressions
-	 * @see https://eslint.org/docs/latest/rules/no-multi-assign
-	 */
-	'no-multi-assign'?: [({
-		ignoreNonDeclaration?: boolean,
-	})?],
-	/**
-	 * Disallow multiple spaces
-	 * @see https://eslint.org/docs/latest/rules/no-multi-spaces
-	 */
-	'no-multi-spaces'?: [({
-		exceptions?: { [key: string]: unknown },
-		ignoreEOLComments?: boolean,
-	})?],
-	/**
-	 * Disallow multiline strings
-	 * @see https://eslint.org/docs/latest/rules/no-multi-str
-	 */
-	'no-multi-str'?: [],
-	/**
-	 * Disallow multiple empty lines
-	 * @see https://eslint.org/docs/latest/rules/no-multiple-empty-lines
-	 */
-	'no-multiple-empty-lines'?: [({
-		max: number,
-		maxEOF?: number,
-		maxBOF?: number,
-	})?],
-	/**
-	 * Disallow assignments to native objects or read-only global variables
-	 * @see https://eslint.org/docs/latest/rules/no-native-reassign
-	 */
-	'no-native-reassign'?: [({
-		exceptions?: (string)[],
-	})?],
-	/**
-	 * Disallow negated conditions
-	 * @see https://eslint.org/docs/latest/rules/no-negated-condition
-	 */
-	'no-negated-condition'?: [],
-	/**
-	 * Disallow negating the left operand in `in` expressions
-	 * @see https://eslint.org/docs/latest/rules/no-negated-in-lhs
-	 */
-	'no-negated-in-lhs'?: [],
-	/**
-	 * Disallow nested ternary expressions
-	 * @see https://eslint.org/docs/latest/rules/no-nested-ternary
-	 */
-	'no-nested-ternary'?: [],
-	/**
-	 * Disallow `new` operators with the `Function` object
-	 * @see https://eslint.org/docs/latest/rules/no-new-func
-	 */
-	'no-new-func'?: [],
-	/**
-	 * Disallow `new` operators with global non-constructor functions
-	 * @see https://eslint.org/docs/latest/rules/no-new-native-nonconstructor
-	 */
-	'no-new-native-nonconstructor'?: [],
-	/**
-	 * Disallow `Object` constructors
-	 * @see https://eslint.org/docs/latest/rules/no-new-object
-	 */
-	'no-new-object'?: [],
-	/**
-	 * Disallow `new` operators with calls to `require`
-	 * @see https://eslint.org/docs/latest/rules/no-new-require
-	 */
-	'no-new-require'?: [],
-	/**
-	 * Disallow `new` operators with the `Symbol` object
-	 * @see https://eslint.org/docs/latest/rules/no-new-symbol
-	 */
-	'no-new-symbol'?: [],
-	/**
-	 * Disallow `new` operators with the `String`, `Number`, and `Boolean` objects
-	 * @see https://eslint.org/docs/latest/rules/no-new-wrappers
-	 */
-	'no-new-wrappers'?: [],
-	/**
-	 * Disallow `new` operators outside of assignments or comparisons
-	 * @see https://eslint.org/docs/latest/rules/no-new
-	 */
-	'no-new'?: [],
-	/**
-	 * Disallow `\8` and `\9` escape sequences in string literals
-	 * @see https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape
-	 */
-	'no-nonoctal-decimal-escape'?: [],
-	/**
-	 * Disallow calling global object properties as functions
-	 * @see https://eslint.org/docs/latest/rules/no-obj-calls
-	 */
-	'no-obj-calls'?: [],
-	/**
-	 * Disallow calls to the `Object` constructor without an argument
-	 * @see https://eslint.org/docs/latest/rules/no-object-constructor
-	 */
-	'no-object-constructor'?: [],
-	/**
-	 * Disallow octal escape sequences in string literals
-	 * @see https://eslint.org/docs/latest/rules/no-octal-escape
-	 */
-	'no-octal-escape'?: [],
-	/**
-	 * Disallow octal literals
-	 * @see https://eslint.org/docs/latest/rules/no-octal
-	 */
-	'no-octal'?: [],
-	/**
-	 * Disallow reassigning function parameters
-	 * @see https://eslint.org/docs/latest/rules/no-param-reassign
-	 */
-	'no-param-reassign'?: [({
-		props?: false,
-	} | {
-		props?: true,
-		ignorePropertyModificationsFor?: (string)[],
-		ignorePropertyModificationsForRegex?: (string)[],
-	})?],
-	/**
-	 * Disallow string concatenation with `__dirname` and `__filename`
-	 * @see https://eslint.org/docs/latest/rules/no-path-concat
-	 */
-	'no-path-concat'?: [],
-	/**
-	 * Disallow the unary operators `++` and `--`
-	 * @see https://eslint.org/docs/latest/rules/no-plusplus
-	 */
-	'no-plusplus'?: [({
-		allowForLoopAfterthoughts?: boolean,
-	})?],
-	/**
-	 * Disallow the use of `process.env`
-	 * @see https://eslint.org/docs/latest/rules/no-process-env
-	 */
-	'no-process-env'?: [],
-	/**
-	 * Disallow the use of `process.exit()`
-	 * @see https://eslint.org/docs/latest/rules/no-process-exit
-	 */
-	'no-process-exit'?: [],
-	/**
-	 * Disallow returning values from Promise executor functions
-	 * @see https://eslint.org/docs/latest/rules/no-promise-executor-return
-	 */
-	'no-promise-executor-return'?: [({
-		allowVoid?: boolean,
-	})?],
-	/**
-	 * Disallow the use of the `__proto__` property
-	 * @see https://eslint.org/docs/latest/rules/no-proto
-	 */
-	'no-proto'?: [],
-	/**
-	 * Disallow calling some `Object.prototype` methods directly on objects
-	 * @see https://eslint.org/docs/latest/rules/no-prototype-builtins
-	 */
-	'no-prototype-builtins'?: [],
-	/**
-	 * Disallow variable redeclaration
-	 * @see https://eslint.org/docs/latest/rules/no-redeclare
-	 */
-	'no-redeclare'?: [({
-		builtinGlobals?: boolean,
-	})?],
-	/**
-	 * Disallow multiple spaces in regular expressions
-	 * @see https://eslint.org/docs/latest/rules/no-regex-spaces
-	 */
-	'no-regex-spaces'?: [],
-	/**
-	 * Disallow specified names in exports
-	 * @see https://eslint.org/docs/latest/rules/no-restricted-exports
-	 */
-	'no-restricted-exports'?: [({
-		restrictedNamedExports?: (string)[],
-		restrictedNamedExportsPattern?: string,
-	} | {
-		restrictedNamedExports?: (string)[],
-		restrictedNamedExportsPattern?: string,
-		restrictDefaultExports?: {
-			direct?: boolean,
-			named?: boolean,
-			defaultFrom?: boolean,
-			namedFrom?: boolean,
-			namespaceFrom?: boolean,
-		},
-	})?],
-	/**
-	 * Disallow specified global variables
-	 * @see https://eslint.org/docs/latest/rules/no-restricted-globals
-	 */
-	'no-restricted-globals'?: (string | {
-		name: string,
-		message?: string,
-	})[],
-	/**
-	 * Disallow specified modules when loaded by `import`
-	 * @see https://eslint.org/docs/latest/rules/no-restricted-imports
-	 */
-	'no-restricted-imports'?: (string | {
-		name: string,
-		message?: string,
-		importNames?: (string)[],
-		allowImportNames?: (string)[],
-	})[] | [{
-		paths?: (string | {
-			name: string,
-			message?: string,
-			importNames?: (string)[],
-			allowImportNames?: (string)[],
-		})[],
-		patterns?: (string)[] | ({
-			importNames?: (string)[],
-			allowImportNames?: (string)[],
-			group?: (string)[],
-			regex?: string,
-			importNamePattern?: string,
-			allowImportNamePattern?: string,
-			message?: string,
-			caseSensitive?: boolean,
-		})[],
-	}],
-	/**
-	 * Disallow specified modules when loaded by `require`
-	 * @see https://eslint.org/docs/latest/rules/no-restricted-modules
-	 */
-	'no-restricted-modules'?: (string | {
-		name: string,
-		message?: string,
-	})[] | ({
-		paths?: (string | {
-			name: string,
-			message?: string,
-		})[],
-		patterns?: (string)[],
-	})[],
-	/**
-	 * Disallow certain properties on certain objects
-	 * @see https://eslint.org/docs/latest/rules/no-restricted-properties
-	 */
-	'no-restricted-properties'?: ({
-		object?: string,
-		property?: string,
-		allowObjects?: (string)[],
-		message?: string,
-	})[],
-	/**
-	 * Disallow specified syntax
-	 * @see https://eslint.org/docs/latest/rules/no-restricted-syntax
-	 */
-	'no-restricted-syntax'?: (string | {
-		selector: string,
-		message?: string,
-	})[],
-	/**
-	 * Disallow assignment operators in `return` statements
-	 * @see https://eslint.org/docs/latest/rules/no-return-assign
-	 */
-	'no-return-assign'?: [("except-parens" | "always")?],
-	/**
-	 * Disallow unnecessary `return await`
-	 * @see https://eslint.org/docs/latest/rules/no-return-await
-	 */
-	'no-return-await'?: [],
-	/**
-	 * Disallow `javascript:` URLs
-	 * @see https://eslint.org/docs/latest/rules/no-script-url
-	 */
-	'no-script-url'?: [],
-	/**
-	 * Disallow assignments where both sides are exactly the same
-	 * @see https://eslint.org/docs/latest/rules/no-self-assign
-	 */
-	'no-self-assign'?: [({
-		props?: boolean,
-	})?],
-	/**
-	 * Disallow comparisons where both sides are exactly the same
-	 * @see https://eslint.org/docs/latest/rules/no-self-compare
-	 */
-	'no-self-compare'?: [],
-	/**
-	 * Disallow comma operators
-	 * @see https://eslint.org/docs/latest/rules/no-sequences
-	 */
-	'no-sequences'?: [({
-		allowInParentheses?: boolean,
-	})?],
-	/**
-	 * Disallow returning values from setters
-	 * @see https://eslint.org/docs/latest/rules/no-setter-return
-	 */
-	'no-setter-return'?: [],
-	/**
-	 * Disallow identifiers from shadowing restricted names
-	 * @see https://eslint.org/docs/latest/rules/no-shadow-restricted-names
-	 */
-	'no-shadow-restricted-names'?: [({
-		reportGlobalThis?: boolean,
-	})?],
-	/**
-	 * Disallow variable declarations from shadowing variables declared in the outer scope
-	 * @see https://eslint.org/docs/latest/rules/no-shadow
-	 */
-	'no-shadow'?: [({
-		builtinGlobals?: boolean,
-		hoist?: "all" | "functions" | "never",
-		allow?: (string)[],
-		ignoreOnInitialization?: boolean,
-	})?],
-	/**
-	 * Disallow spacing between function identifiers and their applications (deprecated)
-	 * @see https://eslint.org/docs/latest/rules/no-spaced-func
-	 */
-	'no-spaced-func'?: [],
-	/**
-	 * Disallow sparse arrays
-	 * @see https://eslint.org/docs/latest/rules/no-sparse-arrays
-	 */
-	'no-sparse-arrays'?: [],
-	/**
-	 * Disallow synchronous methods
-	 * @see https://eslint.org/docs/latest/rules/no-sync
-	 */
-	'no-sync'?: [({
-		allowAtRootLevel?: boolean,
-	})?],
-	/**
-	 * Disallow all tabs
-	 * @see https://eslint.org/docs/latest/rules/no-tabs
-	 */
-	'no-tabs'?: [({
-		allowIndentationTabs?: boolean,
-	})?],
-	/**
-	 * Disallow template literal placeholder syntax in regular strings
-	 * @see https://eslint.org/docs/latest/rules/no-template-curly-in-string
-	 */
-	'no-template-curly-in-string'?: [],
-	/**
-	 * Disallow ternary operators
-	 * @see https://eslint.org/docs/latest/rules/no-ternary
-	 */
-	'no-ternary'?: [],
-	/**
-	 * Disallow `this`/`super` before calling `super()` in constructors
-	 * @see https://eslint.org/docs/latest/rules/no-this-before-super
-	 */
-	'no-this-before-super'?: [],
-	/**
-	 * Disallow throwing literals as exceptions
-	 * @see https://eslint.org/docs/latest/rules/no-throw-literal
-	 */
-	'no-throw-literal'?: [],
-	/**
-	 * Disallow trailing whitespace at the end of lines
-	 * @see https://eslint.org/docs/latest/rules/no-trailing-spaces
-	 */
-	'no-trailing-spaces'?: [({
-		skipBlankLines?: boolean,
-		ignoreComments?: boolean,
-	})?],
-	/**
-	 * Disallow `let` or `var` variables that are read but never assigned
-	 * @see https://eslint.org/docs/latest/rules/no-unassigned-vars
-	 */
-	'no-unassigned-vars'?: [],
-	/**
-	 * Disallow initializing variables to `undefined`
-	 * @see https://eslint.org/docs/latest/rules/no-undef-init
-	 */
-	'no-undef-init'?: [],
-	/**
-	 * Disallow the use of undeclared variables unless mentioned in `/*global * /` comments
-	 * @see https://eslint.org/docs/latest/rules/no-undef
-	 */
-	'no-undef'?: [({
-		typeof?: boolean,
-	})?],
-	/**
-	 * Disallow the use of `undefined` as an identifier
-	 * @see https://eslint.org/docs/latest/rules/no-undefined
-	 */
-	'no-undefined'?: [],
-	/**
-	 * Disallow dangling underscores in identifiers
-	 * @see https://eslint.org/docs/latest/rules/no-underscore-dangle
-	 */
-	'no-underscore-dangle'?: [({
-		allow?: (string)[],
-		allowAfterThis?: boolean,
-		allowAfterSuper?: boolean,
-		allowAfterThisConstructor?: boolean,
-		enforceInMethodNames?: boolean,
-		allowFunctionParams?: boolean,
-		enforceInClassFields?: boolean,
-		allowInArrayDestructuring?: boolean,
-		allowInObjectDestructuring?: boolean,
-	})?],
-	/**
-	 * Disallow confusing multiline expressions
-	 * @see https://eslint.org/docs/latest/rules/no-unexpected-multiline
-	 */
-	'no-unexpected-multiline'?: [],
-	/**
-	 * Disallow unmodified loop conditions
-	 * @see https://eslint.org/docs/latest/rules/no-unmodified-loop-condition
-	 */
-	'no-unmodified-loop-condition'?: [],
-	/**
-	 * Disallow ternary operators when simpler alternatives exist
-	 * @see https://eslint.org/docs/latest/rules/no-unneeded-ternary
-	 */
-	'no-unneeded-ternary'?: [({
-		defaultAssignment?: boolean,
-	})?],
-	/**
-	 * Disallow loops with a body that allows only one iteration
-	 * @see https://eslint.org/docs/latest/rules/no-unreachable-loop
-	 */
-	'no-unreachable-loop'?: [({
-		ignore?: ("WhileStatement" | "DoWhileStatement" | "ForStatement" | "ForInStatement" | "ForOfStatement")[],
-	})?],
-	/**
-	 * Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements
-	 * @see https://eslint.org/docs/latest/rules/no-unreachable
-	 */
-	'no-unreachable'?: [],
-	/**
-	 * Disallow control flow statements in `finally` blocks
-	 * @see https://eslint.org/docs/latest/rules/no-unsafe-finally
-	 */
-	'no-unsafe-finally'?: [],
-	/**
-	 * Disallow negating the left operand of relational operators
-	 * @see https://eslint.org/docs/latest/rules/no-unsafe-negation
-	 */
-	'no-unsafe-negation'?: [({
-		enforceForOrderingRelations?: boolean,
-	})?],
-	/**
-	 * Disallow use of optional chaining in contexts where the `undefined` value is not allowed
-	 * @see https://eslint.org/docs/latest/rules/no-unsafe-optional-chaining
-	 */
-	'no-unsafe-optional-chaining'?: [({
-		disallowArithmeticOperators?: boolean,
-	})?],
-	/**
-	 * Disallow unused expressions
-	 * @see https://eslint.org/docs/latest/rules/no-unused-expressions
-	 */
-	'no-unused-expressions'?: [({
-		allowShortCircuit?: boolean,
-		allowTernary?: boolean,
-		allowTaggedTemplates?: boolean,
-		enforceForJSX?: boolean,
-		ignoreDirectives?: boolean,
-	})?],
-	/**
-	 * Disallow unused labels
-	 * @see https://eslint.org/docs/latest/rules/no-unused-labels
-	 */
-	'no-unused-labels'?: [],
-	/**
-	 * Disallow unused private class members
-	 * @see https://eslint.org/docs/latest/rules/no-unused-private-class-members
-	 */
-	'no-unused-private-class-members'?: [],
-	/**
-	 * Disallow unused variables
-	 * @see https://eslint.org/docs/latest/rules/no-unused-vars
-	 */
-	'no-unused-vars'?: [("all" | "local" | {
-		vars?: "all" | "local",
-		varsIgnorePattern?: string,
-		args?: "all" | "after-used" | "none",
-		ignoreRestSiblings?: boolean,
-		argsIgnorePattern?: string,
-		caughtErrors?: "all" | "none",
-		caughtErrorsIgnorePattern?: string,
-		destructuredArrayIgnorePattern?: string,
-		ignoreClassWithStaticInitBlock?: boolean,
-		reportUsedIgnorePattern?: boolean,
-	})?],
-	/**
-	 * Disallow the use of variables before they are defined
-	 * @see https://eslint.org/docs/latest/rules/no-use-before-define
-	 */
-	'no-use-before-define'?: [("nofunc" | {
-		functions?: boolean,
-		classes?: boolean,
-		variables?: boolean,
-		allowNamedExports?: boolean,
-	})?],
-	/**
-	 * Disallow variable assignments when the value is not used
-	 * @see https://eslint.org/docs/latest/rules/no-useless-assignment
-	 */
-	'no-useless-assignment'?: [],
-	/**
-	 * Disallow useless backreferences in regular expressions
-	 * @see https://eslint.org/docs/latest/rules/no-useless-backreference
-	 */
-	'no-useless-backreference'?: [],
-	/**
-	 * Disallow unnecessary calls to `.call()` and `.apply()`
-	 * @see https://eslint.org/docs/latest/rules/no-useless-call
-	 */
-	'no-useless-call'?: [],
-	/**
-	 * Disallow unnecessary `catch` clauses
-	 * @see https://eslint.org/docs/latest/rules/no-useless-catch
-	 */
-	'no-useless-catch'?: [],
-	/**
-	 * Disallow unnecessary computed property keys in objects and classes
-	 * @see https://eslint.org/docs/latest/rules/no-useless-computed-key
-	 */
-	'no-useless-computed-key'?: [({
-		enforceForClassMembers?: boolean,
-	})?],
-	/**
-	 * Disallow unnecessary concatenation of literals or template literals
-	 * @see https://eslint.org/docs/latest/rules/no-useless-concat
-	 */
-	'no-useless-concat'?: [],
-	/**
-	 * Disallow unnecessary constructors
-	 * @see https://eslint.org/docs/latest/rules/no-useless-constructor
-	 */
-	'no-useless-constructor'?: [],
-	/**
-	 * Disallow unnecessary escape characters
-	 * @see https://eslint.org/docs/latest/rules/no-useless-escape
-	 */
-	'no-useless-escape'?: [({
-		allowRegexCharacters?: (string)[],
-	})?],
-	/**
-	 * Disallow renaming import, export, and destructured assignments to the same name
-	 * @see https://eslint.org/docs/latest/rules/no-useless-rename
-	 */
-	'no-useless-rename'?: [({
-		ignoreDestructuring?: boolean,
-		ignoreImport?: boolean,
-		ignoreExport?: boolean,
-	})?],
-	/**
-	 * Disallow redundant return statements
-	 * @see https://eslint.org/docs/latest/rules/no-useless-return
-	 */
-	'no-useless-return'?: [],
-	/**
-	 * Require `let` or `const` instead of `var`
-	 * @see https://eslint.org/docs/latest/rules/no-var
-	 */
-	'no-var'?: [],
-	/**
-	 * Disallow `void` operators
-	 * @see https://eslint.org/docs/latest/rules/no-void
-	 */
-	'no-void'?: [({
-		allowAsStatement?: boolean,
-	})?],
-	/**
-	 * Disallow specified warning terms in comments
-	 * @see https://eslint.org/docs/latest/rules/no-warning-comments
-	 */
-	'no-warning-comments'?: [({
-		terms?: (string)[],
-		location?: "start" | "anywhere",
-		decoration?: (string)[],
-	})?],
-	/**
-	 * Disallow whitespace before properties
-	 * @see https://eslint.org/docs/latest/rules/no-whitespace-before-property
-	 */
-	'no-whitespace-before-property'?: [],
-	/**
-	 * Disallow `with` statements
-	 * @see https://eslint.org/docs/latest/rules/no-with
-	 */
-	'no-with'?: [],
-	/**
-	 * Enforce the location of single-line statements
-	 * @see https://eslint.org/docs/latest/rules/nonblock-statement-body-position
-	 */
-	'nonblock-statement-body-position'?: [("beside" | "below" | "any")?, ({
-		overrides?: {
-			if?: "beside" | "below" | "any",
-			else?: "beside" | "below" | "any",
-			while?: "beside" | "below" | "any",
-			do?: "beside" | "below" | "any",
-			for?: "beside" | "below" | "any",
-		},
-	})?],
-	/**
-	 * Enforce consistent line breaks after opening and before closing braces
-	 * @see https://eslint.org/docs/latest/rules/object-curly-newline
-	 */
-	'object-curly-newline'?: [("always" | "never" | {
-		multiline?: boolean,
-		minProperties?: number,
-		consistent?: boolean,
-	} | {
-		ObjectExpression?: "always" | "never" | {
-			multiline?: boolean,
-			minProperties?: number,
-			consistent?: boolean,
-		},
-		ObjectPattern?: "always" | "never" | {
-			multiline?: boolean,
-			minProperties?: number,
-			consistent?: boolean,
-		},
-		ImportDeclaration?: "always" | "never" | {
-			multiline?: boolean,
-			minProperties?: number,
-			consistent?: boolean,
-		},
-		ExportDeclaration?: "always" | "never" | {
-			multiline?: boolean,
-			minProperties?: number,
-			consistent?: boolean,
-		},
-	})?],
-	/**
-	 * Enforce consistent spacing inside braces
-	 * @see https://eslint.org/docs/latest/rules/object-curly-spacing
-	 */
-	'object-curly-spacing'?: [("always" | "never")?, ({
-		arraysInObjects?: boolean,
-		objectsInObjects?: boolean,
-	})?],
-	/**
-	 * Enforce placing object properties on separate lines
-	 * @see https://eslint.org/docs/latest/rules/object-property-newline
-	 */
-	'object-property-newline'?: [({
-		allowAllPropertiesOnSameLine?: boolean,
-		allowMultiplePropertiesPerLine?: boolean,
-	})?],
-	/**
-	 * Require or disallow method and property shorthand syntax for object literals
-	 * @see https://eslint.org/docs/latest/rules/object-shorthand
-	 */
-	'object-shorthand'?: ["always" | "methods" | "properties" | "never" | "consistent" | "consistent-as-needed"] | ["always" | "methods" | "properties", {
-		avoidQuotes?: boolean,
-	}] | ["always" | "methods", {
-		ignoreConstructors?: boolean,
-		methodsIgnorePattern?: string,
-		avoidQuotes?: boolean,
-		avoidExplicitReturnArrows?: boolean,
-	}],
-	/**
-	 * Require or disallow newlines around variable declarations
-	 * @see https://eslint.org/docs/latest/rules/one-var-declaration-per-line
-	 */
-	'one-var-declaration-per-line'?: [("always" | "initializations")?],
-	/**
-	 * Enforce variables to be declared either together or separately in functions
-	 * @see https://eslint.org/docs/latest/rules/one-var
-	 */
-	'one-var'?: [("always" | "never" | "consecutive" | {
-		separateRequires?: boolean,
-		var?: "always" | "never" | "consecutive",
-		let?: "always" | "never" | "consecutive",
-		const?: "always" | "never" | "consecutive",
-	} | {
-		initialized?: "always" | "never" | "consecutive",
-		uninitialized?: "always" | "never" | "consecutive",
-	})?],
-	/**
-	 * Require or disallow assignment operator shorthand where possible
-	 * @see https://eslint.org/docs/latest/rules/operator-assignment
-	 */
-	'operator-assignment'?: [("always" | "never")?],
-	/**
-	 * Enforce consistent linebreak style for operators
-	 * @see https://eslint.org/docs/latest/rules/operator-linebreak
-	 */
-	'operator-linebreak'?: [("after" | "before" | "none" | null)?, ({
-		overrides?: { [key: string]: unknown },
-	})?],
-	/**
-	 * Require or disallow padding within blocks
-	 * @see https://eslint.org/docs/latest/rules/padded-blocks
-	 */
-	'padded-blocks'?: [("always" | "never" | {
-		blocks?: "always" | "never",
-		switches?: "always" | "never",
-		classes?: "always" | "never",
-	})?, ({
-		allowSingleLineBlocks?: boolean,
-	})?],
-	/**
-	 * Require or disallow padding lines between statements
-	 * @see https://eslint.org/docs/latest/rules/padding-line-between-statements
-	 */
-	'padding-line-between-statements'?: ({
-		blankLine: Def21_paddingType,
-		prev: Def22_statementType,
-		next: Def22_statementType,
-	})[],
-	/**
-	 * Require using arrow functions for callbacks
-	 * @see https://eslint.org/docs/latest/rules/prefer-arrow-callback
-	 */
-	'prefer-arrow-callback'?: [({
-		allowNamedFunctions?: boolean,
-		allowUnboundThis?: boolean,
-	})?],
-	/**
-	 * Require `const` declarations for variables that are never reassigned after declared
-	 * @see https://eslint.org/docs/latest/rules/prefer-const
-	 */
-	'prefer-const'?: [({
-		destructuring?: "any" | "all",
-		ignoreReadBeforeAssign?: boolean,
-	})?],
-	/**
-	 * Require destructuring from arrays and/or objects
-	 * @see https://eslint.org/docs/latest/rules/prefer-destructuring
-	 */
-	'prefer-destructuring'?: [({
-		VariableDeclarator?: {
-			array?: boolean,
-			object?: boolean,
-		},
-		AssignmentExpression?: {
-			array?: boolean,
-			object?: boolean,
-		},
-	} | {
-		array?: boolean,
-		object?: boolean,
-	})?, ({
-		enforceForRenamedProperties?: boolean,
-	})?],
-	/**
-	 * Disallow the use of `Math.pow` in favor of the `**` operator
-	 * @see https://eslint.org/docs/latest/rules/prefer-exponentiation-operator
-	 */
-	'prefer-exponentiation-operator'?: [],
-	/**
-	 * Enforce using named capture group in regular expression
-	 * @see https://eslint.org/docs/latest/rules/prefer-named-capture-group
-	 */
-	'prefer-named-capture-group'?: [],
-	/**
-	 * Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals
-	 * @see https://eslint.org/docs/latest/rules/prefer-numeric-literals
-	 */
-	'prefer-numeric-literals'?: [],
-	/**
-	 * Disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`
-	 * @see https://eslint.org/docs/latest/rules/prefer-object-has-own
-	 */
-	'prefer-object-has-own'?: [],
-	/**
-	 * Disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead
-	 * @see https://eslint.org/docs/latest/rules/prefer-object-spread
-	 */
-	'prefer-object-spread'?: [],
-	/**
-	 * Require using Error objects as Promise rejection reasons
-	 * @see https://eslint.org/docs/latest/rules/prefer-promise-reject-errors
-	 */
-	'prefer-promise-reject-errors'?: [({
-		allowEmptyReject?: boolean,
-	})?],
-	/**
-	 * Require `Reflect` methods where applicable
-	 * @see https://eslint.org/docs/latest/rules/prefer-reflect
-	 */
-	'prefer-reflect'?: [({
-		exceptions?: ("apply" | "call" | "delete" | "defineProperty" | "getOwnPropertyDescriptor" | "getPrototypeOf" | "setPrototypeOf" | "isExtensible" | "getOwnPropertyNames" | "preventExtensions")[],
-	})?],
-	/**
-	 * Disallow use of the `RegExp` constructor in favor of regular expression literals
-	 * @see https://eslint.org/docs/latest/rules/prefer-regex-literals
-	 */
-	'prefer-regex-literals'?: [({
-		disallowRedundantWrapping?: boolean,
-	})?],
-	/**
-	 * Require rest parameters instead of `arguments`
-	 * @see https://eslint.org/docs/latest/rules/prefer-rest-params
-	 */
-	'prefer-rest-params'?: [],
-	/**
-	 * Require spread operators instead of `.apply()`
-	 * @see https://eslint.org/docs/latest/rules/prefer-spread
-	 */
-	'prefer-spread'?: [],
-	/**
-	 * Require template literals instead of string concatenation
-	 * @see https://eslint.org/docs/latest/rules/prefer-template
-	 */
-	'prefer-template'?: [],
-	/**
-	 * Require quotes around object literal property names
-	 * @see https://eslint.org/docs/latest/rules/quote-props
-	 */
-	'quote-props'?: ["always" | "as-needed" | "consistent" | "consistent-as-needed"] | ["always" | "as-needed" | "consistent" | "consistent-as-needed", {
-		keywords?: boolean,
-		unnecessary?: boolean,
-		numbers?: boolean,
-	}],
-	/**
-	 * Enforce the consistent use of either backticks, double, or single quotes
-	 * @see https://eslint.org/docs/latest/rules/quotes
-	 */
-	'quotes'?: [("single" | "double" | "backtick")?, ("avoid-escape" | {
-		avoidEscape?: boolean,
-		allowTemplateLiterals?: boolean,
-	})?],
-	/**
-	 * Enforce the consistent use of the radix argument when using `parseInt()`
-	 * @see https://eslint.org/docs/latest/rules/radix
-	 */
-	'radix'?: [("always" | "as-needed")?],
-	/**
-	 * Disallow assignments that can lead to race conditions due to usage of `await` or `yield`
-	 * @see https://eslint.org/docs/latest/rules/require-atomic-updates
-	 */
-	'require-atomic-updates'?: [({
-		allowProperties?: boolean,
-	})?],
-	/**
-	 * Disallow async functions which have no `await` expression
-	 * @see https://eslint.org/docs/latest/rules/require-await
-	 */
-	'require-await'?: [],
-	/**
-	 * Enforce the use of `u` or `v` flag on regular expressions
-	 * @see https://eslint.org/docs/latest/rules/require-unicode-regexp
-	 */
-	'require-unicode-regexp'?: [({
-		requireFlag?: "u" | "v",
-	})?],
-	/**
-	 * Require generator functions to contain `yield`
-	 * @see https://eslint.org/docs/latest/rules/require-yield
-	 */
-	'require-yield'?: [],
-	/**
-	 * Enforce spacing between rest and spread operators and their expressions
-	 * @see https://eslint.org/docs/latest/rules/rest-spread-spacing
-	 */
-	'rest-spread-spacing'?: [("always" | "never")?],
-	/**
-	 * Enforce consistent spacing before and after semicolons
-	 * @see https://eslint.org/docs/latest/rules/semi-spacing
-	 */
-	'semi-spacing'?: [({
-		before?: boolean,
-		after?: boolean,
-	})?],
-	/**
-	 * Enforce location of semicolons
-	 * @see https://eslint.org/docs/latest/rules/semi-style
-	 */
-	'semi-style'?: [("last" | "first")?],
-	/**
-	 * Require or disallow semicolons instead of ASI
-	 * @see https://eslint.org/docs/latest/rules/semi
-	 */
-	'semi'?: ["never", {
-		beforeStatementContinuationChars?: "always" | "any" | "never",
-	}] | ["always", {
-		omitLastInOneLineBlock?: boolean,
-		omitLastInOneLineClassBody?: boolean,
-	}],
-	/**
-	 * Enforce sorted `import` declarations within modules
-	 * @see https://eslint.org/docs/latest/rules/sort-imports
-	 */
-	'sort-imports'?: [({
-		ignoreCase?: boolean,
-		memberSyntaxSortOrder?: ("none" | "all" | "multiple" | "single")[],
-		ignoreDeclarationSort?: boolean,
-		ignoreMemberSort?: boolean,
-		allowSeparatedGroups?: boolean,
-	})?],
-	/**
-	 * Require object keys to be sorted
-	 * @see https://eslint.org/docs/latest/rules/sort-keys
-	 */
-	'sort-keys'?: [("asc" | "desc")?, ({
-		caseSensitive?: boolean,
-		natural?: boolean,
-		minKeys?: number,
-		allowLineSeparatedGroups?: boolean,
-		ignoreComputedKeys?: boolean,
-	})?],
-	/**
-	 * Require variables within the same declaration block to be sorted
-	 * @see https://eslint.org/docs/latest/rules/sort-vars
-	 */
-	'sort-vars'?: [({
-		ignoreCase?: boolean,
-	})?],
-	/**
-	 * Enforce consistent spacing before blocks
-	 * @see https://eslint.org/docs/latest/rules/space-before-blocks
-	 */
-	'space-before-blocks'?: [("always" | "never" | {
-		keywords?: "always" | "never" | "off",
-		functions?: "always" | "never" | "off",
-		classes?: "always" | "never" | "off",
-	})?],
-	/**
-	 * Enforce consistent spacing before `function` definition opening parenthesis
-	 * @see https://eslint.org/docs/latest/rules/space-before-function-paren
-	 */
-	'space-before-function-paren'?: [("always" | "never" | {
-		anonymous?: "always" | "never" | "ignore",
-		named?: "always" | "never" | "ignore",
-		asyncArrow?: "always" | "never" | "ignore",
-	})?],
-	/**
-	 * Enforce consistent spacing inside parentheses
-	 * @see https://eslint.org/docs/latest/rules/space-in-parens
-	 */
-	'space-in-parens'?: [("always" | "never")?, ({
-		exceptions?: ("{}" | "[]" | "()" | "empty")[],
-	})?],
-	/**
-	 * Require spacing around infix operators
-	 * @see https://eslint.org/docs/latest/rules/space-infix-ops
-	 */
-	'space-infix-ops'?: [({
-		int32Hint?: boolean,
-	})?],
-	/**
-	 * Enforce consistent spacing before or after unary operators
-	 * @see https://eslint.org/docs/latest/rules/space-unary-ops
-	 */
-	'space-unary-ops'?: [({
-		words?: boolean,
-		nonwords?: boolean,
-		overrides?: { [key: string]: unknown },
-	})?],
-	/**
-	 * Enforce consistent spacing after the `//` or `/*` in a comment
-	 * @see https://eslint.org/docs/latest/rules/spaced-comment
-	 */
-	'spaced-comment'?: [("always" | "never")?, ({
-		exceptions?: (string)[],
-		markers?: (string)[],
-		line?: {
-			exceptions?: (string)[],
-			markers?: (string)[],
-		},
-		block?: {
-			exceptions?: (string)[],
-			markers?: (string)[],
-			balanced?: boolean,
-		},
-	})?],
-	/**
-	 * Require or disallow strict mode directives
-	 * @see https://eslint.org/docs/latest/rules/strict
-	 */
-	'strict'?: [("never" | "global" | "function" | "safe")?],
-	/**
-	 * Enforce spacing around colons of switch statements
-	 * @see https://eslint.org/docs/latest/rules/switch-colon-spacing
-	 */
-	'switch-colon-spacing'?: [({
-		before?: boolean,
-		after?: boolean,
-	})?],
-	/**
-	 * Require symbol descriptions
-	 * @see https://eslint.org/docs/latest/rules/symbol-description
-	 */
-	'symbol-description'?: [],
-	/**
-	 * Require or disallow spacing around embedded expressions of template strings
-	 * @see https://eslint.org/docs/latest/rules/template-curly-spacing
-	 */
-	'template-curly-spacing'?: [("always" | "never")?],
-	/**
-	 * Require or disallow spacing between template tags and their literals
-	 * @see https://eslint.org/docs/latest/rules/template-tag-spacing
-	 */
-	'template-tag-spacing'?: [("always" | "never")?],
-	/**
-	 * Require or disallow Unicode byte order mark (BOM)
-	 * @see https://eslint.org/docs/latest/rules/unicode-bom
-	 */
-	'unicode-bom'?: [("always" | "never")?],
-	/**
-	 * Require calls to `isNaN()` when checking for `NaN`
-	 * @see https://eslint.org/docs/latest/rules/use-isnan
-	 */
-	'use-isnan'?: [({
-		enforceForSwitchCase?: boolean,
-		enforceForIndexOf?: boolean,
-	})?],
-	/**
-	 * Enforce comparing `typeof` expressions against valid strings
-	 * @see https://eslint.org/docs/latest/rules/valid-typeof
-	 */
-	'valid-typeof'?: [({
-		requireStringLiterals?: boolean,
-	})?],
-	/**
-	 * Require `var` declarations be placed at the top of their containing scope
-	 * @see https://eslint.org/docs/latest/rules/vars-on-top
-	 */
-	'vars-on-top'?: [],
-	/**
-	 * Require parentheses around immediate `function` invocations
-	 * @see https://eslint.org/docs/latest/rules/wrap-iife
-	 */
-	'wrap-iife'?: [("outside" | "inside" | "any")?, ({
-		functionPrototypeMethods?: boolean,
-	})?],
-	/**
-	 * Require parenthesis around regex literals
-	 * @see https://eslint.org/docs/latest/rules/wrap-regex
-	 */
-	'wrap-regex'?: [],
-	/**
-	 * Require or disallow spacing around the `*` in `yield*` expressions
-	 * @see https://eslint.org/docs/latest/rules/yield-star-spacing
-	 */
-	'yield-star-spacing'?: [("before" | "after" | "both" | "neither" | {
-		before?: boolean,
-		after?: boolean,
-	})?],
-	/**
-	 * Require or disallow "Yoda" conditions
-	 * @see https://eslint.org/docs/latest/rules/yoda
-	 */
-	'yoda'?: [("always" | "never")?, ({
-		exceptRange?: boolean,
-		onlyEquality?: boolean,
-	})?],
-	/**
-	 * Expects type error, type snapshot, or type.
-	 * @see https://github.com/JoshuaKGoldberg/eslint-plugin-expect-type/blob/main/docs/rules/expect.md
-	 */
-	'expect-type/expect'?: [({
-		disableExpectTypeSnapshotFix?: boolean,
-	})?],
+export interface ESLintRulesConfig extends Record<string, any[]> {
+    [key: string]: any[];
 }
-
-type Def0_arrayOption = "array" | "generic" | "array-simple";
-type Def1_directiveConfigSchema = boolean | "allow-with-description" | {
-	descriptionFormat?: string,
-};
-type Def2_accessibilityLevel = "explicit" | "no-public" | "off";
-type Def4_allItems = "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";
-type Def5_optionalityOrderOptions = "optional-first" | "required-first";
-type Def6_orderOptions = "alphabetically" | "alphabetically-case-insensitive" | "as-written" | "natural" | "natural-case-insensitive";
-type Def3_baseConfig = "never" | (Def4_allItems | (Def4_allItems)[])[] | {
-	memberTypes?: (Def4_allItems | (Def4_allItems)[])[] | "never",
-	optionalityOrder?: Def5_optionalityOrderOptions,
-	order?: Def6_orderOptions,
-};
-type Def8_typeItems = "readonly-signature" | "signature" | "readonly-field" | "field" | "method" | "constructor";
-type Def7_typesConfig = "never" | (Def8_typeItems | (Def8_typeItems)[])[] | {
-	memberTypes?: (Def8_typeItems | (Def8_typeItems)[])[] | "never",
-	optionalityOrder?: Def5_optionalityOrderOptions,
-	order?: Def6_orderOptions,
-};
-type Def9_matchRegexConfig = {
-	match: boolean,
-	regex: string,
-};
-type Def11_predefinedFormats = "camelCase" | "strictCamelCase" | "PascalCase" | "StrictPascalCase" | "snake_case" | "UPPER_CASE";
-type Def10_formatOptionsConfig = (Def11_predefinedFormats)[] | null;
-type Def12_underscoreOptions = "forbid" | "allow" | "require" | "requireDouble" | "allowDouble" | "allowSingleOrDouble";
-type Def13_prefixSuffixConfig = (string)[];
-type Def14_typeModifiers = "boolean" | "string" | "number" | "function" | "array";
-type Def15_expandedOptions = "always" | "never" | "in-unions" | "in-intersections" | "in-unions-and-intersections";
-type Def16_simpleOptions = "always" | "never";
-type Def17_modifier = "readonly" | "private" | "protected" | "public" | "private readonly" | "protected readonly" | "public readonly";
-type Def18_basicConfig = "always" | "never" | "consistent" | {
-	multiline?: boolean,
-	minItems?: number | null,
-};
-type Def19_value = "always-multiline" | "always" | "never" | "only-multiline";
-type Def20_valueWithIgnore = "always-multiline" | "always" | "ignore" | "never" | "only-multiline";
-type Def21_paddingType = "any" | "never" | "always";
-type Def22_statementType = "*" | "block-like" | "cjs-export" | "cjs-import" | "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" | ("*" | "block-like" | "cjs-export" | "cjs-import" | "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")[];