@w5s/eslint-config 2.4.4 → 3.0.0

package/src/typegen/style.d.ts

@@ -0,0 +1,1637 @@
+/* eslint-disable unicorn/no-abusive-eslint-disable */
+/* eslint-disable */
+/* prettier-ignore */
+import type { Linter } from 'eslint'
+
+declare module 'eslint' {
+  namespace Linter {
+    interface RulesRecord extends RuleOptions {}
+  }
+}
+
+export interface RuleOptions {
+  /**
+   * Enforce linebreaks after opening and before closing array brackets
+   * @see https://eslint.style/rules/js/array-bracket-newline
+   */
+  'style/array-bracket-newline'?: Linter.RuleEntry<StyleArrayBracketNewline>
+  /**
+   * Enforce consistent spacing inside array brackets
+   * @see https://eslint.style/rules/js/array-bracket-spacing
+   */
+  'style/array-bracket-spacing'?: Linter.RuleEntry<StyleArrayBracketSpacing>
+  /**
+   * Enforce line breaks after each array element
+   * @see https://eslint.style/rules/js/array-element-newline
+   */
+  'style/array-element-newline'?: Linter.RuleEntry<StyleArrayElementNewline>
+  /**
+   * Require parentheses around arrow function arguments
+   * @see https://eslint.style/rules/js/arrow-parens
+   */
+  'style/arrow-parens'?: Linter.RuleEntry<StyleArrowParens>
+  /**
+   * Enforce consistent spacing before and after the arrow in arrow functions
+   * @see https://eslint.style/rules/js/arrow-spacing
+   */
+  'style/arrow-spacing'?: Linter.RuleEntry<StyleArrowSpacing>
+  /**
+   * Disallow or enforce spaces inside of blocks after opening block and before closing block
+   * @see https://eslint.style/rules/ts/block-spacing
+   */
+  'style/block-spacing'?: Linter.RuleEntry<StyleBlockSpacing>
+  /**
+   * Enforce consistent brace style for blocks
+   * @see https://eslint.style/rules/ts/brace-style
+   */
+  'style/brace-style'?: Linter.RuleEntry<StyleBraceStyle>
+  /**
+   * Require or disallow trailing commas
+   * @see https://eslint.style/rules/ts/comma-dangle
+   */
+  'style/comma-dangle'?: Linter.RuleEntry<StyleCommaDangle>
+  /**
+   * Enforce consistent spacing before and after commas
+   * @see https://eslint.style/rules/ts/comma-spacing
+   */
+  'style/comma-spacing'?: Linter.RuleEntry<StyleCommaSpacing>
+  /**
+   * Enforce consistent comma style
+   * @see https://eslint.style/rules/js/comma-style
+   */
+  'style/comma-style'?: Linter.RuleEntry<StyleCommaStyle>
+  /**
+   * Enforce consistent spacing inside computed property brackets
+   * @see https://eslint.style/rules/js/computed-property-spacing
+   */
+  'style/computed-property-spacing'?: Linter.RuleEntry<StyleComputedPropertySpacing>
+  /**
+   * Enforce consistent line breaks after opening and before closing braces
+   * @see https://eslint.style/rules/plus/curly-newline
+   */
+  'style/curly-newline'?: Linter.RuleEntry<StyleCurlyNewline>
+  /**
+   * Enforce consistent newlines before and after dots
+   * @see https://eslint.style/rules/js/dot-location
+   */
+  'style/dot-location'?: Linter.RuleEntry<StyleDotLocation>
+  /**
+   * Require or disallow newline at the end of files
+   * @see https://eslint.style/rules/js/eol-last
+   */
+  'style/eol-last'?: Linter.RuleEntry<StyleEolLast>
+  /**
+   * Require or disallow spacing between function identifiers and their invocations
+   * @see https://eslint.style/rules/ts/function-call-spacing
+   */
+  'style/func-call-spacing'?: Linter.RuleEntry<StyleFuncCallSpacing>
+  /**
+   * Enforce line breaks between arguments of a function call
+   * @see https://eslint.style/rules/js/function-call-argument-newline
+   */
+  'style/function-call-argument-newline'?: Linter.RuleEntry<StyleFunctionCallArgumentNewline>
+  /**
+   * Require or disallow spacing between function identifiers and their invocations
+   * @see https://eslint.style/rules/ts/function-call-spacing
+   */
+  'style/function-call-spacing'?: Linter.RuleEntry<StyleFunctionCallSpacing>
+  /**
+   * Enforce consistent line breaks inside function parentheses
+   * @see https://eslint.style/rules/js/function-paren-newline
+   */
+  'style/function-paren-newline'?: Linter.RuleEntry<StyleFunctionParenNewline>
+  /**
+   * Enforce consistent spacing around `*` operators in generator functions
+   * @see https://eslint.style/rules/js/generator-star-spacing
+   */
+  'style/generator-star-spacing'?: Linter.RuleEntry<StyleGeneratorStarSpacing>
+  /**
+   * Enforce the location of arrow function bodies
+   * @see https://eslint.style/rules/js/implicit-arrow-linebreak
+   */
+  'style/implicit-arrow-linebreak'?: Linter.RuleEntry<StyleImplicitArrowLinebreak>
+  /**
+   * Enforce consistent indentation
+   * @see https://eslint.style/rules/ts/indent
+   */
+  'style/indent'?: Linter.RuleEntry<StyleIndent>
+  /**
+   * Indentation for binary operators
+   * @see https://eslint.style/rules/plus/indent-binary-ops
+   */
+  'style/indent-binary-ops'?: Linter.RuleEntry<StyleIndentBinaryOps>
+  /**
+   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
+   * @see https://eslint.style/rules/jsx/jsx-child-element-spacing
+   */
+  'style/jsx-child-element-spacing'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce closing bracket location in JSX
+   * @see https://eslint.style/rules/jsx/jsx-closing-bracket-location
+   */
+  'style/jsx-closing-bracket-location'?: Linter.RuleEntry<StyleJsxClosingBracketLocation>
+  /**
+   * Enforce closing tag location for multiline JSX
+   * @see https://eslint.style/rules/jsx/jsx-closing-tag-location
+   */
+  'style/jsx-closing-tag-location'?: Linter.RuleEntry<StyleJsxClosingTagLocation>
+  /**
+   * Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
+   * @see https://eslint.style/rules/jsx/jsx-curly-brace-presence
+   */
+  'style/jsx-curly-brace-presence'?: Linter.RuleEntry<StyleJsxCurlyBracePresence>
+  /**
+   * Enforce consistent linebreaks in curly braces in JSX attributes and expressions
+   * @see https://eslint.style/rules/jsx/jsx-curly-newline
+   */
+  'style/jsx-curly-newline'?: Linter.RuleEntry<StyleJsxCurlyNewline>
+  /**
+   * Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
+   * @see https://eslint.style/rules/jsx/jsx-curly-spacing
+   */
+  'style/jsx-curly-spacing'?: Linter.RuleEntry<StyleJsxCurlySpacing>
+  /**
+   * Enforce or disallow spaces around equal signs in JSX attributes
+   * @see https://eslint.style/rules/jsx/jsx-equals-spacing
+   */
+  'style/jsx-equals-spacing'?: Linter.RuleEntry<StyleJsxEqualsSpacing>
+  /**
+   * Enforce proper position of the first property in JSX
+   * @see https://eslint.style/rules/jsx/jsx-first-prop-new-line
+   */
+  'style/jsx-first-prop-new-line'?: Linter.RuleEntry<StyleJsxFirstPropNewLine>
+  /**
+   * Enforce line breaks before and after JSX elements when they are used as arguments to a function.
+   * @see https://eslint.style/rules/jsx/jsx-function-call-newline
+   */
+  'style/jsx-function-call-newline'?: Linter.RuleEntry<StyleJsxFunctionCallNewline>
+  /**
+   * Enforce JSX indentation. Deprecated, use `indent` rule instead.
+   * @see https://eslint.style/rules/jsx/jsx-indent
+   * @deprecated
+   */
+  'style/jsx-indent'?: Linter.RuleEntry<StyleJsxIndent>
+  /**
+   * Enforce props indentation in JSX
+   * @see https://eslint.style/rules/jsx/jsx-indent-props
+   */
+  'style/jsx-indent-props'?: Linter.RuleEntry<StyleJsxIndentProps>
+  /**
+   * Enforce maximum of props on a single line in JSX
+   * @see https://eslint.style/rules/jsx/jsx-max-props-per-line
+   */
+  'style/jsx-max-props-per-line'?: Linter.RuleEntry<StyleJsxMaxPropsPerLine>
+  /**
+   * Require or prevent a new line after jsx elements and expressions.
+   * @see https://eslint.style/rules/jsx/jsx-newline
+   */
+  'style/jsx-newline'?: Linter.RuleEntry<StyleJsxNewline>
+  /**
+   * Require one JSX element per line
+   * @see https://eslint.style/rules/jsx/jsx-one-expression-per-line
+   */
+  'style/jsx-one-expression-per-line'?: Linter.RuleEntry<StyleJsxOneExpressionPerLine>
+  /**
+   * Enforce PascalCase for user-defined JSX components
+   * @see https://eslint.style/rules/jsx/jsx-pascal-case
+   */
+  'style/jsx-pascal-case'?: Linter.RuleEntry<StyleJsxPascalCase>
+  /**
+   * Disallow multiple spaces between inline JSX props
+   * @see https://eslint.style/rules/jsx/jsx-props-no-multi-spaces
+   */
+  'style/jsx-props-no-multi-spaces'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce the consistent use of either double or single quotes in JSX attributes
+   * @see https://eslint.style/rules/js/jsx-quotes
+   */
+  'style/jsx-quotes'?: Linter.RuleEntry<StyleJsxQuotes>
+  /**
+   * Disallow extra closing tags for components without children
+   * @see https://eslint.style/rules/jsx/jsx-self-closing-comp
+   */
+  'style/jsx-self-closing-comp'?: Linter.RuleEntry<StyleJsxSelfClosingComp>
+  /**
+   * Enforce props alphabetical sorting
+   * @see https://eslint.style/rules/jsx/jsx-sort-props
+   */
+  'style/jsx-sort-props'?: Linter.RuleEntry<StyleJsxSortProps>
+  /**
+   * Enforce whitespace in and around the JSX opening and closing brackets
+   * @see https://eslint.style/rules/jsx/jsx-tag-spacing
+   */
+  'style/jsx-tag-spacing'?: Linter.RuleEntry<StyleJsxTagSpacing>
+  /**
+   * Disallow missing parentheses around multiline JSX
+   * @see https://eslint.style/rules/jsx/jsx-wrap-multilines
+   */
+  'style/jsx-wrap-multilines'?: Linter.RuleEntry<StyleJsxWrapMultilines>
+  /**
+   * Enforce consistent spacing between property names and type annotations in types and interfaces
+   * @see https://eslint.style/rules/ts/key-spacing
+   */
+  'style/key-spacing'?: Linter.RuleEntry<StyleKeySpacing>
+  /**
+   * Enforce consistent spacing before and after keywords
+   * @see https://eslint.style/rules/ts/keyword-spacing
+   */
+  'style/keyword-spacing'?: Linter.RuleEntry<StyleKeywordSpacing>
+  /**
+   * Enforce position of line comments
+   * @see https://eslint.style/rules/js/line-comment-position
+   */
+  'style/line-comment-position'?: Linter.RuleEntry<StyleLineCommentPosition>
+  /**
+   * Enforce consistent linebreak style
+   * @see https://eslint.style/rules/js/linebreak-style
+   */
+  'style/linebreak-style'?: Linter.RuleEntry<StyleLinebreakStyle>
+  /**
+   * Require empty lines around comments
+   * @see https://eslint.style/rules/ts/lines-around-comment
+   */
+  'style/lines-around-comment'?: Linter.RuleEntry<StyleLinesAroundComment>
+  /**
+   * Require or disallow an empty line between class members
+   * @see https://eslint.style/rules/ts/lines-between-class-members
+   */
+  'style/lines-between-class-members'?: Linter.RuleEntry<StyleLinesBetweenClassMembers>
+  /**
+   * Enforce a maximum line length
+   * @see https://eslint.style/rules/js/max-len
+   */
+  'style/max-len'?: Linter.RuleEntry<StyleMaxLen>
+  /**
+   * Enforce a maximum number of statements allowed per line
+   * @see https://eslint.style/rules/js/max-statements-per-line
+   */
+  'style/max-statements-per-line'?: Linter.RuleEntry<StyleMaxStatementsPerLine>
+  /**
+   * Require a specific member delimiter style for interfaces and type literals
+   * @see https://eslint.style/rules/ts/member-delimiter-style
+   */
+  'style/member-delimiter-style'?: Linter.RuleEntry<StyleMemberDelimiterStyle>
+  /**
+   * Enforce a particular style for multiline comments
+   * @see https://eslint.style/rules/js/multiline-comment-style
+   */
+  'style/multiline-comment-style'?: Linter.RuleEntry<StyleMultilineCommentStyle>
+  /**
+   * Enforce newlines between operands of ternary expressions
+   * @see https://eslint.style/rules/js/multiline-ternary
+   */
+  'style/multiline-ternary'?: Linter.RuleEntry<StyleMultilineTernary>
+  /**
+   * Enforce or disallow parentheses when invoking a constructor with no arguments
+   * @see https://eslint.style/rules/js/new-parens
+   */
+  'style/new-parens'?: Linter.RuleEntry<StyleNewParens>
+  /**
+   * Require a newline after each call in a method chain
+   * @see https://eslint.style/rules/js/newline-per-chained-call
+   */
+  'style/newline-per-chained-call'?: Linter.RuleEntry<StyleNewlinePerChainedCall>
+  /**
+   * Disallow arrow functions where they could be confused with comparisons
+   * @see https://eslint.style/rules/js/no-confusing-arrow
+   */
+  'style/no-confusing-arrow'?: Linter.RuleEntry<StyleNoConfusingArrow>
+  /**
+   * Disallow unnecessary parentheses
+   * @see https://eslint.style/rules/ts/no-extra-parens
+   */
+  'style/no-extra-parens'?: Linter.RuleEntry<StyleNoExtraParens>
+  /**
+   * Disallow unnecessary semicolons
+   * @see https://eslint.style/rules/ts/no-extra-semi
+   */
+  'style/no-extra-semi'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow leading or trailing decimal points in numeric literals
+   * @see https://eslint.style/rules/js/no-floating-decimal
+   */
+  'style/no-floating-decimal'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow mixed binary operators
+   * @see https://eslint.style/rules/js/no-mixed-operators
+   */
+  'style/no-mixed-operators'?: Linter.RuleEntry<StyleNoMixedOperators>
+  /**
+   * Disallow mixed spaces and tabs for indentation
+   * @see https://eslint.style/rules/js/no-mixed-spaces-and-tabs
+   */
+  'style/no-mixed-spaces-and-tabs'?: Linter.RuleEntry<StyleNoMixedSpacesAndTabs>
+  /**
+   * Disallow multiple spaces
+   * @see https://eslint.style/rules/js/no-multi-spaces
+   */
+  'style/no-multi-spaces'?: Linter.RuleEntry<StyleNoMultiSpaces>
+  /**
+   * Disallow multiple empty lines
+   * @see https://eslint.style/rules/js/no-multiple-empty-lines
+   */
+  'style/no-multiple-empty-lines'?: Linter.RuleEntry<StyleNoMultipleEmptyLines>
+  /**
+   * Disallow all tabs
+   * @see https://eslint.style/rules/js/no-tabs
+   */
+  'style/no-tabs'?: Linter.RuleEntry<StyleNoTabs>
+  /**
+   * Disallow trailing whitespace at the end of lines
+   * @see https://eslint.style/rules/js/no-trailing-spaces
+   */
+  'style/no-trailing-spaces'?: Linter.RuleEntry<StyleNoTrailingSpaces>
+  /**
+   * Disallow whitespace before properties
+   * @see https://eslint.style/rules/js/no-whitespace-before-property
+   */
+  'style/no-whitespace-before-property'?: Linter.RuleEntry<[]>
+  /**
+   * Enforce the location of single-line statements
+   * @see https://eslint.style/rules/js/nonblock-statement-body-position
+   */
+  'style/nonblock-statement-body-position'?: Linter.RuleEntry<StyleNonblockStatementBodyPosition>
+  /**
+   * Enforce consistent line breaks after opening and before closing braces
+   * @see https://eslint.style/rules/ts/object-curly-newline
+   */
+  'style/object-curly-newline'?: Linter.RuleEntry<StyleObjectCurlyNewline>
+  /**
+   * Enforce consistent spacing inside braces
+   * @see https://eslint.style/rules/ts/object-curly-spacing
+   */
+  'style/object-curly-spacing'?: Linter.RuleEntry<StyleObjectCurlySpacing>
+  /**
+   * Enforce placing object properties on separate lines
+   * @see https://eslint.style/rules/ts/object-property-newline
+   */
+  'style/object-property-newline'?: Linter.RuleEntry<StyleObjectPropertyNewline>
+  /**
+   * Require or disallow newlines around variable declarations
+   * @see https://eslint.style/rules/js/one-var-declaration-per-line
+   */
+  'style/one-var-declaration-per-line'?: Linter.RuleEntry<StyleOneVarDeclarationPerLine>
+  /**
+   * Enforce consistent linebreak style for operators
+   * @see https://eslint.style/rules/js/operator-linebreak
+   */
+  'style/operator-linebreak'?: Linter.RuleEntry<StyleOperatorLinebreak>
+  /**
+   * Require or disallow padding within blocks
+   * @see https://eslint.style/rules/js/padded-blocks
+   */
+  'style/padded-blocks'?: Linter.RuleEntry<StylePaddedBlocks>
+  /**
+   * Require or disallow padding lines between statements
+   * @see https://eslint.style/rules/ts/padding-line-between-statements
+   */
+  'style/padding-line-between-statements'?: Linter.RuleEntry<StylePaddingLineBetweenStatements>
+  /**
+   * Require quotes around object literal, type literal, interfaces and enums property names
+   * @see https://eslint.style/rules/ts/quote-props
+   */
+  'style/quote-props'?: Linter.RuleEntry<StyleQuoteProps>
+  /**
+   * Enforce the consistent use of either backticks, double, or single quotes
+   * @see https://eslint.style/rules/ts/quotes
+   */
+  'style/quotes'?: Linter.RuleEntry<StyleQuotes>
+  /**
+   * Enforce spacing between rest and spread operators and their expressions
+   * @see https://eslint.style/rules/js/rest-spread-spacing
+   */
+  'style/rest-spread-spacing'?: Linter.RuleEntry<StyleRestSpreadSpacing>
+  /**
+   * Require or disallow semicolons instead of ASI
+   * @see https://eslint.style/rules/ts/semi
+   */
+  'style/semi'?: Linter.RuleEntry<StyleSemi>
+  /**
+   * Enforce consistent spacing before and after semicolons
+   * @see https://eslint.style/rules/js/semi-spacing
+   */
+  'style/semi-spacing'?: Linter.RuleEntry<StyleSemiSpacing>
+  /**
+   * Enforce location of semicolons
+   * @see https://eslint.style/rules/js/semi-style
+   */
+  'style/semi-style'?: Linter.RuleEntry<StyleSemiStyle>
+  /**
+   * Enforce consistent spacing before blocks
+   * @see https://eslint.style/rules/ts/space-before-blocks
+   */
+  'style/space-before-blocks'?: Linter.RuleEntry<StyleSpaceBeforeBlocks>
+  /**
+   * Enforce consistent spacing before function parenthesis
+   * @see https://eslint.style/rules/ts/space-before-function-paren
+   */
+  'style/space-before-function-paren'?: Linter.RuleEntry<StyleSpaceBeforeFunctionParen>
+  /**
+   * Enforce consistent spacing inside parentheses
+   * @see https://eslint.style/rules/js/space-in-parens
+   */
+  'style/space-in-parens'?: Linter.RuleEntry<StyleSpaceInParens>
+  /**
+   * Require spacing around infix operators
+   * @see https://eslint.style/rules/ts/space-infix-ops
+   */
+  'style/space-infix-ops'?: Linter.RuleEntry<StyleSpaceInfixOps>
+  /**
+   * Enforce consistent spacing before or after unary operators
+   * @see https://eslint.style/rules/js/space-unary-ops
+   */
+  'style/space-unary-ops'?: Linter.RuleEntry<StyleSpaceUnaryOps>
+  /**
+   * Enforce consistent spacing after the `//` or `/*` in a comment
+   * @see https://eslint.style/rules/js/spaced-comment
+   */
+  'style/spaced-comment'?: Linter.RuleEntry<StyleSpacedComment>
+  /**
+   * Enforce spacing around colons of switch statements
+   * @see https://eslint.style/rules/js/switch-colon-spacing
+   */
+  'style/switch-colon-spacing'?: Linter.RuleEntry<StyleSwitchColonSpacing>
+  /**
+   * Require or disallow spacing around embedded expressions of template strings
+   * @see https://eslint.style/rules/js/template-curly-spacing
+   */
+  'style/template-curly-spacing'?: Linter.RuleEntry<StyleTemplateCurlySpacing>
+  /**
+   * Require or disallow spacing between template tags and their literals
+   * @see https://eslint.style/rules/js/template-tag-spacing
+   */
+  'style/template-tag-spacing'?: Linter.RuleEntry<StyleTemplateTagSpacing>
+  /**
+   * Require consistent spacing around type annotations
+   * @see https://eslint.style/rules/ts/type-annotation-spacing
+   */
+  'style/type-annotation-spacing'?: Linter.RuleEntry<StyleTypeAnnotationSpacing>
+  /**
+   * Enforces consistent spacing inside TypeScript type generics
+   * @see https://eslint.style/rules/plus/type-generic-spacing
+   */
+  'style/type-generic-spacing'?: Linter.RuleEntry<[]>
+  /**
+   * Expect space before the type declaration in the named tuple
+   * @see https://eslint.style/rules/plus/type-named-tuple-spacing
+   */
+  'style/type-named-tuple-spacing'?: Linter.RuleEntry<[]>
+  /**
+   * Require parentheses around immediate `function` invocations
+   * @see https://eslint.style/rules/js/wrap-iife
+   */
+  'style/wrap-iife'?: Linter.RuleEntry<StyleWrapIife>
+  /**
+   * Require parenthesis around regex literals
+   * @see https://eslint.style/rules/js/wrap-regex
+   */
+  'style/wrap-regex'?: Linter.RuleEntry<[]>
+  /**
+   * Require or disallow spacing around the `*` in `yield*` expressions
+   * @see https://eslint.style/rules/js/yield-star-spacing
+   */
+  'style/yield-star-spacing'?: Linter.RuleEntry<StyleYieldStarSpacing>
+}
+
+/* ======= Declarations ======= */
+// ----- style/array-bracket-newline -----
+type StyleArrayBracketNewline = []|[(("always" | "never" | "consistent") | {
+  multiline?: boolean
+  minItems?: (number | null)
+})]
+// ----- style/array-bracket-spacing -----
+type StyleArrayBracketSpacing = []|[("always" | "never")]|[("always" | "never"), {
+  singleValue?: boolean
+  objectsInArrays?: boolean
+  arraysInArrays?: boolean
+}]
+// ----- style/array-element-newline -----
+type StyleArrayElementNewline = []|[(_StyleArrayElementNewlineBasicConfig | {
+  ArrayExpression?: _StyleArrayElementNewlineBasicConfig
+  ArrayPattern?: _StyleArrayElementNewlineBasicConfig
+})]
+type _StyleArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
+  consistent?: boolean
+  multiline?: boolean
+  minItems?: (number | null)
+})
+// ----- style/arrow-parens -----
+type StyleArrowParens = []|[("always" | "as-needed")]|[("always" | "as-needed"), {
+  requireForBlockBody?: boolean
+}]
+// ----- style/arrow-spacing -----
+type StyleArrowSpacing = []|[{
+  before?: boolean
+  after?: boolean
+}]
+// ----- style/block-spacing -----
+type StyleBlockSpacing = []|[("always" | "never")]
+// ----- style/brace-style -----
+type StyleBraceStyle = []|[("1tbs" | "stroustrup" | "allman")]|[("1tbs" | "stroustrup" | "allman"), {
+  allowSingleLine?: boolean
+}]
+// ----- style/comma-dangle -----
+type StyleCommaDangle = []|[(_StyleCommaDangleValue | {
+  arrays?: _StyleCommaDangleValueWithIgnore
+  objects?: _StyleCommaDangleValueWithIgnore
+  imports?: _StyleCommaDangleValueWithIgnore
+  exports?: _StyleCommaDangleValueWithIgnore
+  functions?: _StyleCommaDangleValueWithIgnore
+  importAttributes?: _StyleCommaDangleValueWithIgnore
+  dynamicImports?: _StyleCommaDangleValueWithIgnore
+  enums?: _StyleCommaDangleValueWithIgnore
+  generics?: _StyleCommaDangleValueWithIgnore
+  tuples?: _StyleCommaDangleValueWithIgnore
+})]
+type _StyleCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline")
+type _StyleCommaDangleValueWithIgnore = ("always-multiline" | "always" | "never" | "only-multiline" | "ignore")
+// ----- style/comma-spacing -----
+type StyleCommaSpacing = []|[{
+  before?: boolean
+  after?: boolean
+}]
+// ----- style/comma-style -----
+type StyleCommaStyle = []|[("first" | "last")]|[("first" | "last"), {
+  exceptions?: {
+    [k: string]: boolean | undefined
+  }
+}]
+// ----- style/computed-property-spacing -----
+type StyleComputedPropertySpacing = []|[("always" | "never")]|[("always" | "never"), {
+  enforceForClassMembers?: boolean
+}]
+// ----- style/curly-newline -----
+type StyleCurlyNewline = []|[(("always" | "never") | {
+  IfStatementConsequent?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  IfStatementAlternative?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  DoWhileStatement?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  ForInStatement?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  ForOfStatement?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  ForStatement?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  WhileStatement?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  SwitchStatement?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  SwitchCase?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  TryStatementBlock?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  TryStatementHandler?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  TryStatementFinalizer?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  BlockStatement?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  ArrowFunctionExpression?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  FunctionDeclaration?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  FunctionExpression?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  Property?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  ClassBody?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  StaticBlock?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  WithStatement?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  TSEnumBody?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  TSInterfaceBody?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  TSModuleBlock?: (("always" | "never") | {
+    multiline?: boolean
+    minElements?: number
+    consistent?: boolean
+  })
+  multiline?: boolean
+  minElements?: number
+  consistent?: boolean
+})]
+// ----- style/dot-location -----
+type StyleDotLocation = []|[("object" | "property")]
+// ----- style/eol-last -----
+type StyleEolLast = []|[("always" | "never" | "unix" | "windows")]
+// ----- style/func-call-spacing -----
+type StyleFuncCallSpacing = ([]|["never"] | []|["always"]|["always", {
+  allowNewlines?: boolean
+  optionalChain?: {
+    before?: boolean
+    after?: boolean
+  }
+}])
+// ----- style/function-call-argument-newline -----
+type StyleFunctionCallArgumentNewline = []|[("always" | "never" | "consistent")]
+// ----- style/function-call-spacing -----
+type StyleFunctionCallSpacing = ([]|["never"] | []|["always"]|["always", {
+  allowNewlines?: boolean
+  optionalChain?: {
+    before?: boolean
+    after?: boolean
+  }
+}])
+// ----- style/function-paren-newline -----
+type StyleFunctionParenNewline = []|[(("always" | "never" | "consistent" | "multiline" | "multiline-arguments") | {
+  minItems?: number
+})]
+// ----- style/generator-star-spacing -----
+type StyleGeneratorStarSpacing = []|[(("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
+  })
+})]
+// ----- style/implicit-arrow-linebreak -----
+type StyleImplicitArrowLinebreak = []|[("beside" | "below")]
+// ----- style/indent -----
+type StyleIndent = []|[("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
+  offsetTernaryExpressionsOffsetCallExpressions?: boolean
+  ignoredNodes?: string[]
+  ignoreComments?: boolean
+  tabLength?: number
+}]
+// ----- style/indent-binary-ops -----
+type StyleIndentBinaryOps = []|[(number | "tab")]
+// ----- style/jsx-closing-bracket-location -----
+type StyleJsxClosingBracketLocation = []|[(("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | {
+  location?: ("after-props" | "props-aligned" | "tag-aligned" | "line-aligned")
+} | {
+  nonEmpty?: (("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | false)
+  selfClosing?: (("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | false)
+})]
+// ----- style/jsx-closing-tag-location -----
+type StyleJsxClosingTagLocation = []|[("tag-aligned" | "line-aligned")]
+// ----- style/jsx-curly-brace-presence -----
+type StyleJsxCurlyBracePresence = []|[({
+  props?: ("always" | "never" | "ignore")
+  children?: ("always" | "never" | "ignore")
+  propElementValues?: ("always" | "never" | "ignore")
+} | ("always" | "never" | "ignore"))]
+// ----- style/jsx-curly-newline -----
+type StyleJsxCurlyNewline = []|[(("consistent" | "never") | {
+  singleline?: ("consistent" | "require" | "forbid")
+  multiline?: ("consistent" | "require" | "forbid")
+})]
+// ----- style/jsx-curly-spacing -----
+type StyleJsxCurlySpacing = []|[((_StyleJsxCurlySpacing_BasicConfig & {
+  attributes?: _StyleJsxCurlySpacingBasicConfigOrBoolean
+  children?: _StyleJsxCurlySpacingBasicConfigOrBoolean
+  [k: string]: unknown | undefined
+}) | ("always" | "never"))]|[((_StyleJsxCurlySpacing_BasicConfig & {
+  attributes?: _StyleJsxCurlySpacingBasicConfigOrBoolean
+  children?: _StyleJsxCurlySpacingBasicConfigOrBoolean
+  [k: string]: unknown | undefined
+}) | ("always" | "never")), {
+  allowMultiline?: boolean
+  spacing?: {
+    objectLiterals?: ("always" | "never")
+    [k: string]: unknown | undefined
+  }
+}]
+type _StyleJsxCurlySpacingBasicConfigOrBoolean = (_StyleJsxCurlySpacing_BasicConfig | boolean)
+interface _StyleJsxCurlySpacing_BasicConfig {
+  when?: ("always" | "never")
+  allowMultiline?: boolean
+  spacing?: {
+    objectLiterals?: ("always" | "never")
+    [k: string]: unknown | undefined
+  }
+  [k: string]: unknown | undefined
+}
+// ----- style/jsx-equals-spacing -----
+type StyleJsxEqualsSpacing = []|[("always" | "never")]
+// ----- style/jsx-first-prop-new-line -----
+type StyleJsxFirstPropNewLine = []|[("always" | "never" | "multiline" | "multiline-multiprop" | "multiprop")]
+// ----- style/jsx-function-call-newline -----
+type StyleJsxFunctionCallNewline = []|[("always" | "multiline")]
+// ----- style/jsx-indent -----
+type StyleJsxIndent = []|[("tab" | number)]|[("tab" | number), {
+  checkAttributes?: boolean
+  indentLogicalExpressions?: boolean
+}]
+// ----- style/jsx-indent-props -----
+type StyleJsxIndentProps = []|[(("tab" | "first") | number | {
+  indentMode?: (("tab" | "first") | number)
+  ignoreTernaryOperator?: boolean
+  [k: string]: unknown | undefined
+})]
+// ----- style/jsx-max-props-per-line -----
+type StyleJsxMaxPropsPerLine = []|[({
+  maximum?: {
+    single?: number
+    multi?: number
+    [k: string]: unknown | undefined
+  }
+} | {
+  maximum?: number
+  when?: ("always" | "multiline")
+})]
+// ----- style/jsx-newline -----
+type StyleJsxNewline = []|[{
+  prevent?: boolean
+  allowMultilines?: boolean
+}]
+// ----- style/jsx-one-expression-per-line -----
+type StyleJsxOneExpressionPerLine = []|[{
+  allow?: ("none" | "literal" | "single-child" | "single-line" | "non-jsx")
+}]
+// ----- style/jsx-pascal-case -----
+type StyleJsxPascalCase = []|[{
+  allowAllCaps?: boolean
+  allowLeadingUnderscore?: boolean
+  allowNamespace?: boolean
+  ignore?: string[]
+}]
+// ----- style/jsx-quotes -----
+type StyleJsxQuotes = []|[("prefer-single" | "prefer-double")]
+// ----- style/jsx-self-closing-comp -----
+type StyleJsxSelfClosingComp = []|[{
+  component?: boolean
+  html?: boolean
+}]
+// ----- style/jsx-sort-props -----
+type StyleJsxSortProps = []|[{
+  callbacksLast?: boolean
+  shorthandFirst?: boolean
+  shorthandLast?: boolean
+  multiline?: ("ignore" | "first" | "last")
+  ignoreCase?: boolean
+  noSortAlphabetically?: boolean
+  reservedFirst?: (unknown[] | boolean)
+  locale?: string
+}]
+// ----- style/jsx-tag-spacing -----
+type StyleJsxTagSpacing = []|[{
+  closingSlash?: ("always" | "never" | "allow")
+  beforeSelfClosing?: ("always" | "proportional-always" | "never" | "allow")
+  afterOpening?: ("always" | "allow-multiline" | "never" | "allow")
+  beforeClosing?: ("always" | "proportional-always" | "never" | "allow")
+}]
+// ----- style/jsx-wrap-multilines -----
+type StyleJsxWrapMultilines = []|[{
+  declaration?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"))
+  assignment?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"))
+  return?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"))
+  arrow?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"))
+  condition?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"))
+  logical?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"))
+  prop?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"))
+  propertyValue?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"))
+}]
+// ----- style/key-spacing -----
+type StyleKeySpacing = []|[({
+  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
+  }
+})]
+// ----- style/keyword-spacing -----
+type StyleKeywordSpacing = []|[{
+  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
+    }
+    satisfies?: {
+      before?: boolean
+      after?: boolean
+    }
+    set?: {
+      before?: boolean
+      after?: boolean
+    }
+    short?: {
+      before?: boolean
+      after?: boolean
+    }
+    static?: {
+      before?: boolean
+      after?: boolean
+    }
+    super?: {
+      before?: boolean
+      after?: boolean
+    }
+    switch?: {
+      before?: boolean
+      after?: boolean
+    }
+    synchronized?: {
+      before?: boolean
+      after?: boolean
+    }
+    this?: {
+      before?: boolean
+      after?: boolean
+    }
+    throw?: {
+      before?: boolean
+      after?: boolean
+    }
+    throws?: {
+      before?: boolean
+      after?: boolean
+    }
+    transient?: {
+      before?: boolean
+      after?: boolean
+    }
+    true?: {
+      before?: boolean
+      after?: boolean
+    }
+    try?: {
+      before?: boolean
+      after?: boolean
+    }
+    typeof?: {
+      before?: boolean
+      after?: boolean
+    }
+    var?: {
+      before?: boolean
+      after?: boolean
+    }
+    void?: {
+      before?: boolean
+      after?: boolean
+    }
+    volatile?: {
+      before?: boolean
+      after?: boolean
+    }
+    while?: {
+      before?: boolean
+      after?: boolean
+    }
+    with?: {
+      before?: boolean
+      after?: boolean
+    }
+    yield?: {
+      before?: boolean
+      after?: boolean
+    }
+    type?: {
+      before?: boolean
+      after?: boolean
+    }
+  }
+}]
+// ----- style/line-comment-position -----
+type StyleLineCommentPosition = []|[(("above" | "beside") | {
+  position?: ("above" | "beside")
+  ignorePattern?: string
+  applyDefaultPatterns?: boolean
+  applyDefaultIgnorePatterns?: boolean
+})]
+// ----- style/linebreak-style -----
+type StyleLinebreakStyle = []|[("unix" | "windows")]
+// ----- style/lines-around-comment -----
+type StyleLinesAroundComment = []|[{
+  beforeBlockComment?: boolean
+  afterBlockComment?: boolean
+  beforeLineComment?: boolean
+  afterLineComment?: boolean
+  allowBlockStart?: boolean
+  allowBlockEnd?: boolean
+  allowClassStart?: boolean
+  allowClassEnd?: boolean
+  allowObjectStart?: boolean
+  allowObjectEnd?: boolean
+  allowArrayStart?: boolean
+  allowArrayEnd?: boolean
+  allowInterfaceStart?: boolean
+  allowInterfaceEnd?: boolean
+  allowTypeStart?: boolean
+  allowTypeEnd?: boolean
+  allowEnumStart?: boolean
+  allowEnumEnd?: boolean
+  allowModuleStart?: boolean
+  allowModuleEnd?: boolean
+  ignorePattern?: string
+  applyDefaultIgnorePatterns?: boolean
+  afterHashbangComment?: boolean
+}]
+// ----- style/lines-between-class-members -----
+type StyleLinesBetweenClassMembers = []|[({
+  
+  enforce: [{
+    blankLine: ("always" | "never")
+    prev: ("method" | "field" | "*")
+    next: ("method" | "field" | "*")
+  }, ...({
+    blankLine: ("always" | "never")
+    prev: ("method" | "field" | "*")
+    next: ("method" | "field" | "*")
+  })[]]
+} | ("always" | "never"))]|[({
+  
+  enforce: [{
+    blankLine: ("always" | "never")
+    prev: ("method" | "field" | "*")
+    next: ("method" | "field" | "*")
+  }, ...({
+    blankLine: ("always" | "never")
+    prev: ("method" | "field" | "*")
+    next: ("method" | "field" | "*")
+  })[]]
+} | ("always" | "never")), {
+  exceptAfterSingleLine?: boolean
+  exceptAfterOverload?: boolean
+}]
+// ----- style/max-len -----
+type StyleMaxLen = []|[({
+  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
+}]
+// ----- style/max-statements-per-line -----
+type StyleMaxStatementsPerLine = []|[{
+  max?: number
+  ignoredNodes?: ("BreakStatement" | "ClassDeclaration" | "ContinueStatement" | "DebuggerStatement" | "DoWhileStatement" | "ExpressionStatement" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "IfStatement" | "ImportDeclaration" | "LabeledStatement" | "ReturnStatement" | "SwitchStatement" | "ThrowStatement" | "TryStatement" | "VariableDeclaration" | "WhileStatement" | "WithStatement" | "ExportNamedDeclaration" | "ExportDefaultDeclaration" | "ExportAllDeclaration")[]
+}]
+// ----- style/member-delimiter-style -----
+type StyleMemberDelimiterStyle = []|[{
+  multiline?: {
+    delimiter?: ("none" | "semi" | "comma")
+    requireLast?: boolean
+  }
+  singleline?: {
+    delimiter?: ("semi" | "comma")
+    requireLast?: boolean
+  }
+  overrides?: {
+    interface?: _StyleMemberDelimiterStyle_DelimiterConfig
+    typeLiteral?: _StyleMemberDelimiterStyle_DelimiterConfig
+  }
+  multilineDetection?: ("brackets" | "last-member")
+}]
+interface _StyleMemberDelimiterStyle_DelimiterConfig {
+  multiline?: {
+    delimiter?: ("none" | "semi" | "comma")
+    requireLast?: boolean
+  }
+  singleline?: {
+    delimiter?: ("semi" | "comma")
+    requireLast?: boolean
+  }
+}
+// ----- style/multiline-comment-style -----
+type StyleMultilineCommentStyle = ([]|[("starred-block" | "bare-block")] | []|["separate-lines"]|["separate-lines", {
+  checkJSDoc?: boolean
+}])
+// ----- style/multiline-ternary -----
+type StyleMultilineTernary = []|[("always" | "always-multiline" | "never")]|[("always" | "always-multiline" | "never"), {
+  ignoreJSX?: boolean
+  [k: string]: unknown | undefined
+}]
+// ----- style/new-parens -----
+type StyleNewParens = []|[("always" | "never")]
+// ----- style/newline-per-chained-call -----
+type StyleNewlinePerChainedCall = []|[{
+  ignoreChainWithDepth?: number
+}]
+// ----- style/no-confusing-arrow -----
+type StyleNoConfusingArrow = []|[{
+  allowParens?: boolean
+  onlyOneSimpleParam?: boolean
+}]
+// ----- style/no-extra-parens -----
+type StyleNoExtraParens = ([]|["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
+}])
+// ----- style/no-mixed-operators -----
+type StyleNoMixedOperators = []|[{
+  groups?: [("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ...(("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"))[]][]
+  allowSamePrecedence?: boolean
+}]
+// ----- style/no-mixed-spaces-and-tabs -----
+type StyleNoMixedSpacesAndTabs = []|[("smart-tabs" | boolean)]
+// ----- style/no-multi-spaces -----
+type StyleNoMultiSpaces = []|[{
+  exceptions?: {
+    [k: string]: boolean
+  }
+  ignoreEOLComments?: boolean
+  includeTabs?: boolean
+}]
+// ----- style/no-multiple-empty-lines -----
+type StyleNoMultipleEmptyLines = []|[{
+  max: number
+  maxEOF?: number
+  maxBOF?: number
+}]
+// ----- style/no-tabs -----
+type StyleNoTabs = []|[{
+  allowIndentationTabs?: boolean
+}]
+// ----- style/no-trailing-spaces -----
+type StyleNoTrailingSpaces = []|[{
+  skipBlankLines?: boolean
+  ignoreComments?: boolean
+}]
+// ----- style/nonblock-statement-body-position -----
+type StyleNonblockStatementBodyPosition = []|[("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")
+  }
+}]
+// ----- style/object-curly-newline -----
+type StyleObjectCurlyNewline = []|[((("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
+  })
+  TSTypeLiteral?: (("always" | "never") | {
+    multiline?: boolean
+    minProperties?: number
+    consistent?: boolean
+  })
+  TSInterfaceBody?: (("always" | "never") | {
+    multiline?: boolean
+    minProperties?: number
+    consistent?: boolean
+  })
+})]
+// ----- style/object-curly-spacing -----
+type StyleObjectCurlySpacing = []|[("always" | "never")]|[("always" | "never"), {
+  arraysInObjects?: boolean
+  objectsInObjects?: boolean
+}]
+// ----- style/object-property-newline -----
+type StyleObjectPropertyNewline = []|[{
+  allowAllPropertiesOnSameLine?: boolean
+  allowMultiplePropertiesPerLine?: boolean
+}]
+// ----- style/one-var-declaration-per-line -----
+type StyleOneVarDeclarationPerLine = []|[("always" | "initializations")]
+// ----- style/operator-linebreak -----
+type StyleOperatorLinebreak = []|[(("after" | "before" | "none") | null)]|[(("after" | "before" | "none") | null), {
+  overrides?: {
+    [k: string]: ("after" | "before" | "none" | "ignore") | undefined
+  }
+}]
+// ----- style/padded-blocks -----
+type StylePaddedBlocks = []|[(("always" | "never") | {
+  blocks?: ("always" | "never")
+  switches?: ("always" | "never")
+  classes?: ("always" | "never")
+})]|[(("always" | "never") | {
+  blocks?: ("always" | "never")
+  switches?: ("always" | "never")
+  classes?: ("always" | "never")
+}), {
+  allowSingleLineBlocks?: boolean
+}]
+// ----- style/padding-line-between-statements -----
+type _StylePaddingLineBetweenStatementsPaddingType = ("any" | "never" | "always")
+type _StylePaddingLineBetweenStatementsStatementType = (("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload") | [("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload"), ...(("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload"))[]])
+type StylePaddingLineBetweenStatements = {
+  blankLine: _StylePaddingLineBetweenStatementsPaddingType
+  prev: _StylePaddingLineBetweenStatementsStatementType
+  next: _StylePaddingLineBetweenStatementsStatementType
+}[]
+// ----- style/quote-props -----
+type StyleQuoteProps = ([]|[("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
+}])
+// ----- style/quotes -----
+type StyleQuotes = []|[("single" | "double" | "backtick")]|[("single" | "double" | "backtick"), ("avoid-escape" | {
+  avoidEscape?: boolean
+  allowTemplateLiterals?: boolean
+  ignoreStringLiterals?: boolean
+})]
+// ----- style/rest-spread-spacing -----
+type StyleRestSpreadSpacing = []|[("always" | "never")]
+// ----- style/semi -----
+type StyleSemi = ([]|["never"]|["never", {
+  beforeStatementContinuationChars?: ("always" | "any" | "never")
+}] | []|["always"]|["always", {
+  omitLastInOneLineBlock?: boolean
+  omitLastInOneLineClassBody?: boolean
+}])
+// ----- style/semi-spacing -----
+type StyleSemiSpacing = []|[{
+  before?: boolean
+  after?: boolean
+}]
+// ----- style/semi-style -----
+type StyleSemiStyle = []|[("last" | "first")]
+// ----- style/space-before-blocks -----
+type StyleSpaceBeforeBlocks = []|[(("always" | "never") | {
+  keywords?: ("always" | "never" | "off")
+  functions?: ("always" | "never" | "off")
+  classes?: ("always" | "never" | "off")
+})]
+// ----- style/space-before-function-paren -----
+type StyleSpaceBeforeFunctionParen = []|[(("always" | "never") | {
+  anonymous?: ("always" | "never" | "ignore")
+  named?: ("always" | "never" | "ignore")
+  asyncArrow?: ("always" | "never" | "ignore")
+})]
+// ----- style/space-in-parens -----
+type StyleSpaceInParens = []|[("always" | "never")]|[("always" | "never"), {
+  exceptions?: ("{}" | "[]" | "()" | "empty")[]
+}]
+// ----- style/space-infix-ops -----
+type StyleSpaceInfixOps = []|[{
+  int32Hint?: boolean
+}]
+// ----- style/space-unary-ops -----
+type StyleSpaceUnaryOps = []|[{
+  words?: boolean
+  nonwords?: boolean
+  overrides?: {
+    [k: string]: boolean | undefined
+  }
+}]
+// ----- style/spaced-comment -----
+type StyleSpacedComment = []|[("always" | "never")]|[("always" | "never"), {
+  exceptions?: string[]
+  markers?: string[]
+  line?: {
+    exceptions?: string[]
+    markers?: string[]
+  }
+  block?: {
+    exceptions?: string[]
+    markers?: string[]
+    balanced?: boolean
+  }
+}]
+// ----- style/switch-colon-spacing -----
+type StyleSwitchColonSpacing = []|[{
+  before?: boolean
+  after?: boolean
+}]
+// ----- style/template-curly-spacing -----
+type StyleTemplateCurlySpacing = []|[("always" | "never")]
+// ----- style/template-tag-spacing -----
+type StyleTemplateTagSpacing = []|[("always" | "never")]
+// ----- style/type-annotation-spacing -----
+type StyleTypeAnnotationSpacing = []|[{
+  before?: boolean
+  after?: boolean
+  overrides?: {
+    colon?: _StyleTypeAnnotationSpacing_SpacingConfig
+    arrow?: _StyleTypeAnnotationSpacing_SpacingConfig
+    variable?: _StyleTypeAnnotationSpacing_SpacingConfig
+    parameter?: _StyleTypeAnnotationSpacing_SpacingConfig
+    property?: _StyleTypeAnnotationSpacing_SpacingConfig
+    returnType?: _StyleTypeAnnotationSpacing_SpacingConfig
+  }
+}]
+interface _StyleTypeAnnotationSpacing_SpacingConfig {
+  before?: boolean
+  after?: boolean
+}
+// ----- style/wrap-iife -----
+type StyleWrapIife = []|[("outside" | "inside" | "any")]|[("outside" | "inside" | "any"), {
+  functionPrototypeMethods?: boolean
+}]
+// ----- style/yield-star-spacing -----
+type StyleYieldStarSpacing = []|[(("before" | "after" | "both" | "neither") | {
+  before?: boolean
+  after?: boolean
+})]