@kazupon/eslint-config 0.18.0 → 0.20.0

package/dist/types/gens/javascript.d.cts

@@ -1,3163 +0,0 @@
-import type { Linter } from 'eslint';
-export interface JavascriptRules {
-    /**
-     * Enforce getter and setter pairs in objects and classes
-     * @see https://eslint.org/docs/latest/rules/accessor-pairs
-     */
-    'accessor-pairs'?: Linter.RuleEntry<AccessorPairs>;
-    /**
-     * Enforce linebreaks after opening and before closing array brackets
-     * @see https://eslint.org/docs/latest/rules/array-bracket-newline
-     * @deprecated
-     */
-    'array-bracket-newline'?: Linter.RuleEntry<ArrayBracketNewline>;
-    /**
-     * Enforce consistent spacing inside array brackets
-     * @see https://eslint.org/docs/latest/rules/array-bracket-spacing
-     * @deprecated
-     */
-    'array-bracket-spacing'?: Linter.RuleEntry<ArrayBracketSpacing>;
-    /**
-     * Enforce `return` statements in callbacks of array methods
-     * @see https://eslint.org/docs/latest/rules/array-callback-return
-     */
-    'array-callback-return'?: Linter.RuleEntry<ArrayCallbackReturn>;
-    /**
-     * Enforce line breaks after each array element
-     * @see https://eslint.org/docs/latest/rules/array-element-newline
-     * @deprecated
-     */
-    'array-element-newline'?: Linter.RuleEntry<ArrayElementNewline>;
-    /**
-     * Require braces around arrow function bodies
-     * @see https://eslint.org/docs/latest/rules/arrow-body-style
-     */
-    'arrow-body-style'?: Linter.RuleEntry<ArrowBodyStyle>;
-    /**
-     * Require parentheses around arrow function arguments
-     * @see https://eslint.org/docs/latest/rules/arrow-parens
-     * @deprecated
-     */
-    'arrow-parens'?: Linter.RuleEntry<ArrowParens>;
-    /**
-     * Enforce consistent spacing before and after the arrow in arrow functions
-     * @see https://eslint.org/docs/latest/rules/arrow-spacing
-     * @deprecated
-     */
-    'arrow-spacing'?: Linter.RuleEntry<ArrowSpacing>;
-    /**
-     * Enforce the use of variables within the scope they are defined
-     * @see https://eslint.org/docs/latest/rules/block-scoped-var
-     */
-    'block-scoped-var'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow or enforce spaces inside of blocks after opening block and before closing block
-     * @see https://eslint.org/docs/latest/rules/block-spacing
-     * @deprecated
-     */
-    'block-spacing'?: Linter.RuleEntry<BlockSpacing>;
-    /**
-     * Enforce consistent brace style for blocks
-     * @see https://eslint.org/docs/latest/rules/brace-style
-     * @deprecated
-     */
-    'brace-style'?: Linter.RuleEntry<BraceStyle>;
-    /**
-     * Require `return` statements after callbacks
-     * @see https://eslint.org/docs/latest/rules/callback-return
-     * @deprecated
-     */
-    'callback-return'?: Linter.RuleEntry<CallbackReturn>;
-    /**
-     * Enforce camelcase naming convention
-     * @see https://eslint.org/docs/latest/rules/camelcase
-     */
-    'camelcase'?: Linter.RuleEntry<Camelcase>;
-    /**
-     * Enforce or disallow capitalization of the first letter of a comment
-     * @see https://eslint.org/docs/latest/rules/capitalized-comments
-     */
-    'capitalized-comments'?: Linter.RuleEntry<CapitalizedComments>;
-    /**
-     * Enforce that class methods utilize `this`
-     * @see https://eslint.org/docs/latest/rules/class-methods-use-this
-     */
-    'class-methods-use-this'?: Linter.RuleEntry<ClassMethodsUseThis>;
-    /**
-     * Require or disallow trailing commas
-     * @see https://eslint.org/docs/latest/rules/comma-dangle
-     * @deprecated
-     */
-    'comma-dangle'?: Linter.RuleEntry<CommaDangle>;
-    /**
-     * Enforce consistent spacing before and after commas
-     * @see https://eslint.org/docs/latest/rules/comma-spacing
-     * @deprecated
-     */
-    'comma-spacing'?: Linter.RuleEntry<CommaSpacing>;
-    /**
-     * Enforce consistent comma style
-     * @see https://eslint.org/docs/latest/rules/comma-style
-     * @deprecated
-     */
-    'comma-style'?: Linter.RuleEntry<CommaStyle>;
-    /**
-     * Enforce a maximum cyclomatic complexity allowed in a program
-     * @see https://eslint.org/docs/latest/rules/complexity
-     */
-    'complexity'?: Linter.RuleEntry<Complexity>;
-    /**
-     * Enforce consistent spacing inside computed property brackets
-     * @see https://eslint.org/docs/latest/rules/computed-property-spacing
-     * @deprecated
-     */
-    'computed-property-spacing'?: Linter.RuleEntry<ComputedPropertySpacing>;
-    /**
-     * Require `return` statements to either always or never specify values
-     * @see https://eslint.org/docs/latest/rules/consistent-return
-     */
-    'consistent-return'?: Linter.RuleEntry<ConsistentReturn>;
-    /**
-     * Enforce consistent naming when capturing the current execution context
-     * @see https://eslint.org/docs/latest/rules/consistent-this
-     */
-    'consistent-this'?: Linter.RuleEntry<ConsistentThis>;
-    /**
-     * Require `super()` calls in constructors
-     * @see https://eslint.org/docs/latest/rules/constructor-super
-     */
-    'constructor-super'?: Linter.RuleEntry<[]>;
-    /**
-     * Enforce consistent brace style for all control statements
-     * @see https://eslint.org/docs/latest/rules/curly
-     */
-    'curly'?: Linter.RuleEntry<Curly>;
-    /**
-     * Require `default` cases in `switch` statements
-     * @see https://eslint.org/docs/latest/rules/default-case
-     */
-    'default-case'?: Linter.RuleEntry<DefaultCase>;
-    /**
-     * Enforce default clauses in switch statements to be last
-     * @see https://eslint.org/docs/latest/rules/default-case-last
-     */
-    'default-case-last'?: Linter.RuleEntry<[]>;
-    /**
-     * Enforce default parameters to be last
-     * @see https://eslint.org/docs/latest/rules/default-param-last
-     */
-    'default-param-last'?: Linter.RuleEntry<[]>;
-    /**
-     * Enforce consistent newlines before and after dots
-     * @see https://eslint.org/docs/latest/rules/dot-location
-     * @deprecated
-     */
-    'dot-location'?: Linter.RuleEntry<DotLocation>;
-    /**
-     * Enforce dot notation whenever possible
-     * @see https://eslint.org/docs/latest/rules/dot-notation
-     */
-    'dot-notation'?: Linter.RuleEntry<DotNotation>;
-    /**
-     * Require or disallow newline at the end of files
-     * @see https://eslint.org/docs/latest/rules/eol-last
-     * @deprecated
-     */
-    'eol-last'?: Linter.RuleEntry<EolLast>;
-    /**
-     * Require the use of `===` and `!==`
-     * @see https://eslint.org/docs/latest/rules/eqeqeq
-     */
-    'eqeqeq'?: Linter.RuleEntry<Eqeqeq>;
-    /**
-     * Enforce "for" loop update clause moving the counter in the right direction
-     * @see https://eslint.org/docs/latest/rules/for-direction
-     */
-    'for-direction'?: Linter.RuleEntry<[]>;
-    /**
-     * Require or disallow spacing between function identifiers and their invocations
-     * @see https://eslint.org/docs/latest/rules/func-call-spacing
-     * @deprecated
-     */
-    'func-call-spacing'?: Linter.RuleEntry<FuncCallSpacing>;
-    /**
-     * Require function names to match the name of the variable or property to which they are assigned
-     * @see https://eslint.org/docs/latest/rules/func-name-matching
-     */
-    'func-name-matching'?: Linter.RuleEntry<FuncNameMatching>;
-    /**
-     * Require or disallow named `function` expressions
-     * @see https://eslint.org/docs/latest/rules/func-names
-     */
-    'func-names'?: Linter.RuleEntry<FuncNames>;
-    /**
-     * Enforce the consistent use of either `function` declarations or expressions assigned to variables
-     * @see https://eslint.org/docs/latest/rules/func-style
-     */
-    'func-style'?: Linter.RuleEntry<FuncStyle>;
-    /**
-     * Enforce line breaks between arguments of a function call
-     * @see https://eslint.org/docs/latest/rules/function-call-argument-newline
-     * @deprecated
-     */
-    'function-call-argument-newline'?: Linter.RuleEntry<FunctionCallArgumentNewline>;
-    /**
-     * Enforce consistent line breaks inside function parentheses
-     * @see https://eslint.org/docs/latest/rules/function-paren-newline
-     * @deprecated
-     */
-    'function-paren-newline'?: Linter.RuleEntry<FunctionParenNewline>;
-    /**
-     * Enforce consistent spacing around `*` operators in generator functions
-     * @see https://eslint.org/docs/latest/rules/generator-star-spacing
-     * @deprecated
-     */
-    'generator-star-spacing'?: Linter.RuleEntry<GeneratorStarSpacing>;
-    /**
-     * Enforce `return` statements in getters
-     * @see https://eslint.org/docs/latest/rules/getter-return
-     */
-    'getter-return'?: Linter.RuleEntry<GetterReturn>;
-    /**
-     * Require `require()` calls to be placed at top-level module scope
-     * @see https://eslint.org/docs/latest/rules/global-require
-     * @deprecated
-     */
-    'global-require'?: Linter.RuleEntry<[]>;
-    /**
-     * Require grouped accessor pairs in object literals and classes
-     * @see https://eslint.org/docs/latest/rules/grouped-accessor-pairs
-     */
-    'grouped-accessor-pairs'?: Linter.RuleEntry<GroupedAccessorPairs>;
-    /**
-     * Require `for-in` loops to include an `if` statement
-     * @see https://eslint.org/docs/latest/rules/guard-for-in
-     */
-    'guard-for-in'?: Linter.RuleEntry<[]>;
-    /**
-     * Require error handling in callbacks
-     * @see https://eslint.org/docs/latest/rules/handle-callback-err
-     * @deprecated
-     */
-    'handle-callback-err'?: Linter.RuleEntry<HandleCallbackErr>;
-    /**
-     * Disallow specified identifiers
-     * @see https://eslint.org/docs/latest/rules/id-blacklist
-     * @deprecated
-     */
-    'id-blacklist'?: Linter.RuleEntry<IdBlacklist>;
-    /**
-     * Disallow specified identifiers
-     * @see https://eslint.org/docs/latest/rules/id-denylist
-     */
-    'id-denylist'?: Linter.RuleEntry<IdDenylist>;
-    /**
-     * Enforce minimum and maximum identifier lengths
-     * @see https://eslint.org/docs/latest/rules/id-length
-     */
-    'id-length'?: Linter.RuleEntry<IdLength>;
-    /**
-     * Require identifiers to match a specified regular expression
-     * @see https://eslint.org/docs/latest/rules/id-match
-     */
-    'id-match'?: Linter.RuleEntry<IdMatch>;
-    /**
-     * Enforce the location of arrow function bodies
-     * @see https://eslint.org/docs/latest/rules/implicit-arrow-linebreak
-     * @deprecated
-     */
-    'implicit-arrow-linebreak'?: Linter.RuleEntry<ImplicitArrowLinebreak>;
-    /**
-     * Enforce consistent indentation
-     * @see https://eslint.org/docs/latest/rules/indent
-     * @deprecated
-     */
-    'indent'?: Linter.RuleEntry<Indent>;
-    /**
-     * Enforce consistent indentation
-     * @see https://eslint.org/docs/latest/rules/indent-legacy
-     * @deprecated
-     */
-    'indent-legacy'?: Linter.RuleEntry<IndentLegacy>;
-    /**
-     * Require or disallow initialization in variable declarations
-     * @see https://eslint.org/docs/latest/rules/init-declarations
-     */
-    'init-declarations'?: Linter.RuleEntry<InitDeclarations>;
-    /**
-     * Enforce the consistent use of either double or single quotes in JSX attributes
-     * @see https://eslint.org/docs/latest/rules/jsx-quotes
-     * @deprecated
-     */
-    'jsx-quotes'?: Linter.RuleEntry<JsxQuotes>;
-    /**
-     * Enforce consistent spacing between keys and values in object literal properties
-     * @see https://eslint.org/docs/latest/rules/key-spacing
-     * @deprecated
-     */
-    'key-spacing'?: Linter.RuleEntry<KeySpacing>;
-    /**
-     * Enforce consistent spacing before and after keywords
-     * @see https://eslint.org/docs/latest/rules/keyword-spacing
-     * @deprecated
-     */
-    'keyword-spacing'?: Linter.RuleEntry<KeywordSpacing>;
-    /**
-     * Enforce position of line comments
-     * @see https://eslint.org/docs/latest/rules/line-comment-position
-     * @deprecated
-     */
-    'line-comment-position'?: Linter.RuleEntry<LineCommentPosition>;
-    /**
-     * Enforce consistent linebreak style
-     * @see https://eslint.org/docs/latest/rules/linebreak-style
-     * @deprecated
-     */
-    'linebreak-style'?: Linter.RuleEntry<LinebreakStyle>;
-    /**
-     * Require empty lines around comments
-     * @see https://eslint.org/docs/latest/rules/lines-around-comment
-     * @deprecated
-     */
-    'lines-around-comment'?: Linter.RuleEntry<LinesAroundComment>;
-    /**
-     * Require or disallow newlines around directives
-     * @see https://eslint.org/docs/latest/rules/lines-around-directive
-     * @deprecated
-     */
-    'lines-around-directive'?: Linter.RuleEntry<LinesAroundDirective>;
-    /**
-     * Require or disallow an empty line between class members
-     * @see https://eslint.org/docs/latest/rules/lines-between-class-members
-     * @deprecated
-     */
-    'lines-between-class-members'?: Linter.RuleEntry<LinesBetweenClassMembers>;
-    /**
-     * Require or disallow logical assignment operator shorthand
-     * @see https://eslint.org/docs/latest/rules/logical-assignment-operators
-     */
-    'logical-assignment-operators'?: Linter.RuleEntry<LogicalAssignmentOperators>;
-    /**
-     * Enforce a maximum number of classes per file
-     * @see https://eslint.org/docs/latest/rules/max-classes-per-file
-     */
-    'max-classes-per-file'?: Linter.RuleEntry<MaxClassesPerFile>;
-    /**
-     * Enforce a maximum depth that blocks can be nested
-     * @see https://eslint.org/docs/latest/rules/max-depth
-     */
-    'max-depth'?: Linter.RuleEntry<MaxDepth>;
-    /**
-     * Enforce a maximum line length
-     * @see https://eslint.org/docs/latest/rules/max-len
-     * @deprecated
-     */
-    'max-len'?: Linter.RuleEntry<MaxLen>;
-    /**
-     * Enforce a maximum number of lines per file
-     * @see https://eslint.org/docs/latest/rules/max-lines
-     */
-    'max-lines'?: Linter.RuleEntry<MaxLines>;
-    /**
-     * Enforce a maximum number of lines of code in a function
-     * @see https://eslint.org/docs/latest/rules/max-lines-per-function
-     */
-    'max-lines-per-function'?: Linter.RuleEntry<MaxLinesPerFunction>;
-    /**
-     * Enforce a maximum depth that callbacks can be nested
-     * @see https://eslint.org/docs/latest/rules/max-nested-callbacks
-     */
-    'max-nested-callbacks'?: Linter.RuleEntry<MaxNestedCallbacks>;
-    /**
-     * Enforce a maximum number of parameters in function definitions
-     * @see https://eslint.org/docs/latest/rules/max-params
-     */
-    'max-params'?: Linter.RuleEntry<MaxParams>;
-    /**
-     * Enforce a maximum number of statements allowed in function blocks
-     * @see https://eslint.org/docs/latest/rules/max-statements
-     */
-    'max-statements'?: Linter.RuleEntry<MaxStatements>;
-    /**
-     * Enforce a maximum number of statements allowed per line
-     * @see https://eslint.org/docs/latest/rules/max-statements-per-line
-     * @deprecated
-     */
-    'max-statements-per-line'?: Linter.RuleEntry<MaxStatementsPerLine>;
-    /**
-     * Enforce a particular style for multiline comments
-     * @see https://eslint.org/docs/latest/rules/multiline-comment-style
-     * @deprecated
-     */
-    'multiline-comment-style'?: Linter.RuleEntry<MultilineCommentStyle>;
-    /**
-     * Enforce newlines between operands of ternary expressions
-     * @see https://eslint.org/docs/latest/rules/multiline-ternary
-     * @deprecated
-     */
-    'multiline-ternary'?: Linter.RuleEntry<MultilineTernary>;
-    /**
-     * Require constructor names to begin with a capital letter
-     * @see https://eslint.org/docs/latest/rules/new-cap
-     */
-    'new-cap'?: Linter.RuleEntry<NewCap>;
-    /**
-     * Enforce or disallow parentheses when invoking a constructor with no arguments
-     * @see https://eslint.org/docs/latest/rules/new-parens
-     * @deprecated
-     */
-    'new-parens'?: Linter.RuleEntry<NewParens>;
-    /**
-     * Require or disallow an empty line after variable declarations
-     * @see https://eslint.org/docs/latest/rules/newline-after-var
-     * @deprecated
-     */
-    'newline-after-var'?: Linter.RuleEntry<NewlineAfterVar>;
-    /**
-     * Require an empty line before `return` statements
-     * @see https://eslint.org/docs/latest/rules/newline-before-return
-     * @deprecated
-     */
-    'newline-before-return'?: Linter.RuleEntry<[]>;
-    /**
-     * Require a newline after each call in a method chain
-     * @see https://eslint.org/docs/latest/rules/newline-per-chained-call
-     * @deprecated
-     */
-    'newline-per-chained-call'?: Linter.RuleEntry<NewlinePerChainedCall>;
-    /**
-     * Disallow the use of `alert`, `confirm`, and `prompt`
-     * @see https://eslint.org/docs/latest/rules/no-alert
-     */
-    'no-alert'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `Array` constructors
-     * @see https://eslint.org/docs/latest/rules/no-array-constructor
-     */
-    'no-array-constructor'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow using an async function as a Promise executor
-     * @see https://eslint.org/docs/latest/rules/no-async-promise-executor
-     */
-    'no-async-promise-executor'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `await` inside of loops
-     * @see https://eslint.org/docs/latest/rules/no-await-in-loop
-     */
-    'no-await-in-loop'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow bitwise operators
-     * @see https://eslint.org/docs/latest/rules/no-bitwise
-     */
-    'no-bitwise'?: Linter.RuleEntry<NoBitwise>;
-    /**
-     * Disallow use of the `Buffer()` constructor
-     * @see https://eslint.org/docs/latest/rules/no-buffer-constructor
-     * @deprecated
-     */
-    'no-buffer-constructor'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow the use of `arguments.caller` or `arguments.callee`
-     * @see https://eslint.org/docs/latest/rules/no-caller
-     */
-    'no-caller'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow lexical declarations in case clauses
-     * @see https://eslint.org/docs/latest/rules/no-case-declarations
-     */
-    'no-case-declarations'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `catch` clause parameters from shadowing variables in the outer scope
-     * @see https://eslint.org/docs/latest/rules/no-catch-shadow
-     * @deprecated
-     */
-    'no-catch-shadow'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow reassigning class members
-     * @see https://eslint.org/docs/latest/rules/no-class-assign
-     */
-    'no-class-assign'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow comparing against -0
-     * @see https://eslint.org/docs/latest/rules/no-compare-neg-zero
-     */
-    'no-compare-neg-zero'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow assignment operators in conditional expressions
-     * @see https://eslint.org/docs/latest/rules/no-cond-assign
-     */
-    'no-cond-assign'?: Linter.RuleEntry<NoCondAssign>;
-    /**
-     * Disallow arrow functions where they could be confused with comparisons
-     * @see https://eslint.org/docs/latest/rules/no-confusing-arrow
-     * @deprecated
-     */
-    'no-confusing-arrow'?: Linter.RuleEntry<NoConfusingArrow>;
-    /**
-     * Disallow the use of `console`
-     * @see https://eslint.org/docs/latest/rules/no-console
-     */
-    'no-console'?: Linter.RuleEntry<NoConsole>;
-    /**
-     * Disallow reassigning `const` variables
-     * @see https://eslint.org/docs/latest/rules/no-const-assign
-     */
-    'no-const-assign'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow expressions where the operation doesn't affect the value
-     * @see https://eslint.org/docs/latest/rules/no-constant-binary-expression
-     */
-    'no-constant-binary-expression'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow constant expressions in conditions
-     * @see https://eslint.org/docs/latest/rules/no-constant-condition
-     */
-    'no-constant-condition'?: Linter.RuleEntry<NoConstantCondition>;
-    /**
-     * Disallow returning value from constructor
-     * @see https://eslint.org/docs/latest/rules/no-constructor-return
-     */
-    'no-constructor-return'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `continue` statements
-     * @see https://eslint.org/docs/latest/rules/no-continue
-     */
-    'no-continue'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow control characters in regular expressions
-     * @see https://eslint.org/docs/latest/rules/no-control-regex
-     */
-    'no-control-regex'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow the use of `debugger`
-     * @see https://eslint.org/docs/latest/rules/no-debugger
-     */
-    'no-debugger'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow deleting variables
-     * @see https://eslint.org/docs/latest/rules/no-delete-var
-     */
-    'no-delete-var'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow equal signs explicitly at the beginning of regular expressions
-     * @see https://eslint.org/docs/latest/rules/no-div-regex
-     */
-    'no-div-regex'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow duplicate arguments in `function` definitions
-     * @see https://eslint.org/docs/latest/rules/no-dupe-args
-     */
-    'no-dupe-args'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow duplicate class members
-     * @see https://eslint.org/docs/latest/rules/no-dupe-class-members
-     */
-    'no-dupe-class-members'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow duplicate conditions in if-else-if chains
-     * @see https://eslint.org/docs/latest/rules/no-dupe-else-if
-     */
-    'no-dupe-else-if'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow duplicate keys in object literals
-     * @see https://eslint.org/docs/latest/rules/no-dupe-keys
-     */
-    'no-dupe-keys'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow duplicate case labels
-     * @see https://eslint.org/docs/latest/rules/no-duplicate-case
-     */
-    'no-duplicate-case'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow duplicate module imports
-     * @see https://eslint.org/docs/latest/rules/no-duplicate-imports
-     */
-    'no-duplicate-imports'?: Linter.RuleEntry<NoDuplicateImports>;
-    /**
-     * Disallow `else` blocks after `return` statements in `if` statements
-     * @see https://eslint.org/docs/latest/rules/no-else-return
-     */
-    'no-else-return'?: Linter.RuleEntry<NoElseReturn>;
-    /**
-     * Disallow empty block statements
-     * @see https://eslint.org/docs/latest/rules/no-empty
-     */
-    'no-empty'?: Linter.RuleEntry<NoEmpty>;
-    /**
-     * Disallow empty character classes in regular expressions
-     * @see https://eslint.org/docs/latest/rules/no-empty-character-class
-     */
-    'no-empty-character-class'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow empty functions
-     * @see https://eslint.org/docs/latest/rules/no-empty-function
-     */
-    'no-empty-function'?: Linter.RuleEntry<NoEmptyFunction>;
-    /**
-     * Disallow empty destructuring patterns
-     * @see https://eslint.org/docs/latest/rules/no-empty-pattern
-     */
-    'no-empty-pattern'?: Linter.RuleEntry<NoEmptyPattern>;
-    /**
-     * Disallow empty static blocks
-     * @see https://eslint.org/docs/latest/rules/no-empty-static-block
-     */
-    'no-empty-static-block'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `null` comparisons without type-checking operators
-     * @see https://eslint.org/docs/latest/rules/no-eq-null
-     */
-    'no-eq-null'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow the use of `eval()`
-     * @see https://eslint.org/docs/latest/rules/no-eval
-     */
-    'no-eval'?: Linter.RuleEntry<NoEval>;
-    /**
-     * Disallow reassigning exceptions in `catch` clauses
-     * @see https://eslint.org/docs/latest/rules/no-ex-assign
-     */
-    'no-ex-assign'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow extending native types
-     * @see https://eslint.org/docs/latest/rules/no-extend-native
-     */
-    'no-extend-native'?: Linter.RuleEntry<NoExtendNative>;
-    /**
-     * Disallow unnecessary calls to `.bind()`
-     * @see https://eslint.org/docs/latest/rules/no-extra-bind
-     */
-    'no-extra-bind'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unnecessary boolean casts
-     * @see https://eslint.org/docs/latest/rules/no-extra-boolean-cast
-     */
-    'no-extra-boolean-cast'?: Linter.RuleEntry<NoExtraBooleanCast>;
-    /**
-     * Disallow unnecessary labels
-     * @see https://eslint.org/docs/latest/rules/no-extra-label
-     */
-    'no-extra-label'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unnecessary parentheses
-     * @see https://eslint.org/docs/latest/rules/no-extra-parens
-     * @deprecated
-     */
-    'no-extra-parens'?: Linter.RuleEntry<NoExtraParens>;
-    /**
-     * Disallow unnecessary semicolons
-     * @see https://eslint.org/docs/latest/rules/no-extra-semi
-     * @deprecated
-     */
-    'no-extra-semi'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow fallthrough of `case` statements
-     * @see https://eslint.org/docs/latest/rules/no-fallthrough
-     */
-    'no-fallthrough'?: Linter.RuleEntry<NoFallthrough>;
-    /**
-     * Disallow leading or trailing decimal points in numeric literals
-     * @see https://eslint.org/docs/latest/rules/no-floating-decimal
-     * @deprecated
-     */
-    'no-floating-decimal'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow reassigning `function` declarations
-     * @see https://eslint.org/docs/latest/rules/no-func-assign
-     */
-    'no-func-assign'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow assignments to native objects or read-only global variables
-     * @see https://eslint.org/docs/latest/rules/no-global-assign
-     */
-    'no-global-assign'?: Linter.RuleEntry<NoGlobalAssign>;
-    /**
-     * Disallow shorthand type conversions
-     * @see https://eslint.org/docs/latest/rules/no-implicit-coercion
-     */
-    'no-implicit-coercion'?: Linter.RuleEntry<NoImplicitCoercion>;
-    /**
-     * Disallow declarations in the global scope
-     * @see https://eslint.org/docs/latest/rules/no-implicit-globals
-     */
-    'no-implicit-globals'?: Linter.RuleEntry<NoImplicitGlobals>;
-    /**
-     * Disallow the use of `eval()`-like methods
-     * @see https://eslint.org/docs/latest/rules/no-implied-eval
-     */
-    'no-implied-eval'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow assigning to imported bindings
-     * @see https://eslint.org/docs/latest/rules/no-import-assign
-     */
-    'no-import-assign'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow inline comments after code
-     * @see https://eslint.org/docs/latest/rules/no-inline-comments
-     */
-    'no-inline-comments'?: Linter.RuleEntry<NoInlineComments>;
-    /**
-     * Disallow variable or `function` declarations in nested blocks
-     * @see https://eslint.org/docs/latest/rules/no-inner-declarations
-     */
-    'no-inner-declarations'?: Linter.RuleEntry<NoInnerDeclarations>;
-    /**
-     * Disallow invalid regular expression strings in `RegExp` constructors
-     * @see https://eslint.org/docs/latest/rules/no-invalid-regexp
-     */
-    'no-invalid-regexp'?: Linter.RuleEntry<NoInvalidRegexp>;
-    /**
-     * 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'?: Linter.RuleEntry<NoInvalidThis>;
-    /**
-     * Disallow irregular whitespace
-     * @see https://eslint.org/docs/latest/rules/no-irregular-whitespace
-     */
-    'no-irregular-whitespace'?: Linter.RuleEntry<NoIrregularWhitespace>;
-    /**
-     * Disallow the use of the `__iterator__` property
-     * @see https://eslint.org/docs/latest/rules/no-iterator
-     */
-    'no-iterator'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow labels that share a name with a variable
-     * @see https://eslint.org/docs/latest/rules/no-label-var
-     */
-    'no-label-var'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow labeled statements
-     * @see https://eslint.org/docs/latest/rules/no-labels
-     */
-    'no-labels'?: Linter.RuleEntry<NoLabels>;
-    /**
-     * Disallow unnecessary nested blocks
-     * @see https://eslint.org/docs/latest/rules/no-lone-blocks
-     */
-    'no-lone-blocks'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `if` statements as the only statement in `else` blocks
-     * @see https://eslint.org/docs/latest/rules/no-lonely-if
-     */
-    'no-lonely-if'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow function declarations that contain unsafe references inside loop statements
-     * @see https://eslint.org/docs/latest/rules/no-loop-func
-     */
-    'no-loop-func'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow literal numbers that lose precision
-     * @see https://eslint.org/docs/latest/rules/no-loss-of-precision
-     */
-    'no-loss-of-precision'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow magic numbers
-     * @see https://eslint.org/docs/latest/rules/no-magic-numbers
-     */
-    'no-magic-numbers'?: Linter.RuleEntry<NoMagicNumbers>;
-    /**
-     * 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'?: Linter.RuleEntry<NoMisleadingCharacterClass>;
-    /**
-     * Disallow mixed binary operators
-     * @see https://eslint.org/docs/latest/rules/no-mixed-operators
-     * @deprecated
-     */
-    'no-mixed-operators'?: Linter.RuleEntry<NoMixedOperators>;
-    /**
-     * Disallow `require` calls to be mixed with regular variable declarations
-     * @see https://eslint.org/docs/latest/rules/no-mixed-requires
-     * @deprecated
-     */
-    'no-mixed-requires'?: Linter.RuleEntry<NoMixedRequires>;
-    /**
-     * Disallow mixed spaces and tabs for indentation
-     * @see https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs
-     * @deprecated
-     */
-    'no-mixed-spaces-and-tabs'?: Linter.RuleEntry<NoMixedSpacesAndTabs>;
-    /**
-     * Disallow use of chained assignment expressions
-     * @see https://eslint.org/docs/latest/rules/no-multi-assign
-     */
-    'no-multi-assign'?: Linter.RuleEntry<NoMultiAssign>;
-    /**
-     * Disallow multiple spaces
-     * @see https://eslint.org/docs/latest/rules/no-multi-spaces
-     * @deprecated
-     */
-    'no-multi-spaces'?: Linter.RuleEntry<NoMultiSpaces>;
-    /**
-     * Disallow multiline strings
-     * @see https://eslint.org/docs/latest/rules/no-multi-str
-     */
-    'no-multi-str'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow multiple empty lines
-     * @see https://eslint.org/docs/latest/rules/no-multiple-empty-lines
-     * @deprecated
-     */
-    'no-multiple-empty-lines'?: Linter.RuleEntry<NoMultipleEmptyLines>;
-    /**
-     * Disallow assignments to native objects or read-only global variables
-     * @see https://eslint.org/docs/latest/rules/no-native-reassign
-     * @deprecated
-     */
-    'no-native-reassign'?: Linter.RuleEntry<NoNativeReassign>;
-    /**
-     * Disallow negated conditions
-     * @see https://eslint.org/docs/latest/rules/no-negated-condition
-     */
-    'no-negated-condition'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow negating the left operand in `in` expressions
-     * @see https://eslint.org/docs/latest/rules/no-negated-in-lhs
-     * @deprecated
-     */
-    'no-negated-in-lhs'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow nested ternary expressions
-     * @see https://eslint.org/docs/latest/rules/no-nested-ternary
-     */
-    'no-nested-ternary'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `new` operators outside of assignments or comparisons
-     * @see https://eslint.org/docs/latest/rules/no-new
-     */
-    'no-new'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `new` operators with the `Function` object
-     * @see https://eslint.org/docs/latest/rules/no-new-func
-     */
-    'no-new-func'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `new` operators with global non-constructor functions
-     * @see https://eslint.org/docs/latest/rules/no-new-native-nonconstructor
-     */
-    'no-new-native-nonconstructor'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `Object` constructors
-     * @see https://eslint.org/docs/latest/rules/no-new-object
-     * @deprecated
-     */
-    'no-new-object'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `new` operators with calls to `require`
-     * @see https://eslint.org/docs/latest/rules/no-new-require
-     * @deprecated
-     */
-    'no-new-require'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `new` operators with the `Symbol` object
-     * @see https://eslint.org/docs/latest/rules/no-new-symbol
-     * @deprecated
-     */
-    'no-new-symbol'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `new` operators with the `String`, `Number`, and `Boolean` objects
-     * @see https://eslint.org/docs/latest/rules/no-new-wrappers
-     */
-    'no-new-wrappers'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `\8` and `\9` escape sequences in string literals
-     * @see https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape
-     */
-    'no-nonoctal-decimal-escape'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow calling global object properties as functions
-     * @see https://eslint.org/docs/latest/rules/no-obj-calls
-     */
-    'no-obj-calls'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow calls to the `Object` constructor without an argument
-     * @see https://eslint.org/docs/latest/rules/no-object-constructor
-     */
-    'no-object-constructor'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow octal literals
-     * @see https://eslint.org/docs/latest/rules/no-octal
-     */
-    'no-octal'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow octal escape sequences in string literals
-     * @see https://eslint.org/docs/latest/rules/no-octal-escape
-     */
-    'no-octal-escape'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow reassigning `function` parameters
-     * @see https://eslint.org/docs/latest/rules/no-param-reassign
-     */
-    'no-param-reassign'?: Linter.RuleEntry<NoParamReassign>;
-    /**
-     * Disallow string concatenation with `__dirname` and `__filename`
-     * @see https://eslint.org/docs/latest/rules/no-path-concat
-     * @deprecated
-     */
-    'no-path-concat'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow the unary operators `++` and `--`
-     * @see https://eslint.org/docs/latest/rules/no-plusplus
-     */
-    'no-plusplus'?: Linter.RuleEntry<NoPlusplus>;
-    /**
-     * Disallow the use of `process.env`
-     * @see https://eslint.org/docs/latest/rules/no-process-env
-     * @deprecated
-     */
-    'no-process-env'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow the use of `process.exit()`
-     * @see https://eslint.org/docs/latest/rules/no-process-exit
-     * @deprecated
-     */
-    'no-process-exit'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow returning values from Promise executor functions
-     * @see https://eslint.org/docs/latest/rules/no-promise-executor-return
-     */
-    'no-promise-executor-return'?: Linter.RuleEntry<NoPromiseExecutorReturn>;
-    /**
-     * Disallow the use of the `__proto__` property
-     * @see https://eslint.org/docs/latest/rules/no-proto
-     */
-    'no-proto'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow calling some `Object.prototype` methods directly on objects
-     * @see https://eslint.org/docs/latest/rules/no-prototype-builtins
-     */
-    'no-prototype-builtins'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow variable redeclaration
-     * @see https://eslint.org/docs/latest/rules/no-redeclare
-     */
-    'no-redeclare'?: Linter.RuleEntry<NoRedeclare>;
-    /**
-     * Disallow multiple spaces in regular expressions
-     * @see https://eslint.org/docs/latest/rules/no-regex-spaces
-     */
-    'no-regex-spaces'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow specified names in exports
-     * @see https://eslint.org/docs/latest/rules/no-restricted-exports
-     */
-    'no-restricted-exports'?: Linter.RuleEntry<NoRestrictedExports>;
-    /**
-     * Disallow specified global variables
-     * @see https://eslint.org/docs/latest/rules/no-restricted-globals
-     */
-    'no-restricted-globals'?: Linter.RuleEntry<NoRestrictedGlobals>;
-    /**
-     * Disallow specified modules when loaded by `import`
-     * @see https://eslint.org/docs/latest/rules/no-restricted-imports
-     */
-    'no-restricted-imports'?: Linter.RuleEntry<NoRestrictedImports>;
-    /**
-     * Disallow specified modules when loaded by `require`
-     * @see https://eslint.org/docs/latest/rules/no-restricted-modules
-     * @deprecated
-     */
-    'no-restricted-modules'?: Linter.RuleEntry<NoRestrictedModules>;
-    /**
-     * Disallow certain properties on certain objects
-     * @see https://eslint.org/docs/latest/rules/no-restricted-properties
-     */
-    'no-restricted-properties'?: Linter.RuleEntry<NoRestrictedProperties>;
-    /**
-     * Disallow specified syntax
-     * @see https://eslint.org/docs/latest/rules/no-restricted-syntax
-     */
-    'no-restricted-syntax'?: Linter.RuleEntry<NoRestrictedSyntax>;
-    /**
-     * Disallow assignment operators in `return` statements
-     * @see https://eslint.org/docs/latest/rules/no-return-assign
-     */
-    'no-return-assign'?: Linter.RuleEntry<NoReturnAssign>;
-    /**
-     * Disallow unnecessary `return await`
-     * @see https://eslint.org/docs/latest/rules/no-return-await
-     * @deprecated
-     */
-    'no-return-await'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `javascript:` urls
-     * @see https://eslint.org/docs/latest/rules/no-script-url
-     */
-    'no-script-url'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow assignments where both sides are exactly the same
-     * @see https://eslint.org/docs/latest/rules/no-self-assign
-     */
-    'no-self-assign'?: Linter.RuleEntry<NoSelfAssign>;
-    /**
-     * Disallow comparisons where both sides are exactly the same
-     * @see https://eslint.org/docs/latest/rules/no-self-compare
-     */
-    'no-self-compare'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow comma operators
-     * @see https://eslint.org/docs/latest/rules/no-sequences
-     */
-    'no-sequences'?: Linter.RuleEntry<NoSequences>;
-    /**
-     * Disallow returning values from setters
-     * @see https://eslint.org/docs/latest/rules/no-setter-return
-     */
-    'no-setter-return'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow variable declarations from shadowing variables declared in the outer scope
-     * @see https://eslint.org/docs/latest/rules/no-shadow
-     */
-    'no-shadow'?: Linter.RuleEntry<NoShadow>;
-    /**
-     * Disallow identifiers from shadowing restricted names
-     * @see https://eslint.org/docs/latest/rules/no-shadow-restricted-names
-     */
-    'no-shadow-restricted-names'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow spacing between function identifiers and their applications (deprecated)
-     * @see https://eslint.org/docs/latest/rules/no-spaced-func
-     * @deprecated
-     */
-    'no-spaced-func'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow sparse arrays
-     * @see https://eslint.org/docs/latest/rules/no-sparse-arrays
-     */
-    'no-sparse-arrays'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow synchronous methods
-     * @see https://eslint.org/docs/latest/rules/no-sync
-     * @deprecated
-     */
-    'no-sync'?: Linter.RuleEntry<NoSync>;
-    /**
-     * Disallow all tabs
-     * @see https://eslint.org/docs/latest/rules/no-tabs
-     * @deprecated
-     */
-    'no-tabs'?: Linter.RuleEntry<NoTabs>;
-    /**
-     * 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'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow ternary operators
-     * @see https://eslint.org/docs/latest/rules/no-ternary
-     */
-    'no-ternary'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `this`/`super` before calling `super()` in constructors
-     * @see https://eslint.org/docs/latest/rules/no-this-before-super
-     */
-    'no-this-before-super'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow throwing literals as exceptions
-     * @see https://eslint.org/docs/latest/rules/no-throw-literal
-     */
-    'no-throw-literal'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow trailing whitespace at the end of lines
-     * @see https://eslint.org/docs/latest/rules/no-trailing-spaces
-     * @deprecated
-     */
-    'no-trailing-spaces'?: Linter.RuleEntry<NoTrailingSpaces>;
-    /**
-     * Disallow the use of undeclared variables unless mentioned in `/*global *\/` comments
-     * @see https://eslint.org/docs/latest/rules/no-undef
-     */
-    'no-undef'?: Linter.RuleEntry<NoUndef>;
-    /**
-     * Disallow initializing variables to `undefined`
-     * @see https://eslint.org/docs/latest/rules/no-undef-init
-     */
-    'no-undef-init'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow the use of `undefined` as an identifier
-     * @see https://eslint.org/docs/latest/rules/no-undefined
-     */
-    'no-undefined'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow dangling underscores in identifiers
-     * @see https://eslint.org/docs/latest/rules/no-underscore-dangle
-     */
-    'no-underscore-dangle'?: Linter.RuleEntry<NoUnderscoreDangle>;
-    /**
-     * Disallow confusing multiline expressions
-     * @see https://eslint.org/docs/latest/rules/no-unexpected-multiline
-     */
-    'no-unexpected-multiline'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unmodified loop conditions
-     * @see https://eslint.org/docs/latest/rules/no-unmodified-loop-condition
-     */
-    'no-unmodified-loop-condition'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow ternary operators when simpler alternatives exist
-     * @see https://eslint.org/docs/latest/rules/no-unneeded-ternary
-     */
-    'no-unneeded-ternary'?: Linter.RuleEntry<NoUnneededTernary>;
-    /**
-     * Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements
-     * @see https://eslint.org/docs/latest/rules/no-unreachable
-     */
-    'no-unreachable'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow loops with a body that allows only one iteration
-     * @see https://eslint.org/docs/latest/rules/no-unreachable-loop
-     */
-    'no-unreachable-loop'?: Linter.RuleEntry<NoUnreachableLoop>;
-    /**
-     * Disallow control flow statements in `finally` blocks
-     * @see https://eslint.org/docs/latest/rules/no-unsafe-finally
-     */
-    'no-unsafe-finally'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow negating the left operand of relational operators
-     * @see https://eslint.org/docs/latest/rules/no-unsafe-negation
-     */
-    'no-unsafe-negation'?: Linter.RuleEntry<NoUnsafeNegation>;
-    /**
-     * 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'?: Linter.RuleEntry<NoUnsafeOptionalChaining>;
-    /**
-     * Disallow unused expressions
-     * @see https://eslint.org/docs/latest/rules/no-unused-expressions
-     */
-    'no-unused-expressions'?: Linter.RuleEntry<NoUnusedExpressions>;
-    /**
-     * Disallow unused labels
-     * @see https://eslint.org/docs/latest/rules/no-unused-labels
-     */
-    'no-unused-labels'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unused private class members
-     * @see https://eslint.org/docs/latest/rules/no-unused-private-class-members
-     */
-    'no-unused-private-class-members'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unused variables
-     * @see https://eslint.org/docs/latest/rules/no-unused-vars
-     */
-    'no-unused-vars'?: Linter.RuleEntry<NoUnusedVars>;
-    /**
-     * Disallow the use of variables before they are defined
-     * @see https://eslint.org/docs/latest/rules/no-use-before-define
-     */
-    'no-use-before-define'?: Linter.RuleEntry<NoUseBeforeDefine>;
-    /**
-     * Disallow variable assignments when the value is not used
-     * @see https://eslint.org/docs/latest/rules/no-useless-assignment
-     */
-    'no-useless-assignment'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow useless backreferences in regular expressions
-     * @see https://eslint.org/docs/latest/rules/no-useless-backreference
-     */
-    'no-useless-backreference'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unnecessary calls to `.call()` and `.apply()`
-     * @see https://eslint.org/docs/latest/rules/no-useless-call
-     */
-    'no-useless-call'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unnecessary `catch` clauses
-     * @see https://eslint.org/docs/latest/rules/no-useless-catch
-     */
-    'no-useless-catch'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unnecessary computed property keys in objects and classes
-     * @see https://eslint.org/docs/latest/rules/no-useless-computed-key
-     */
-    'no-useless-computed-key'?: Linter.RuleEntry<NoUselessComputedKey>;
-    /**
-     * Disallow unnecessary concatenation of literals or template literals
-     * @see https://eslint.org/docs/latest/rules/no-useless-concat
-     */
-    'no-useless-concat'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unnecessary constructors
-     * @see https://eslint.org/docs/latest/rules/no-useless-constructor
-     */
-    'no-useless-constructor'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow unnecessary escape characters
-     * @see https://eslint.org/docs/latest/rules/no-useless-escape
-     */
-    'no-useless-escape'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow renaming import, export, and destructured assignments to the same name
-     * @see https://eslint.org/docs/latest/rules/no-useless-rename
-     */
-    'no-useless-rename'?: Linter.RuleEntry<NoUselessRename>;
-    /**
-     * Disallow redundant return statements
-     * @see https://eslint.org/docs/latest/rules/no-useless-return
-     */
-    'no-useless-return'?: Linter.RuleEntry<[]>;
-    /**
-     * Require `let` or `const` instead of `var`
-     * @see https://eslint.org/docs/latest/rules/no-var
-     */
-    'no-var'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `void` operators
-     * @see https://eslint.org/docs/latest/rules/no-void
-     */
-    'no-void'?: Linter.RuleEntry<NoVoid>;
-    /**
-     * Disallow specified warning terms in comments
-     * @see https://eslint.org/docs/latest/rules/no-warning-comments
-     */
-    'no-warning-comments'?: Linter.RuleEntry<NoWarningComments>;
-    /**
-     * Disallow whitespace before properties
-     * @see https://eslint.org/docs/latest/rules/no-whitespace-before-property
-     * @deprecated
-     */
-    'no-whitespace-before-property'?: Linter.RuleEntry<[]>;
-    /**
-     * Disallow `with` statements
-     * @see https://eslint.org/docs/latest/rules/no-with
-     */
-    'no-with'?: Linter.RuleEntry<[]>;
-    /**
-     * Enforce the location of single-line statements
-     * @see https://eslint.org/docs/latest/rules/nonblock-statement-body-position
-     * @deprecated
-     */
-    'nonblock-statement-body-position'?: Linter.RuleEntry<NonblockStatementBodyPosition>;
-    /**
-     * Enforce consistent line breaks after opening and before closing braces
-     * @see https://eslint.org/docs/latest/rules/object-curly-newline
-     * @deprecated
-     */
-    'object-curly-newline'?: Linter.RuleEntry<ObjectCurlyNewline>;
-    /**
-     * Enforce consistent spacing inside braces
-     * @see https://eslint.org/docs/latest/rules/object-curly-spacing
-     * @deprecated
-     */
-    'object-curly-spacing'?: Linter.RuleEntry<ObjectCurlySpacing>;
-    /**
-     * Enforce placing object properties on separate lines
-     * @see https://eslint.org/docs/latest/rules/object-property-newline
-     * @deprecated
-     */
-    'object-property-newline'?: Linter.RuleEntry<ObjectPropertyNewline>;
-    /**
-     * Require or disallow method and property shorthand syntax for object literals
-     * @see https://eslint.org/docs/latest/rules/object-shorthand
-     */
-    'object-shorthand'?: Linter.RuleEntry<ObjectShorthand>;
-    /**
-     * Enforce variables to be declared either together or separately in functions
-     * @see https://eslint.org/docs/latest/rules/one-var
-     */
-    'one-var'?: Linter.RuleEntry<OneVar>;
-    /**
-     * Require or disallow newlines around variable declarations
-     * @see https://eslint.org/docs/latest/rules/one-var-declaration-per-line
-     * @deprecated
-     */
-    'one-var-declaration-per-line'?: Linter.RuleEntry<OneVarDeclarationPerLine>;
-    /**
-     * Require or disallow assignment operator shorthand where possible
-     * @see https://eslint.org/docs/latest/rules/operator-assignment
-     */
-    'operator-assignment'?: Linter.RuleEntry<OperatorAssignment>;
-    /**
-     * Enforce consistent linebreak style for operators
-     * @see https://eslint.org/docs/latest/rules/operator-linebreak
-     * @deprecated
-     */
-    'operator-linebreak'?: Linter.RuleEntry<OperatorLinebreak>;
-    /**
-     * Require or disallow padding within blocks
-     * @see https://eslint.org/docs/latest/rules/padded-blocks
-     * @deprecated
-     */
-    'padded-blocks'?: Linter.RuleEntry<PaddedBlocks>;
-    /**
-     * Require or disallow padding lines between statements
-     * @see https://eslint.org/docs/latest/rules/padding-line-between-statements
-     * @deprecated
-     */
-    'padding-line-between-statements'?: Linter.RuleEntry<PaddingLineBetweenStatements>;
-    /**
-     * Require using arrow functions for callbacks
-     * @see https://eslint.org/docs/latest/rules/prefer-arrow-callback
-     */
-    'prefer-arrow-callback'?: Linter.RuleEntry<PreferArrowCallback>;
-    /**
-     * Require `const` declarations for variables that are never reassigned after declared
-     * @see https://eslint.org/docs/latest/rules/prefer-const
-     */
-    'prefer-const'?: Linter.RuleEntry<PreferConst>;
-    /**
-     * Require destructuring from arrays and/or objects
-     * @see https://eslint.org/docs/latest/rules/prefer-destructuring
-     */
-    'prefer-destructuring'?: Linter.RuleEntry<PreferDestructuring>;
-    /**
-     * Disallow the use of `Math.pow` in favor of the `**` operator
-     * @see https://eslint.org/docs/latest/rules/prefer-exponentiation-operator
-     */
-    'prefer-exponentiation-operator'?: Linter.RuleEntry<[]>;
-    /**
-     * Enforce using named capture group in regular expression
-     * @see https://eslint.org/docs/latest/rules/prefer-named-capture-group
-     */
-    'prefer-named-capture-group'?: Linter.RuleEntry<[]>;
-    /**
-     * 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'?: Linter.RuleEntry<[]>;
-    /**
-     * 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'?: Linter.RuleEntry<[]>;
-    /**
-     * 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'?: Linter.RuleEntry<[]>;
-    /**
-     * Require using Error objects as Promise rejection reasons
-     * @see https://eslint.org/docs/latest/rules/prefer-promise-reject-errors
-     */
-    'prefer-promise-reject-errors'?: Linter.RuleEntry<PreferPromiseRejectErrors>;
-    /**
-     * Require `Reflect` methods where applicable
-     * @see https://eslint.org/docs/latest/rules/prefer-reflect
-     * @deprecated
-     */
-    'prefer-reflect'?: Linter.RuleEntry<PreferReflect>;
-    /**
-     * 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'?: Linter.RuleEntry<PreferRegexLiterals>;
-    /**
-     * Require rest parameters instead of `arguments`
-     * @see https://eslint.org/docs/latest/rules/prefer-rest-params
-     */
-    'prefer-rest-params'?: Linter.RuleEntry<[]>;
-    /**
-     * Require spread operators instead of `.apply()`
-     * @see https://eslint.org/docs/latest/rules/prefer-spread
-     */
-    'prefer-spread'?: Linter.RuleEntry<[]>;
-    /**
-     * Require template literals instead of string concatenation
-     * @see https://eslint.org/docs/latest/rules/prefer-template
-     */
-    'prefer-template'?: Linter.RuleEntry<[]>;
-    /**
-     * Require quotes around object literal property names
-     * @see https://eslint.org/docs/latest/rules/quote-props
-     * @deprecated
-     */
-    'quote-props'?: Linter.RuleEntry<QuoteProps>;
-    /**
-     * Enforce the consistent use of either backticks, double, or single quotes
-     * @see https://eslint.org/docs/latest/rules/quotes
-     * @deprecated
-     */
-    'quotes'?: Linter.RuleEntry<Quotes>;
-    /**
-     * Enforce the consistent use of the radix argument when using `parseInt()`
-     * @see https://eslint.org/docs/latest/rules/radix
-     */
-    'radix'?: Linter.RuleEntry<Radix>;
-    /**
-     * 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'?: Linter.RuleEntry<RequireAtomicUpdates>;
-    /**
-     * Disallow async functions which have no `await` expression
-     * @see https://eslint.org/docs/latest/rules/require-await
-     */
-    'require-await'?: Linter.RuleEntry<[]>;
-    /**
-     * Enforce the use of `u` or `v` flag on RegExp
-     * @see https://eslint.org/docs/latest/rules/require-unicode-regexp
-     */
-    'require-unicode-regexp'?: Linter.RuleEntry<RequireUnicodeRegexp>;
-    /**
-     * Require generator functions to contain `yield`
-     * @see https://eslint.org/docs/latest/rules/require-yield
-     */
-    'require-yield'?: Linter.RuleEntry<[]>;
-    /**
-     * Enforce spacing between rest and spread operators and their expressions
-     * @see https://eslint.org/docs/latest/rules/rest-spread-spacing
-     * @deprecated
-     */
-    'rest-spread-spacing'?: Linter.RuleEntry<RestSpreadSpacing>;
-    /**
-     * Require or disallow semicolons instead of ASI
-     * @see https://eslint.org/docs/latest/rules/semi
-     * @deprecated
-     */
-    'semi'?: Linter.RuleEntry<Semi>;
-    /**
-     * Enforce consistent spacing before and after semicolons
-     * @see https://eslint.org/docs/latest/rules/semi-spacing
-     * @deprecated
-     */
-    'semi-spacing'?: Linter.RuleEntry<SemiSpacing>;
-    /**
-     * Enforce location of semicolons
-     * @see https://eslint.org/docs/latest/rules/semi-style
-     * @deprecated
-     */
-    'semi-style'?: Linter.RuleEntry<SemiStyle>;
-    /**
-     * Enforce sorted import declarations within modules
-     * @see https://eslint.org/docs/latest/rules/sort-imports
-     */
-    'sort-imports'?: Linter.RuleEntry<SortImports>;
-    /**
-     * Require object keys to be sorted
-     * @see https://eslint.org/docs/latest/rules/sort-keys
-     */
-    'sort-keys'?: Linter.RuleEntry<SortKeys>;
-    /**
-     * Require variables within the same declaration block to be sorted
-     * @see https://eslint.org/docs/latest/rules/sort-vars
-     */
-    'sort-vars'?: Linter.RuleEntry<SortVars>;
-    /**
-     * Enforce consistent spacing before blocks
-     * @see https://eslint.org/docs/latest/rules/space-before-blocks
-     * @deprecated
-     */
-    'space-before-blocks'?: Linter.RuleEntry<SpaceBeforeBlocks>;
-    /**
-     * Enforce consistent spacing before `function` definition opening parenthesis
-     * @see https://eslint.org/docs/latest/rules/space-before-function-paren
-     * @deprecated
-     */
-    'space-before-function-paren'?: Linter.RuleEntry<SpaceBeforeFunctionParen>;
-    /**
-     * Enforce consistent spacing inside parentheses
-     * @see https://eslint.org/docs/latest/rules/space-in-parens
-     * @deprecated
-     */
-    'space-in-parens'?: Linter.RuleEntry<SpaceInParens>;
-    /**
-     * Require spacing around infix operators
-     * @see https://eslint.org/docs/latest/rules/space-infix-ops
-     * @deprecated
-     */
-    'space-infix-ops'?: Linter.RuleEntry<SpaceInfixOps>;
-    /**
-     * Enforce consistent spacing before or after unary operators
-     * @see https://eslint.org/docs/latest/rules/space-unary-ops
-     * @deprecated
-     */
-    'space-unary-ops'?: Linter.RuleEntry<SpaceUnaryOps>;
-    /**
-     * Enforce consistent spacing after the `//` or `/*` in a comment
-     * @see https://eslint.org/docs/latest/rules/spaced-comment
-     * @deprecated
-     */
-    'spaced-comment'?: Linter.RuleEntry<SpacedComment>;
-    /**
-     * Require or disallow strict mode directives
-     * @see https://eslint.org/docs/latest/rules/strict
-     */
-    'strict'?: Linter.RuleEntry<Strict>;
-    /**
-     * Enforce spacing around colons of switch statements
-     * @see https://eslint.org/docs/latest/rules/switch-colon-spacing
-     * @deprecated
-     */
-    'switch-colon-spacing'?: Linter.RuleEntry<SwitchColonSpacing>;
-    /**
-     * Require symbol descriptions
-     * @see https://eslint.org/docs/latest/rules/symbol-description
-     */
-    'symbol-description'?: Linter.RuleEntry<[]>;
-    /**
-     * Require or disallow spacing around embedded expressions of template strings
-     * @see https://eslint.org/docs/latest/rules/template-curly-spacing
-     * @deprecated
-     */
-    'template-curly-spacing'?: Linter.RuleEntry<TemplateCurlySpacing>;
-    /**
-     * Require or disallow spacing between template tags and their literals
-     * @see https://eslint.org/docs/latest/rules/template-tag-spacing
-     * @deprecated
-     */
-    'template-tag-spacing'?: Linter.RuleEntry<TemplateTagSpacing>;
-    /**
-     * Require or disallow Unicode byte order mark (BOM)
-     * @see https://eslint.org/docs/latest/rules/unicode-bom
-     */
-    'unicode-bom'?: Linter.RuleEntry<UnicodeBom>;
-    /**
-     * Require calls to `isNaN()` when checking for `NaN`
-     * @see https://eslint.org/docs/latest/rules/use-isnan
-     */
-    'use-isnan'?: Linter.RuleEntry<UseIsnan>;
-    /**
-     * Enforce comparing `typeof` expressions against valid strings
-     * @see https://eslint.org/docs/latest/rules/valid-typeof
-     */
-    'valid-typeof'?: Linter.RuleEntry<ValidTypeof>;
-    /**
-     * 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'?: Linter.RuleEntry<[]>;
-    /**
-     * Require parentheses around immediate `function` invocations
-     * @see https://eslint.org/docs/latest/rules/wrap-iife
-     * @deprecated
-     */
-    'wrap-iife'?: Linter.RuleEntry<WrapIife>;
-    /**
-     * Require parenthesis around regex literals
-     * @see https://eslint.org/docs/latest/rules/wrap-regex
-     * @deprecated
-     */
-    'wrap-regex'?: Linter.RuleEntry<[]>;
-    /**
-     * Require or disallow spacing around the `*` in `yield*` expressions
-     * @see https://eslint.org/docs/latest/rules/yield-star-spacing
-     * @deprecated
-     */
-    'yield-star-spacing'?: Linter.RuleEntry<YieldStarSpacing>;
-    /**
-     * Require or disallow "Yoda" conditions
-     * @see https://eslint.org/docs/latest/rules/yoda
-     */
-    'yoda'?: Linter.RuleEntry<Yoda>;
-}
-type AccessorPairs = [] | [
-    {
-        getWithoutSet?: boolean;
-        setWithoutGet?: boolean;
-        enforceForClassMembers?: boolean;
-    }
-];
-type ArrayBracketNewline = [] | [
-    (("always" | "never" | "consistent") | {
-        multiline?: boolean;
-        minItems?: (number | null);
-    })
-];
-type ArrayBracketSpacing = [] | [("always" | "never")] | [
-    ("always" | "never"),
-    {
-        singleValue?: boolean;
-        objectsInArrays?: boolean;
-        arraysInArrays?: boolean;
-    }
-];
-type ArrayCallbackReturn = [] | [
-    {
-        allowImplicit?: boolean;
-        checkForEach?: boolean;
-        allowVoid?: boolean;
-    }
-];
-type ArrayElementNewline = [] | [
-    (_ArrayElementNewlineBasicConfig | {
-        ArrayExpression?: _ArrayElementNewlineBasicConfig;
-        ArrayPattern?: _ArrayElementNewlineBasicConfig;
-    })
-];
-type _ArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
-    multiline?: boolean;
-    minItems?: (number | null);
-});
-type ArrowBodyStyle = ([] | [("always" | "never")] | [] | ["as-needed"] | [
-    "as-needed",
-    {
-        requireReturnForObjectLiteral?: boolean;
-    }
-]);
-type ArrowParens = [] | [("always" | "as-needed")] | [
-    ("always" | "as-needed"),
-    {
-        requireForBlockBody?: boolean;
-    }
-];
-type ArrowSpacing = [] | [
-    {
-        before?: boolean;
-        after?: boolean;
-    }
-];
-type BlockSpacing = [] | [("always" | "never")];
-type BraceStyle = [] | [("1tbs" | "stroustrup" | "allman")] | [
-    ("1tbs" | "stroustrup" | "allman"),
-    {
-        allowSingleLine?: boolean;
-    }
-];
-type CallbackReturn = [] | [string[]];
-type Camelcase = [] | [
-    {
-        ignoreDestructuring?: boolean;
-        ignoreImports?: boolean;
-        ignoreGlobals?: boolean;
-        properties?: ("always" | "never");
-        allow?: string[];
-    }
-];
-type CapitalizedComments = [] | [("always" | "never")] | [
-    ("always" | "never"),
-    ({
-        ignorePattern?: string;
-        ignoreInlineComments?: boolean;
-        ignoreConsecutiveComments?: boolean;
-    } | {
-        line?: {
-            ignorePattern?: string;
-            ignoreInlineComments?: boolean;
-            ignoreConsecutiveComments?: boolean;
-        };
-        block?: {
-            ignorePattern?: string;
-            ignoreInlineComments?: boolean;
-            ignoreConsecutiveComments?: boolean;
-        };
-    })
-];
-type ClassMethodsUseThis = [] | [
-    {
-        exceptMethods?: string[];
-        enforceForClassFields?: boolean;
-    }
-];
-type CommaDangle = [] | [
-    (_CommaDangleValue | {
-        arrays?: _CommaDangleValueWithIgnore;
-        objects?: _CommaDangleValueWithIgnore;
-        imports?: _CommaDangleValueWithIgnore;
-        exports?: _CommaDangleValueWithIgnore;
-        functions?: _CommaDangleValueWithIgnore;
-    })
-];
-type _CommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline");
-type _CommaDangleValueWithIgnore = ("always-multiline" | "always" | "ignore" | "never" | "only-multiline");
-type CommaSpacing = [] | [
-    {
-        before?: boolean;
-        after?: boolean;
-    }
-];
-type CommaStyle = [] | [("first" | "last")] | [
-    ("first" | "last"),
-    {
-        exceptions?: {
-            [k: string]: boolean | undefined;
-        };
-    }
-];
-type Complexity = [] | [
-    (number | {
-        maximum?: number;
-        max?: number;
-    })
-];
-type ComputedPropertySpacing = [] | [("always" | "never")] | [
-    ("always" | "never"),
-    {
-        enforceForClassMembers?: boolean;
-    }
-];
-type ConsistentReturn = [] | [
-    {
-        treatUndefinedAsUnspecified?: boolean;
-    }
-];
-type ConsistentThis = string[];
-type Curly = ([] | ["all"] | [] | [("multi" | "multi-line" | "multi-or-nest")] | [("multi" | "multi-line" | "multi-or-nest"), "consistent"]);
-type DefaultCase = [] | [
-    {
-        commentPattern?: string;
-    }
-];
-type DotLocation = [] | [("object" | "property")];
-type DotNotation = [] | [
-    {
-        allowKeywords?: boolean;
-        allowPattern?: string;
-    }
-];
-type EolLast = [] | [("always" | "never" | "unix" | "windows")];
-type Eqeqeq = ([] | ["always"] | [
-    "always",
-    {
-        null?: ("always" | "never" | "ignore");
-    }
-] | [] | [("smart" | "allow-null")]);
-type FuncCallSpacing = ([] | ["never"] | [] | ["always"] | [
-    "always",
-    {
-        allowNewlines?: boolean;
-    }
-]);
-type FuncNameMatching = ([] | [("always" | "never")] | [
-    ("always" | "never"),
-    {
-        considerPropertyDescriptor?: boolean;
-        includeCommonJSModuleExports?: boolean;
-    }
-] | [] | [
-    {
-        considerPropertyDescriptor?: boolean;
-        includeCommonJSModuleExports?: boolean;
-    }
-]);
-type FuncNames = [] | [_FuncNamesValue] | [
-    _FuncNamesValue,
-    {
-        generators?: _FuncNamesValue;
-    }
-];
-type _FuncNamesValue = ("always" | "as-needed" | "never");
-type FuncStyle = [] | [("declaration" | "expression")] | [
-    ("declaration" | "expression"),
-    {
-        allowArrowFunctions?: boolean;
-        overrides?: {
-            namedExports?: ("declaration" | "expression" | "ignore");
-        };
-    }
-];
-type FunctionCallArgumentNewline = [] | [("always" | "never" | "consistent")];
-type FunctionParenNewline = [] | [
-    (("always" | "never" | "consistent" | "multiline" | "multiline-arguments") | {
-        minItems?: number;
-    })
-];
-type GeneratorStarSpacing = [] | [
-    (("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;
-        });
-    })
-];
-type GetterReturn = [] | [
-    {
-        allowImplicit?: boolean;
-    }
-];
-type GroupedAccessorPairs = [] | [("anyOrder" | "getBeforeSet" | "setBeforeGet")];
-type HandleCallbackErr = [] | [string];
-type IdBlacklist = string[];
-type IdDenylist = string[];
-type IdLength = [] | [
-    {
-        min?: number;
-        max?: number;
-        exceptions?: string[];
-        exceptionPatterns?: string[];
-        properties?: ("always" | "never");
-    }
-];
-type IdMatch = [] | [string] | [
-    string,
-    {
-        properties?: boolean;
-        classFields?: boolean;
-        onlyDeclarations?: boolean;
-        ignoreDestructuring?: boolean;
-    }
-];
-type ImplicitArrowLinebreak = [] | [("beside" | "below")];
-type Indent = [] | [("tab" | number)] | [
-    ("tab" | number),
-    {
-        SwitchCase?: number;
-        VariableDeclarator?: ((number | ("first" | "off")) | {
-            var?: (number | ("first" | "off"));
-            let?: (number | ("first" | "off"));
-            const?: (number | ("first" | "off"));
-        });
-        outerIIFEBody?: (number | "off");
-        MemberExpression?: (number | "off");
-        FunctionDeclaration?: {
-            parameters?: (number | ("first" | "off"));
-            body?: number;
-        };
-        FunctionExpression?: {
-            parameters?: (number | ("first" | "off"));
-            body?: number;
-        };
-        StaticBlock?: {
-            body?: number;
-        };
-        CallExpression?: {
-            arguments?: (number | ("first" | "off"));
-        };
-        ArrayExpression?: (number | ("first" | "off"));
-        ObjectExpression?: (number | ("first" | "off"));
-        ImportDeclaration?: (number | ("first" | "off"));
-        flatTernaryExpressions?: boolean;
-        offsetTernaryExpressions?: boolean;
-        ignoredNodes?: string[];
-        ignoreComments?: boolean;
-    }
-];
-type IndentLegacy = [] | [("tab" | number)] | [
-    ("tab" | number),
-    {
-        SwitchCase?: number;
-        VariableDeclarator?: (number | {
-            var?: number;
-            let?: number;
-            const?: number;
-            [k: string]: unknown | undefined;
-        });
-        outerIIFEBody?: number;
-        MemberExpression?: number;
-        FunctionDeclaration?: {
-            parameters?: (number | "first");
-            body?: number;
-            [k: string]: unknown | undefined;
-        };
-        FunctionExpression?: {
-            parameters?: (number | "first");
-            body?: number;
-            [k: string]: unknown | undefined;
-        };
-        CallExpression?: {
-            parameters?: (number | "first");
-            [k: string]: unknown | undefined;
-        };
-        ArrayExpression?: (number | "first");
-        ObjectExpression?: (number | "first");
-    }
-];
-type InitDeclarations = ([] | ["always"] | [] | ["never"] | [
-    "never",
-    {
-        ignoreForLoopInit?: boolean;
-    }
-]);
-type JsxQuotes = [] | [("prefer-single" | "prefer-double")];
-type KeySpacing = [] | [
-    ({
-        align?: (("colon" | "value") | {
-            mode?: ("strict" | "minimum");
-            on?: ("colon" | "value");
-            beforeColon?: boolean;
-            afterColon?: boolean;
-        });
-        mode?: ("strict" | "minimum");
-        beforeColon?: boolean;
-        afterColon?: boolean;
-    } | {
-        singleLine?: {
-            mode?: ("strict" | "minimum");
-            beforeColon?: boolean;
-            afterColon?: boolean;
-        };
-        multiLine?: {
-            align?: (("colon" | "value") | {
-                mode?: ("strict" | "minimum");
-                on?: ("colon" | "value");
-                beforeColon?: boolean;
-                afterColon?: boolean;
-            });
-            mode?: ("strict" | "minimum");
-            beforeColon?: boolean;
-            afterColon?: boolean;
-        };
-    } | {
-        singleLine?: {
-            mode?: ("strict" | "minimum");
-            beforeColon?: boolean;
-            afterColon?: boolean;
-        };
-        multiLine?: {
-            mode?: ("strict" | "minimum");
-            beforeColon?: boolean;
-            afterColon?: boolean;
-        };
-        align?: {
-            mode?: ("strict" | "minimum");
-            on?: ("colon" | "value");
-            beforeColon?: boolean;
-            afterColon?: boolean;
-        };
-    })
-];
-type KeywordSpacing = [] | [
-    {
-        before?: boolean;
-        after?: boolean;
-        overrides?: {
-            abstract?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            as?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            async?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            await?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            boolean?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            break?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            byte?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            case?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            catch?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            char?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            class?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            const?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            continue?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            debugger?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            default?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            delete?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            do?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            double?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            else?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            enum?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            export?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            extends?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            false?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            final?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            finally?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            float?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            for?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            from?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            function?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            get?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            goto?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            if?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            implements?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            import?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            in?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            instanceof?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            int?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            interface?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            let?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            long?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            native?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            new?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            null?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            of?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            package?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            private?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            protected?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            public?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            return?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            set?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            short?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            static?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            super?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            switch?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            synchronized?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            this?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            throw?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            throws?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            transient?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            true?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            try?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            typeof?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            var?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            void?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            volatile?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            while?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            with?: {
-                before?: boolean;
-                after?: boolean;
-            };
-            yield?: {
-                before?: boolean;
-                after?: boolean;
-            };
-        };
-    }
-];
-type LineCommentPosition = [] | [
-    (("above" | "beside") | {
-        position?: ("above" | "beside");
-        ignorePattern?: string;
-        applyDefaultPatterns?: boolean;
-        applyDefaultIgnorePatterns?: boolean;
-    })
-];
-type LinebreakStyle = [] | [("unix" | "windows")];
-type LinesAroundComment = [] | [
-    {
-        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;
-    }
-];
-type LinesAroundDirective = [] | [
-    (("always" | "never") | {
-        before?: ("always" | "never");
-        after?: ("always" | "never");
-    })
-];
-type LinesBetweenClassMembers = [] | [
-    ({
-        enforce: [
-            {
-                blankLine: ("always" | "never");
-                prev: ("method" | "field" | "*");
-                next: ("method" | "field" | "*");
-            },
-            ...({
-                blankLine: ("always" | "never");
-                prev: ("method" | "field" | "*");
-                next: ("method" | "field" | "*");
-            })[]
-        ];
-    } | ("always" | "never"))
-] | [
-    ({
-        enforce: [
-            {
-                blankLine: ("always" | "never");
-                prev: ("method" | "field" | "*");
-                next: ("method" | "field" | "*");
-            },
-            ...({
-                blankLine: ("always" | "never");
-                prev: ("method" | "field" | "*");
-                next: ("method" | "field" | "*");
-            })[]
-        ];
-    } | ("always" | "never")),
-    {
-        exceptAfterSingleLine?: boolean;
-    }
-];
-type LogicalAssignmentOperators = (([] | ["always"] | [
-    "always",
-    {
-        enforceForIfStatements?: boolean;
-    }
-] | ["never"]) & unknown[]);
-type MaxClassesPerFile = [] | [
-    (number | {
-        ignoreExpressions?: boolean;
-        max?: number;
-    })
-];
-type MaxDepth = [] | [
-    (number | {
-        maximum?: number;
-        max?: number;
-    })
-];
-type MaxLen = [] | [
-    ({
-        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;
-    } | 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;
-    } | number),
-    {
-        code?: number;
-        comments?: number;
-        tabWidth?: number;
-        ignorePattern?: string;
-        ignoreComments?: boolean;
-        ignoreStrings?: boolean;
-        ignoreUrls?: boolean;
-        ignoreTemplateLiterals?: boolean;
-        ignoreRegExpLiterals?: boolean;
-        ignoreTrailingComments?: boolean;
-    }
-];
-type MaxLines = [] | [
-    (number | {
-        max?: number;
-        skipComments?: boolean;
-        skipBlankLines?: boolean;
-    })
-];
-type MaxLinesPerFunction = [] | [
-    ({
-        max?: number;
-        skipComments?: boolean;
-        skipBlankLines?: boolean;
-        IIFEs?: boolean;
-    } | number)
-];
-type MaxNestedCallbacks = [] | [
-    (number | {
-        maximum?: number;
-        max?: number;
-    })
-];
-type MaxParams = [] | [
-    (number | {
-        maximum?: number;
-        max?: number;
-    })
-];
-type MaxStatements = [] | [
-    (number | {
-        maximum?: number;
-        max?: number;
-    })
-] | [
-    (number | {
-        maximum?: number;
-        max?: number;
-    }),
-    {
-        ignoreTopLevelFunctions?: boolean;
-    }
-];
-type MaxStatementsPerLine = [] | [
-    {
-        max?: number;
-    }
-];
-type MultilineCommentStyle = ([] | [("starred-block" | "bare-block")] | [] | ["separate-lines"] | [
-    "separate-lines",
-    {
-        checkJSDoc?: boolean;
-    }
-]);
-type MultilineTernary = [] | [("always" | "always-multiline" | "never")];
-type NewCap = [] | [
-    {
-        newIsCap?: boolean;
-        capIsNew?: boolean;
-        newIsCapExceptions?: string[];
-        newIsCapExceptionPattern?: string;
-        capIsNewExceptions?: string[];
-        capIsNewExceptionPattern?: string;
-        properties?: boolean;
-    }
-];
-type NewParens = [] | [("always" | "never")];
-type NewlineAfterVar = [] | [("never" | "always")];
-type NewlinePerChainedCall = [] | [
-    {
-        ignoreChainWithDepth?: number;
-    }
-];
-type NoBitwise = [] | [
-    {
-        allow?: ("^" | "|" | "&" | "<<" | ">>" | ">>>" | "^=" | "|=" | "&=" | "<<=" | ">>=" | ">>>=" | "~")[];
-        int32Hint?: boolean;
-    }
-];
-type NoCondAssign = [] | [("except-parens" | "always")];
-type NoConfusingArrow = [] | [
-    {
-        allowParens?: boolean;
-        onlyOneSimpleParam?: boolean;
-    }
-];
-type NoConsole = [] | [
-    {
-        allow?: [string, ...(string)[]];
-    }
-];
-type NoConstantCondition = [] | [
-    {
-        checkLoops?: ("all" | "allExceptWhileTrue" | "none" | true | false);
-    }
-];
-type NoDuplicateImports = [] | [
-    {
-        includeExports?: boolean;
-    }
-];
-type NoElseReturn = [] | [
-    {
-        allowElseIf?: boolean;
-    }
-];
-type NoEmpty = [] | [
-    {
-        allowEmptyCatch?: boolean;
-    }
-];
-type NoEmptyFunction = [] | [
-    {
-        allow?: ("functions" | "arrowFunctions" | "generatorFunctions" | "methods" | "generatorMethods" | "getters" | "setters" | "constructors" | "asyncFunctions" | "asyncMethods")[];
-    }
-];
-type NoEmptyPattern = [] | [
-    {
-        allowObjectPatternsAsParameters?: boolean;
-    }
-];
-type NoEval = [] | [
-    {
-        allowIndirect?: boolean;
-    }
-];
-type NoExtendNative = [] | [
-    {
-        exceptions?: string[];
-    }
-];
-type NoExtraBooleanCast = [] | [
-    ({
-        enforceForInnerExpressions?: boolean;
-    } | {
-        enforceForLogicalOperands?: boolean;
-    })
-];
-type NoExtraParens = ([] | ["functions"] | [] | ["all"] | [
-    "all",
-    {
-        conditionalAssign?: boolean;
-        ternaryOperandBinaryExpressions?: boolean;
-        nestedBinaryExpressions?: boolean;
-        returnAssign?: boolean;
-        ignoreJSX?: ("none" | "all" | "single-line" | "multi-line");
-        enforceForArrowConditionals?: boolean;
-        enforceForSequenceExpressions?: boolean;
-        enforceForNewInMemberExpressions?: boolean;
-        enforceForFunctionPrototypeMethods?: boolean;
-        allowParensAfterCommentPattern?: string;
-    }
-]);
-type NoFallthrough = [] | [
-    {
-        commentPattern?: string;
-        allowEmptyCase?: boolean;
-        reportUnusedFallthroughComment?: boolean;
-    }
-];
-type NoGlobalAssign = [] | [
-    {
-        exceptions?: string[];
-    }
-];
-type NoImplicitCoercion = [] | [
-    {
-        boolean?: boolean;
-        number?: boolean;
-        string?: boolean;
-        disallowTemplateShorthand?: boolean;
-        allow?: ("~" | "!!" | "+" | "- -" | "-" | "*")[];
-    }
-];
-type NoImplicitGlobals = [] | [
-    {
-        lexicalBindings?: boolean;
-    }
-];
-type NoInlineComments = [] | [
-    {
-        ignorePattern?: string;
-    }
-];
-type NoInnerDeclarations = [] | [("functions" | "both")] | [
-    ("functions" | "both"),
-    {
-        blockScopedFunctions?: ("allow" | "disallow");
-    }
-];
-type NoInvalidRegexp = [] | [
-    {
-        allowConstructorFlags?: string[];
-    }
-];
-type NoInvalidThis = [] | [
-    {
-        capIsConstructor?: boolean;
-    }
-];
-type NoIrregularWhitespace = [] | [
-    {
-        skipComments?: boolean;
-        skipStrings?: boolean;
-        skipTemplates?: boolean;
-        skipRegExps?: boolean;
-        skipJSXText?: boolean;
-    }
-];
-type NoLabels = [] | [
-    {
-        allowLoop?: boolean;
-        allowSwitch?: boolean;
-    }
-];
-type NoMagicNumbers = [] | [
-    {
-        detectObjects?: boolean;
-        enforceConst?: boolean;
-        ignore?: (number | string)[];
-        ignoreArrayIndexes?: boolean;
-        ignoreDefaultValues?: boolean;
-        ignoreClassFieldInitialValues?: boolean;
-    }
-];
-type NoMisleadingCharacterClass = [] | [
-    {
-        allowEscape?: boolean;
-    }
-];
-type NoMixedOperators = [] | [
-    {
-        groups?: [("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ...(("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"))[]][];
-        allowSamePrecedence?: boolean;
-    }
-];
-type NoMixedRequires = [] | [
-    (boolean | {
-        grouping?: boolean;
-        allowCall?: boolean;
-    })
-];
-type NoMixedSpacesAndTabs = [] | [("smart-tabs" | true | false)];
-type NoMultiAssign = [] | [
-    {
-        ignoreNonDeclaration?: boolean;
-    }
-];
-type NoMultiSpaces = [] | [
-    {
-        exceptions?: {
-            [k: string]: boolean;
-        };
-        ignoreEOLComments?: boolean;
-    }
-];
-type NoMultipleEmptyLines = [] | [
-    {
-        max: number;
-        maxEOF?: number;
-        maxBOF?: number;
-    }
-];
-type NoNativeReassign = [] | [
-    {
-        exceptions?: string[];
-    }
-];
-type NoParamReassign = [] | [
-    ({
-        props?: false;
-    } | {
-        props?: true;
-        ignorePropertyModificationsFor?: string[];
-        ignorePropertyModificationsForRegex?: string[];
-    })
-];
-type NoPlusplus = [] | [
-    {
-        allowForLoopAfterthoughts?: boolean;
-    }
-];
-type NoPromiseExecutorReturn = [] | [
-    {
-        allowVoid?: boolean;
-    }
-];
-type NoRedeclare = [] | [
-    {
-        builtinGlobals?: boolean;
-    }
-];
-type NoRestrictedExports = [] | [
-    ({
-        restrictedNamedExports?: string[];
-        restrictedNamedExportsPattern?: string;
-    } | {
-        restrictedNamedExports?: string[];
-        restrictedNamedExportsPattern?: string;
-        restrictDefaultExports?: {
-            direct?: boolean;
-            named?: boolean;
-            defaultFrom?: boolean;
-            namedFrom?: boolean;
-            namespaceFrom?: boolean;
-        };
-    })
-];
-type NoRestrictedGlobals = (string | {
-    name: string;
-    message?: string;
-})[];
-type NoRestrictedImports = ((string | {
-    name: string;
-    message?: string;
-    importNames?: string[];
-    allowImportNames?: string[];
-})[] | [] | [
-    {
-        paths?: (string | {
-            name: string;
-            message?: string;
-            importNames?: string[];
-            allowImportNames?: string[];
-        })[];
-        patterns?: (string[] | ({
-            [k: string]: unknown | undefined;
-        } | {
-            [k: string]: unknown | undefined;
-        })[]);
-    }
-]);
-type NoRestrictedModules = ((string | {
-    name: string;
-    message?: string;
-})[] | {
-    paths?: (string | {
-        name: string;
-        message?: string;
-    })[];
-    patterns?: string[];
-}[]);
-type NoRestrictedProperties = ({
-    object: string;
-    property?: string;
-    message?: string;
-} | {
-    object?: string;
-    property: string;
-    message?: string;
-})[];
-type NoRestrictedSyntax = (string | {
-    selector: string;
-    message?: string;
-})[];
-type NoReturnAssign = [] | [("except-parens" | "always")];
-type NoSelfAssign = [] | [
-    {
-        props?: boolean;
-    }
-];
-type NoSequences = [] | [
-    {
-        allowInParentheses?: boolean;
-    }
-];
-type NoShadow = [] | [
-    {
-        builtinGlobals?: boolean;
-        hoist?: ("all" | "functions" | "never");
-        allow?: string[];
-        ignoreOnInitialization?: boolean;
-    }
-];
-type NoSync = [] | [
-    {
-        allowAtRootLevel?: boolean;
-    }
-];
-type NoTabs = [] | [
-    {
-        allowIndentationTabs?: boolean;
-    }
-];
-type NoTrailingSpaces = [] | [
-    {
-        skipBlankLines?: boolean;
-        ignoreComments?: boolean;
-    }
-];
-type NoUndef = [] | [
-    {
-        typeof?: boolean;
-    }
-];
-type NoUnderscoreDangle = [] | [
-    {
-        allow?: string[];
-        allowAfterThis?: boolean;
-        allowAfterSuper?: boolean;
-        allowAfterThisConstructor?: boolean;
-        enforceInMethodNames?: boolean;
-        allowFunctionParams?: boolean;
-        enforceInClassFields?: boolean;
-        allowInArrayDestructuring?: boolean;
-        allowInObjectDestructuring?: boolean;
-    }
-];
-type NoUnneededTernary = [] | [
-    {
-        defaultAssignment?: boolean;
-    }
-];
-type NoUnreachableLoop = [] | [
-    {
-        ignore?: ("WhileStatement" | "DoWhileStatement" | "ForStatement" | "ForInStatement" | "ForOfStatement")[];
-    }
-];
-type NoUnsafeNegation = [] | [
-    {
-        enforceForOrderingRelations?: boolean;
-    }
-];
-type NoUnsafeOptionalChaining = [] | [
-    {
-        disallowArithmeticOperators?: boolean;
-    }
-];
-type NoUnusedExpressions = [] | [
-    {
-        allowShortCircuit?: boolean;
-        allowTernary?: boolean;
-        allowTaggedTemplates?: boolean;
-        enforceForJSX?: boolean;
-    }
-];
-type NoUnusedVars = [] | [
-    (("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;
-    })
-];
-type NoUseBeforeDefine = [] | [
-    ("nofunc" | {
-        functions?: boolean;
-        classes?: boolean;
-        variables?: boolean;
-        allowNamedExports?: boolean;
-    })
-];
-type NoUselessComputedKey = [] | [
-    {
-        enforceForClassMembers?: boolean;
-    }
-];
-type NoUselessRename = [] | [
-    {
-        ignoreDestructuring?: boolean;
-        ignoreImport?: boolean;
-        ignoreExport?: boolean;
-    }
-];
-type NoVoid = [] | [
-    {
-        allowAsStatement?: boolean;
-    }
-];
-type NoWarningComments = [] | [
-    {
-        terms?: string[];
-        location?: ("start" | "anywhere");
-        decoration?: [string, ...(string)[]];
-    }
-];
-type NonblockStatementBodyPosition = [] | [("beside" | "below" | "any")] | [
-    ("beside" | "below" | "any"),
-    {
-        overrides?: {
-            if?: ("beside" | "below" | "any");
-            else?: ("beside" | "below" | "any");
-            while?: ("beside" | "below" | "any");
-            do?: ("beside" | "below" | "any");
-            for?: ("beside" | "below" | "any");
-        };
-    }
-];
-type ObjectCurlyNewline = [] | [
-    ((("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;
-        });
-    })
-];
-type ObjectCurlySpacing = [] | [("always" | "never")] | [
-    ("always" | "never"),
-    {
-        arraysInObjects?: boolean;
-        objectsInObjects?: boolean;
-    }
-];
-type ObjectPropertyNewline = [] | [
-    {
-        allowAllPropertiesOnSameLine?: boolean;
-        allowMultiplePropertiesPerLine?: boolean;
-    }
-];
-type ObjectShorthand = ([] | [("always" | "methods" | "properties" | "never" | "consistent" | "consistent-as-needed")] | [] | [("always" | "methods" | "properties")] | [
-    ("always" | "methods" | "properties"),
-    {
-        avoidQuotes?: boolean;
-    }
-] | [] | [("always" | "methods")] | [
-    ("always" | "methods"),
-    {
-        ignoreConstructors?: boolean;
-        methodsIgnorePattern?: string;
-        avoidQuotes?: boolean;
-        avoidExplicitReturnArrows?: boolean;
-    }
-]);
-type OneVar = [] | [
-    (("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");
-    })
-];
-type OneVarDeclarationPerLine = [] | [("always" | "initializations")];
-type OperatorAssignment = [] | [("always" | "never")];
-type OperatorLinebreak = [] | [("after" | "before" | "none" | null)] | [
-    ("after" | "before" | "none" | null),
-    {
-        overrides?: {
-            [k: string]: ("after" | "before" | "none" | "ignore") | undefined;
-        };
-    }
-];
-type PaddedBlocks = [] | [
-    (("always" | "never") | {
-        blocks?: ("always" | "never");
-        switches?: ("always" | "never");
-        classes?: ("always" | "never");
-    })
-] | [
-    (("always" | "never") | {
-        blocks?: ("always" | "never");
-        switches?: ("always" | "never");
-        classes?: ("always" | "never");
-    }),
-    {
-        allowSingleLineBlocks?: boolean;
-    }
-];
-type _PaddingLineBetweenStatementsPaddingType = ("any" | "never" | "always");
-type _PaddingLineBetweenStatementsStatementType = (("*" | "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"), ...(("*" | "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"))[]]);
-type PaddingLineBetweenStatements = {
-    blankLine: _PaddingLineBetweenStatementsPaddingType;
-    prev: _PaddingLineBetweenStatementsStatementType;
-    next: _PaddingLineBetweenStatementsStatementType;
-}[];
-type PreferArrowCallback = [] | [
-    {
-        allowNamedFunctions?: boolean;
-        allowUnboundThis?: boolean;
-    }
-];
-type PreferConst = [] | [
-    {
-        destructuring?: ("any" | "all");
-        ignoreReadBeforeAssign?: boolean;
-    }
-];
-type PreferDestructuring = [] | [
-    ({
-        VariableDeclarator?: {
-            array?: boolean;
-            object?: boolean;
-        };
-        AssignmentExpression?: {
-            array?: boolean;
-            object?: boolean;
-        };
-    } | {
-        array?: boolean;
-        object?: boolean;
-    })
-] | [
-    ({
-        VariableDeclarator?: {
-            array?: boolean;
-            object?: boolean;
-        };
-        AssignmentExpression?: {
-            array?: boolean;
-            object?: boolean;
-        };
-    } | {
-        array?: boolean;
-        object?: boolean;
-    }),
-    {
-        enforceForRenamedProperties?: boolean;
-    }
-];
-type PreferPromiseRejectErrors = [] | [
-    {
-        allowEmptyReject?: boolean;
-    }
-];
-type PreferReflect = [] | [
-    {
-        exceptions?: ("apply" | "call" | "delete" | "defineProperty" | "getOwnPropertyDescriptor" | "getPrototypeOf" | "setPrototypeOf" | "isExtensible" | "getOwnPropertyNames" | "preventExtensions")[];
-    }
-];
-type PreferRegexLiterals = [] | [
-    {
-        disallowRedundantWrapping?: boolean;
-    }
-];
-type QuoteProps = ([] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [
-    ("always" | "as-needed" | "consistent" | "consistent-as-needed"),
-    {
-        keywords?: boolean;
-        unnecessary?: boolean;
-        numbers?: boolean;
-    }
-]);
-type Quotes = [] | [("single" | "double" | "backtick")] | [
-    ("single" | "double" | "backtick"),
-    ("avoid-escape" | {
-        avoidEscape?: boolean;
-        allowTemplateLiterals?: boolean;
-    })
-];
-type Radix = [] | [("always" | "as-needed")];
-type RequireAtomicUpdates = [] | [
-    {
-        allowProperties?: boolean;
-    }
-];
-type RequireUnicodeRegexp = [] | [
-    {
-        requireFlag?: ("u" | "v");
-    }
-];
-type RestSpreadSpacing = [] | [("always" | "never")];
-type Semi = ([] | ["never"] | [
-    "never",
-    {
-        beforeStatementContinuationChars?: ("always" | "any" | "never");
-    }
-] | [] | ["always"] | [
-    "always",
-    {
-        omitLastInOneLineBlock?: boolean;
-        omitLastInOneLineClassBody?: boolean;
-    }
-]);
-type SemiSpacing = [] | [
-    {
-        before?: boolean;
-        after?: boolean;
-    }
-];
-type SemiStyle = [] | [("last" | "first")];
-type SortImports = [] | [
-    {
-        ignoreCase?: boolean;
-        memberSyntaxSortOrder?: [("none" | "all" | "multiple" | "single"), ("none" | "all" | "multiple" | "single"), ("none" | "all" | "multiple" | "single"), ("none" | "all" | "multiple" | "single")];
-        ignoreDeclarationSort?: boolean;
-        ignoreMemberSort?: boolean;
-        allowSeparatedGroups?: boolean;
-    }
-];
-type SortKeys = [] | [("asc" | "desc")] | [
-    ("asc" | "desc"),
-    {
-        caseSensitive?: boolean;
-        natural?: boolean;
-        minKeys?: number;
-        allowLineSeparatedGroups?: boolean;
-    }
-];
-type SortVars = [] | [
-    {
-        ignoreCase?: boolean;
-    }
-];
-type SpaceBeforeBlocks = [] | [
-    (("always" | "never") | {
-        keywords?: ("always" | "never" | "off");
-        functions?: ("always" | "never" | "off");
-        classes?: ("always" | "never" | "off");
-    })
-];
-type SpaceBeforeFunctionParen = [] | [
-    (("always" | "never") | {
-        anonymous?: ("always" | "never" | "ignore");
-        named?: ("always" | "never" | "ignore");
-        asyncArrow?: ("always" | "never" | "ignore");
-    })
-];
-type SpaceInParens = [] | [("always" | "never")] | [
-    ("always" | "never"),
-    {
-        exceptions?: ("{}" | "[]" | "()" | "empty")[];
-    }
-];
-type SpaceInfixOps = [] | [
-    {
-        int32Hint?: boolean;
-    }
-];
-type SpaceUnaryOps = [] | [
-    {
-        words?: boolean;
-        nonwords?: boolean;
-        overrides?: {
-            [k: string]: boolean | undefined;
-        };
-    }
-];
-type SpacedComment = [] | [("always" | "never")] | [
-    ("always" | "never"),
-    {
-        exceptions?: string[];
-        markers?: string[];
-        line?: {
-            exceptions?: string[];
-            markers?: string[];
-        };
-        block?: {
-            exceptions?: string[];
-            markers?: string[];
-            balanced?: boolean;
-        };
-    }
-];
-type Strict = [] | [("never" | "global" | "function" | "safe")];
-type SwitchColonSpacing = [] | [
-    {
-        before?: boolean;
-        after?: boolean;
-    }
-];
-type TemplateCurlySpacing = [] | [("always" | "never")];
-type TemplateTagSpacing = [] | [("always" | "never")];
-type UnicodeBom = [] | [("always" | "never")];
-type UseIsnan = [] | [
-    {
-        enforceForSwitchCase?: boolean;
-        enforceForIndexOf?: boolean;
-    }
-];
-type ValidTypeof = [] | [
-    {
-        requireStringLiterals?: boolean;
-    }
-];
-type WrapIife = [] | [("outside" | "inside" | "any")] | [
-    ("outside" | "inside" | "any"),
-    {
-        functionPrototypeMethods?: boolean;
-    }
-];
-type YieldStarSpacing = [] | [
-    (("before" | "after" | "both" | "neither") | {
-        before?: boolean;
-        after?: boolean;
-    })
-];
-type Yoda = [] | [("always" | "never")] | [
-    ("always" | "never"),
-    {
-        exceptRange?: boolean;
-        onlyEquality?: boolean;
-    }
-];
-export {};