@kitschpatrol/eslint-config/dist/index.d.ts

ESLint configuration for @kitschpatrol/shared-config.

import { FlatConfigComposer } from "eslint-flat-config-utils";
import { Linter } from "eslint";
import { FlatGitignoreOptions } from "eslint-config-flat-gitignore";

//#region src/typegen.d.ts
interface RuleOptions {
  /**
   * 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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/array-bracket-newline
   */
  'array-bracket-newline'?: Linter.RuleEntry<ArrayBracketNewline>;
  /**
   * Enforce consistent spacing inside array brackets
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/array-bracket-spacing
   */
  '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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/array-element-newline
   */
  '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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/arrow-parens
   */
  'arrow-parens'?: Linter.RuleEntry<ArrowParens>;
  /**
   * Enforce consistent spacing before and after the arrow in arrow functions
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/arrow-spacing
   */
  'arrow-spacing'?: Linter.RuleEntry<ArrowSpacing>;
  /**
   * Apply `jsx-a11y/alt-text` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/alt-text/
   */
  'astro/jsx-a11y/alt-text'?: Linter.RuleEntry<AstroJsxA11YAltText>;
  /**
   * Apply `jsx-a11y/anchor-ambiguous-text` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-ambiguous-text/
   */
  'astro/jsx-a11y/anchor-ambiguous-text'?: Linter.RuleEntry<AstroJsxA11YAnchorAmbiguousText>;
  /**
   * Apply `jsx-a11y/anchor-has-content` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-has-content/
   */
  'astro/jsx-a11y/anchor-has-content'?: Linter.RuleEntry<AstroJsxA11YAnchorHasContent>;
  /**
   * Apply `jsx-a11y/anchor-is-valid` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/anchor-is-valid/
   */
  'astro/jsx-a11y/anchor-is-valid'?: Linter.RuleEntry<AstroJsxA11YAnchorIsValid>;
  /**
   * Apply `jsx-a11y/aria-activedescendant-has-tabindex` rule to Astro
   * components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-activedescendant-has-tabindex/
   */
  'astro/jsx-a11y/aria-activedescendant-has-tabindex'?: Linter.RuleEntry<AstroJsxA11YAriaActivedescendantHasTabindex>;
  /**
   * Apply `jsx-a11y/aria-props` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-props/
   */
  'astro/jsx-a11y/aria-props'?: Linter.RuleEntry<AstroJsxA11YAriaProps>;
  /**
   * Apply `jsx-a11y/aria-proptypes` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-proptypes/
   */
  'astro/jsx-a11y/aria-proptypes'?: Linter.RuleEntry<AstroJsxA11YAriaProptypes>;
  /**
   * Apply `jsx-a11y/aria-role` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-role/
   */
  'astro/jsx-a11y/aria-role'?: Linter.RuleEntry<AstroJsxA11YAriaRole>;
  /**
   * Apply `jsx-a11y/aria-unsupported-elements` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/aria-unsupported-elements/
   */
  'astro/jsx-a11y/aria-unsupported-elements'?: Linter.RuleEntry<AstroJsxA11YAriaUnsupportedElements>;
  /**
   * Apply `jsx-a11y/autocomplete-valid` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/autocomplete-valid/
   */
  'astro/jsx-a11y/autocomplete-valid'?: Linter.RuleEntry<AstroJsxA11YAutocompleteValid>;
  /**
   * Apply `jsx-a11y/click-events-have-key-events` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/click-events-have-key-events/
   */
  'astro/jsx-a11y/click-events-have-key-events'?: Linter.RuleEntry<AstroJsxA11YClickEventsHaveKeyEvents>;
  /**
   * Apply `jsx-a11y/control-has-associated-label` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/control-has-associated-label/
   */
  'astro/jsx-a11y/control-has-associated-label'?: Linter.RuleEntry<AstroJsxA11YControlHasAssociatedLabel>;
  /**
   * Apply `jsx-a11y/heading-has-content` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/heading-has-content/
   */
  'astro/jsx-a11y/heading-has-content'?: Linter.RuleEntry<AstroJsxA11YHeadingHasContent>;
  /**
   * Apply `jsx-a11y/html-has-lang` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/html-has-lang/
   */
  'astro/jsx-a11y/html-has-lang'?: Linter.RuleEntry<AstroJsxA11YHtmlHasLang>;
  /**
   * Apply `jsx-a11y/iframe-has-title` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/iframe-has-title/
   */
  'astro/jsx-a11y/iframe-has-title'?: Linter.RuleEntry<AstroJsxA11YIframeHasTitle>;
  /**
   * Apply `jsx-a11y/img-redundant-alt` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/img-redundant-alt/
   */
  'astro/jsx-a11y/img-redundant-alt'?: Linter.RuleEntry<AstroJsxA11YImgRedundantAlt>;
  /**
   * Apply `jsx-a11y/interactive-supports-focus` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/interactive-supports-focus/
   */
  'astro/jsx-a11y/interactive-supports-focus'?: Linter.RuleEntry<AstroJsxA11YInteractiveSupportsFocus>;
  /**
   * Apply `jsx-a11y/label-has-associated-control` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/label-has-associated-control/
   */
  'astro/jsx-a11y/label-has-associated-control'?: Linter.RuleEntry<AstroJsxA11YLabelHasAssociatedControl>;
  /**
   * Apply `jsx-a11y/lang` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/lang/
   */
  'astro/jsx-a11y/lang'?: Linter.RuleEntry<AstroJsxA11YLang>;
  /**
   * Apply `jsx-a11y/media-has-caption` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/media-has-caption/
   */
  'astro/jsx-a11y/media-has-caption'?: Linter.RuleEntry<AstroJsxA11YMediaHasCaption>;
  /**
   * Apply `jsx-a11y/mouse-events-have-key-events` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/mouse-events-have-key-events/
   */
  'astro/jsx-a11y/mouse-events-have-key-events'?: Linter.RuleEntry<AstroJsxA11YMouseEventsHaveKeyEvents>;
  /**
   * Apply `jsx-a11y/no-access-key` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-access-key/
   */
  'astro/jsx-a11y/no-access-key'?: Linter.RuleEntry<AstroJsxA11YNoAccessKey>;
  /**
   * Apply `jsx-a11y/no-aria-hidden-on-focusable` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-aria-hidden-on-focusable/
   */
  'astro/jsx-a11y/no-aria-hidden-on-focusable'?: Linter.RuleEntry<AstroJsxA11YNoAriaHiddenOnFocusable>;
  /**
   * Apply `jsx-a11y/no-autofocus` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-autofocus/
   */
  'astro/jsx-a11y/no-autofocus'?: Linter.RuleEntry<AstroJsxA11YNoAutofocus>;
  /**
   * Apply `jsx-a11y/no-distracting-elements` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-distracting-elements/
   */
  'astro/jsx-a11y/no-distracting-elements'?: Linter.RuleEntry<AstroJsxA11YNoDistractingElements>;
  /**
   * Apply `jsx-a11y/no-interactive-element-to-noninteractive-role` rule to
   * Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-interactive-element-to-noninteractive-role/
   */
  'astro/jsx-a11y/no-interactive-element-to-noninteractive-role'?: Linter.RuleEntry<AstroJsxA11YNoInteractiveElementToNoninteractiveRole>;
  /**
   * Apply `jsx-a11y/no-noninteractive-element-interactions` rule to Astro
   * components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-element-interactions/
   */
  'astro/jsx-a11y/no-noninteractive-element-interactions'?: Linter.RuleEntry<AstroJsxA11YNoNoninteractiveElementInteractions>;
  /**
   * Apply `jsx-a11y/no-noninteractive-element-to-interactive-role` rule to
   * Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-element-to-interactive-role/
   */
  'astro/jsx-a11y/no-noninteractive-element-to-interactive-role'?: Linter.RuleEntry<AstroJsxA11YNoNoninteractiveElementToInteractiveRole>;
  /**
   * Apply `jsx-a11y/no-noninteractive-tabindex` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-noninteractive-tabindex/
   */
  'astro/jsx-a11y/no-noninteractive-tabindex'?: Linter.RuleEntry<AstroJsxA11YNoNoninteractiveTabindex>;
  /**
   * Apply `jsx-a11y/no-redundant-roles` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-redundant-roles/
   */
  'astro/jsx-a11y/no-redundant-roles'?: Linter.RuleEntry<AstroJsxA11YNoRedundantRoles>;
  /**
   * Apply `jsx-a11y/no-static-element-interactions` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/no-static-element-interactions/
   */
  'astro/jsx-a11y/no-static-element-interactions'?: Linter.RuleEntry<AstroJsxA11YNoStaticElementInteractions>;
  /**
   * Apply `jsx-a11y/prefer-tag-over-role` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/prefer-tag-over-role/
   */
  'astro/jsx-a11y/prefer-tag-over-role'?: Linter.RuleEntry<AstroJsxA11YPreferTagOverRole>;
  /**
   * Apply `jsx-a11y/role-has-required-aria-props` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/role-has-required-aria-props/
   */
  'astro/jsx-a11y/role-has-required-aria-props'?: Linter.RuleEntry<AstroJsxA11YRoleHasRequiredAriaProps>;
  /**
   * Apply `jsx-a11y/role-supports-aria-props` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/role-supports-aria-props/
   */
  'astro/jsx-a11y/role-supports-aria-props'?: Linter.RuleEntry<AstroJsxA11YRoleSupportsAriaProps>;
  /**
   * Apply `jsx-a11y/scope` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/scope/
   */
  'astro/jsx-a11y/scope'?: Linter.RuleEntry<AstroJsxA11YScope>;
  /**
   * Apply `jsx-a11y/tabindex-no-positive` rule to Astro components
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/jsx-a11y/tabindex-no-positive/
   */
  'astro/jsx-a11y/tabindex-no-positive'?: Linter.RuleEntry<AstroJsxA11YTabindexNoPositive>;
  /**
   * The client:only directive is missing the correct component's framework
   * value
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/missing-client-only-directive-value/
   */
  'astro/missing-client-only-directive-value'?: Linter.RuleEntry<[]>;
  /**
   * Disallow conflicting set directives and child contents
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-conflict-set-directives/
   */
  'astro/no-conflict-set-directives'?: Linter.RuleEntry<[]>;
  /**
   * Disallow using deprecated `Astro.canonicalURL`
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-canonicalurl/
   */
  'astro/no-deprecated-astro-canonicalurl'?: Linter.RuleEntry<[]>;
  /**
   * Disallow using deprecated `Astro.fetchContent()`
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-fetchcontent/
   */
  'astro/no-deprecated-astro-fetchcontent'?: Linter.RuleEntry<[]>;
  /**
   * Disallow using deprecated `Astro.resolve()`
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-astro-resolve/
   */
  'astro/no-deprecated-astro-resolve'?: Linter.RuleEntry<[]>;
  /**
   * Disallow using deprecated `getEntryBySlug()`
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-deprecated-getentrybyslug/
   */
  'astro/no-deprecated-getentrybyslug'?: Linter.RuleEntry<[]>;
  /**
   * Disallow value export
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-exports-from-components/
   */
  'astro/no-exports-from-components'?: Linter.RuleEntry<[]>;
  /**
   * Disallow `prerender` export outside of pages/ directory
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-prerender-export-outside-pages/
   */
  'astro/no-prerender-export-outside-pages'?: Linter.RuleEntry<[]>;
  /**
   * Disallow use of `set:html` to prevent XSS attack
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-set-html-directive/
   */
  'astro/no-set-html-directive'?: Linter.RuleEntry<[]>;
  /**
   * Disallow use of `set:text`
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-set-text-directive/
   */
  'astro/no-set-text-directive'?: Linter.RuleEntry<[]>;
  /**
   * Disallow inline `<script>` without `src` to encourage CSP-safe patterns
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-unsafe-inline-scripts/
   */
  'astro/no-unsafe-inline-scripts'?: Linter.RuleEntry<AstroNoUnsafeInlineScripts>;
  /**
   * Disallow selectors defined in `style` tag that don't use in HTML
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-unused-css-selector/
   */
  'astro/no-unused-css-selector'?: Linter.RuleEntry<[]>;
  /**
   * Disallow unused `define:vars={...}` in `style` tag
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/no-unused-define-vars-in-style/
   */
  'astro/no-unused-define-vars-in-style'?: Linter.RuleEntry<[]>;
  /**
   * Require `class:list` directives instead of `class` with expressions
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/prefer-class-list-directive/
   */
  'astro/prefer-class-list-directive'?: Linter.RuleEntry<[]>;
  /**
   * Require use object instead of ternary expression in `class:list`
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/prefer-object-class-list/
   */
  'astro/prefer-object-class-list'?: Linter.RuleEntry<[]>;
  /**
   * Require use split array elements in `class:list`
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/prefer-split-class-list/
   */
  'astro/prefer-split-class-list'?: Linter.RuleEntry<AstroPreferSplitClassList>;
  /**
   * Require or disallow semicolons instead of ASI
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/semi/
   */
  'astro/semi'?: Linter.RuleEntry<AstroSemi>;
  /**
   * Enforce sorting of attributes
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/sort-attributes/
   */
  'astro/sort-attributes'?: Linter.RuleEntry<AstroSortAttributes>;
  /**
   * Disallow warnings when compiling.
   *
   * @see https://ota-meshi.github.io/eslint-plugin-astro/rules/valid-compile/
   */
  'astro/valid-compile'?: Linter.RuleEntry<[]>;
  /**
   * 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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/block-spacing
   */
  'block-spacing'?: Linter.RuleEntry<BlockSpacing>;
  /**
   * Enforce consistent brace style for blocks
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/brace-style
   */
  'brace-style'?: Linter.RuleEntry<BraceStyle>;
  /**
   * Require `return` statements after callbacks
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/callback-return
   */
  '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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/comma-dangle
   */
  'comma-dangle'?: Linter.RuleEntry<CommaDangle>;
  /**
   * Enforce consistent spacing before and after commas
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/comma-spacing
   */
  'comma-spacing'?: Linter.RuleEntry<CommaSpacing>;
  /**
   * Enforce consistent comma style
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/comma-style
   */
  '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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/computed-property-spacing
   */
  '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>;
  /**
   * Transforms the negation of a conjunction !(A && B) into the equivalent !A
   *
   * || !B according to De Morgan’s law
   *
   * @see https://github.com/azat-io/eslint-plugin-de-morgan/blob/main/docs/no-negated-conjunction.md
   */
  'de-morgan/no-negated-conjunction'?: Linter.RuleEntry<[]>;
  /**
   * Transforms the negation of a disjunction !(A || B) into the equivalent !A
   * && !B according to De Morgan’s law
   *
   * @see https://github.com/azat-io/eslint-plugin-de-morgan/blob/main/docs/no-negated-disjunction.md
   */
  'de-morgan/no-negated-disjunction'?: Linter.RuleEntry<[]>;
  /**
   * 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<[]>;
  /**
   * Bans a list of dependencies from being used
   *
   * @see https://github.com/es-tooling/eslint-plugin-depend/blob/main/docs/rules/ban-dependencies.md
   */
  'depend/ban-dependencies'?: Linter.RuleEntry<DependBanDependencies>;
  /**
   * Enforce consistent newlines before and after dots
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/dot-location
   */
  'dot-location'?: Linter.RuleEntry<DotLocation>;
  /**
   * Enforce dot notation whenever possible
   *
   * @see https://eslint.org/docs/latest/rules/dot-notation
   */
  'dot-notation'?: Linter.RuleEntry<DotNotation>;
  /**
   * Disallow dependencies in favor of more performant or secure alternatives
   */
  'e18e/ban-dependencies'?: Linter.RuleEntry<E18EBanDependencies>;
  /**
   * Disallow `delete` on properties — V8 deoptimizes the object to dictionary
   * mode
   */
  'e18e/no-delete-property'?: Linter.RuleEntry<[]>;
  /**
   * Prefer optimized alternatives to `indexOf()` equality checks
   */
  'e18e/no-indexof-equality'?: Linter.RuleEntry<[]>;
  /**
   * Disallow spreading the accumulator inside a `reduce` callback (O(N²)
   * growth)
   */
  'e18e/no-spread-in-reduce'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Array.prototype.at() over length-based indexing
   */
  'e18e/prefer-array-at'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Array.prototype.fill() over Array.from or map with constant values
   */
  'e18e/prefer-array-fill'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Array.from(iterable, mapper) over [...iterable].map(mapper) to avoid
   * intermediate array allocation
   */
  'e18e/prefer-array-from-map'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Array.some() over Array.find() and Array.filter().length checks when
   * checking for element existence
   */
  'e18e/prefer-array-some'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Array.prototype.toReversed() over copying and reversing arrays
   */
  'e18e/prefer-array-to-reversed'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Array.prototype.toSorted() over copying and sorting arrays
   */
  'e18e/prefer-array-to-sorted'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Array.prototype.toSpliced() over copying and splicing arrays
   */
  'e18e/prefer-array-to-spliced'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Date.now() over new Date().getTime() and +new Date()
   */
  'e18e/prefer-date-now'?: Linter.RuleEntry<[]>;
  /**
   * Prefer the exponentiation operator ** over Math.pow()
   */
  'e18e/prefer-exponentiation-operator'?: Linter.RuleEntry<[]>;
  /**
   * Prefer .includes() over indexOf() comparisons for arrays and strings
   */
  'e18e/prefer-includes'?: Linter.RuleEntry<[]>;
  /**
   * Prefer String.prototype.{includes,startsWith,endsWith} over equivalent
   * regex.test() calls
   */
  'e18e/prefer-includes-over-regex-test'?: Linter.RuleEntry<[]>;
  /**
   * Prefer inline equality checks over temporary object creation for simple
   * comparisons
   */
  'e18e/prefer-inline-equality'?: Linter.RuleEntry<[]>;
  /**
   * Prefer nullish coalescing operator (?? and ??=) over verbose null checks
   */
  'e18e/prefer-nullish-coalescing'?: Linter.RuleEntry<[]>;
  /**
   * Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() and
   * obj.hasOwnProperty()
   */
  'e18e/prefer-object-has-own'?: Linter.RuleEntry<[]>;
  /**
   * Prefer `RegExp.test()` over `String.match()` and `RegExp.exec()` when only
   * checking for match existence
   */
  'e18e/prefer-regex-test'?: Linter.RuleEntry<[]>;
  /**
   * Prefer spread syntax over Array.concat(), Array.from(), Object.assign({},
   * ...), and Function.apply()
   */
  'e18e/prefer-spread-syntax'?: Linter.RuleEntry<[]>;
  /**
   * Prefer hoisting an `Intl.Collator` instance over calling localeCompare in a
   * sort callback
   */
  'e18e/prefer-static-collator'?: Linter.RuleEntry<[]>;
  /**
   * Prefer defining regular expressions at module scope to avoid re-compilation
   * on every function call
   */
  'e18e/prefer-static-regex'?: Linter.RuleEntry<[]>;
  /**
   * Prefer String.fromCharCode() over String.fromCodePoint() for code points
   * below 0x10000
   */
  'e18e/prefer-string-fromcharcode'?: Linter.RuleEntry<[]>;
  /**
   * Prefer passing function and arguments directly to setTimeout/setInterval
   * instead of wrapping in an arrow function or using bind
   */
  'e18e/prefer-timer-args'?: Linter.RuleEntry<[]>;
  /**
   * Prefer URL.canParse() over try-catch blocks for URL validation
   */
  'e18e/prefer-url-canparse'?: Linter.RuleEntry<[]>;
  /**
   * Require or disallow newline at the end of files
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/eol-last
   */
  'eol-last'?: Linter.RuleEntry<EolLast>;
  /**
   * Require the use of `===` and `!==`
   *
   * @see https://eslint.org/docs/latest/rules/eqeqeq
   */
  eqeqeq?: Linter.RuleEntry<Eqeqeq>;
  /**
   * Require a `eslint-enable` comment for every `eslint-disable` comment
   *
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/disable-enable-pair.html
   */
  'eslint-comments/disable-enable-pair'?: Linter.RuleEntry<EslintCommentsDisableEnablePair>;
  /**
   * Disallow a `eslint-enable` comment for multiple `eslint-disable` comments
   *
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-aggregating-enable.html
   */
  'eslint-comments/no-aggregating-enable'?: Linter.RuleEntry<[]>;
  /**
   * Disallow duplicate `eslint-disable` comments
   *
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-duplicate-disable.html
   */
  'eslint-comments/no-duplicate-disable'?: Linter.RuleEntry<[]>;
  /**
   * Disallow `eslint-disable` comments about specific rules
   *
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-restricted-disable.html
   */
  'eslint-comments/no-restricted-disable'?: Linter.RuleEntry<EslintCommentsNoRestrictedDisable>;
  /**
   * Disallow `eslint-disable` comments without rule names
   *
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-unlimited-disable.html
   */
  'eslint-comments/no-unlimited-disable'?: Linter.RuleEntry<[]>;
  /**
   * Disallow unused `eslint-disable` comments
   *
   * @deprecated
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-unused-disable.html
   */
  'eslint-comments/no-unused-disable'?: Linter.RuleEntry<[]>;
  /**
   * Disallow unused `eslint-enable` comments
   *
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-unused-enable.html
   */
  'eslint-comments/no-unused-enable'?: Linter.RuleEntry<[]>;
  /**
   * Disallow ESLint directive-comments
   *
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/no-use.html
   */
  'eslint-comments/no-use'?: Linter.RuleEntry<EslintCommentsNoUse>;
  /**
   * Require include descriptions in ESLint directive-comments
   *
   * @see https://eslint-community.github.io/eslint-plugin-eslint-comments/rules/require-description.html
   */
  'eslint-comments/require-description'?: Linter.RuleEntry<EslintCommentsRequireDescription>;
  /**
   * 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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/func-call-spacing
   */
  '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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/function-call-argument-newline
   */
  'function-call-argument-newline'?: Linter.RuleEntry<FunctionCallArgumentNewline>;
  /**
   * Enforce consistent line breaks inside function parentheses
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/function-paren-newline
   */
  'function-paren-newline'?: Linter.RuleEntry<FunctionParenNewline>;
  /**
   * Enforce consistent spacing around `*` operators in generator functions
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/generator-star-spacing
   */
  '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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/global-require
   */
  '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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/handle-callback-err
   */
  'handle-callback-err'?: Linter.RuleEntry<HandleCallbackErr>;
  /**
   * Enforce newline between attributes
   *
   * @see https://html-eslint.org/docs/rules/attrs-newline
   */
  'html/attrs-newline'?: Linter.RuleEntry<HtmlAttrsNewline>;
  /**
   * Disallow extra spacing in class attribute values
   *
   * @see https://html-eslint.org/docs/rules/class-spacing
   */
  'html/class-spacing'?: Linter.RuleEntry<[]>;
  /**
   * Disallows empty CSS blocks in `<style>` tags.
   */
  'html/css-no-empty-blocks'?: Linter.RuleEntry<[]>;
  /**
   * Enforce newline between elements.
   *
   * @see https://html-eslint.org/docs/rules/element-newline
   */
  'html/element-newline'?: Linter.RuleEntry<HtmlElementNewline>;
  /**
   * Enforce optimal ordering of elements in `<head>`
   *
   * @see https://html-eslint.org/docs/rules/head-order
   */
  'html/head-order'?: Linter.RuleEntry<HtmlHeadOrder>;
  /**
   * Enforce consistent naming of id attributes
   *
   * @see https://html-eslint.org/docs/rules/id-naming-convention
   */
  'html/id-naming-convention'?: Linter.RuleEntry<HtmlIdNamingConvention>;
  /**
   * Enforce consistent indentation
   */
  'html/indent'?: Linter.RuleEntry<HtmlIndent>;
  /**
   * Enforce use of lowercase for tag and attribute names.
   *
   * @see https://html-eslint.org/docs/rules/lowercase
   */
  'html/lowercase'?: Linter.RuleEntry<[]>;
  /**
   * Enforce maximum element depth
   *
   * @see https://html-eslint.org/docs/rules/max-element-depth
   */
  'html/max-element-depth'?: Linter.RuleEntry<HtmlMaxElementDepth>;
  /**
   * Disallow use of abstract roles
   *
   * @see https://html-eslint.org/docs/rules/no-abstract-roles
   */
  'html/no-abstract-roles'?: Linter.RuleEntry<[]>;
  /**
   * Disallow use of accesskey attribute
   *
   * @see https://html-eslint.org/docs/rules/no-accesskey-attrs
   */
  'html/no-accesskey-attrs'?: Linter.RuleEntry<[]>;
  /**
   * Disallow use of aria-hidden attributes on the `body` element.
   *
   * @see https://html-eslint.org/docs/rules/no-aria-hidden-body
   */
  'html/no-aria-hidden-body'?: Linter.RuleEntry<[]>;
  /**
   * Disallow aria-hidden="true" on focusable elements
   *
   * @see https://html-eslint.org/docs/rules/no-aria-hidden-on-focusable
   */
  'html/no-aria-hidden-on-focusable'?: Linter.RuleEntry<[]>;
  /**
   * Disallow duplicate attributes
   *
   * @see https://html-eslint.org/docs/rules/no-duplicate-attrs
   */
  'html/no-duplicate-attrs'?: Linter.RuleEntry<[]>;
  /**
   * Disallow duplicate class names
   *
   * @see https://html-eslint.org/docs/rules/no-duplicate-class
   */
  'html/no-duplicate-class'?: Linter.RuleEntry<[]>;
  /**
   * Disallow duplicate id attributes
   *
   * @see https://html-eslint.org/docs/rules/no-duplicate-id
   */
  'html/no-duplicate-id'?: Linter.RuleEntry<[]>;
  /**
   * Disallow duplicate tags in `<head>`
   *
   * @see https://html-eslint.org/docs/rules/no-duplicate-in-head
   */
  'html/no-duplicate-in-head'?: Linter.RuleEntry<[]>;
  /**
   * Disallow empty or inaccessible headings.
   *
   * @see https://html-eslint.org/docs/rules/no-empty-headings
   */
  'html/no-empty-headings'?: Linter.RuleEntry<[]>;
  /**
   * Disallow extra spacing around attributes
   *
   * @deprecated
   * @see https://html-eslint.org/docs/rules/no-extra-spacing-attrs
   */
  'html/no-extra-spacing-attrs'?: Linter.RuleEntry<HtmlNoExtraSpacingAttrs>;
  /**
   * Disallow extra spacing inside tags
   *
   * @see https://html-eslint.org/docs/rules/no-extra-spacing-tags
   */
  'html/no-extra-spacing-tags'?: Linter.RuleEntry<HtmlNoExtraSpacingTags>;
  /**
   * Disallow unnecessary consecutive spaces
   *
   * @see https://html-eslint.org/docs/rules/no-extra-spacing-text
   */
  'html/no-extra-spacing-text'?: Linter.RuleEntry<HtmlNoExtraSpacingText>;
  /**
   * Disallows the use of heading elements inside <button>.
   *
   * @see https://html-eslint.org/docs/rules/no-heading-inside-button
   */
  'html/no-heading-inside-button'?: Linter.RuleEntry<[]>;
  /**
   * Disallow HTML attributes that have no effect in their context
   *
   * @see https://html-eslint.org/docs/rules/no-ineffective-attrs
   */
  'html/no-ineffective-attrs'?: Linter.RuleEntry<[]>;
  /**
   * Disallow using inline style
   *
   * @see https://html-eslint.org/docs/rules/no-inline-styles
   */
  'html/no-inline-styles'?: Linter.RuleEntry<[]>;
  /**
   * Disallow invalid attribute values according to HTML standards
   *
   * @see https://html-eslint.org/docs/rules/no-invalid-attr-value
   */
  'html/no-invalid-attr-value'?: Linter.RuleEntry<HtmlNoInvalidAttrValue>;
  /**
   * Disallows the use of invalid HTML entities
   *
   * @see https://html-eslint.org/docs/rules/no-invalid-entity
   */
  'html/no-invalid-entity'?: Linter.RuleEntry<[]>;
  /**
   * Disallows use of invalid role.
   *
   * @see https://html-eslint.org/docs/rules/no-invalid-role
   */
  'html/no-invalid-role'?: Linter.RuleEntry<[]>;
  /**
   * Disallow multiple empty lines
   *
   * @see https://html-eslint.org/docs/rules/no-multiple-empty-lines
   */
  'html/no-multiple-empty-lines'?: Linter.RuleEntry<HtmlNoMultipleEmptyLines>;
  /**
   * Disallow multiple `<h1></h1>`.
   *
   * @see https://html-eslint.org/docs/rules/no-multiple-h1
   */
  'html/no-multiple-h1'?: Linter.RuleEntry<[]>;
  /**
   * Disallows nested interactive elements
   *
   * @see https://html-eslint.org/docs/rules/no-nested-interactive
   */
  'html/no-nested-interactive'?: Linter.RuleEntry<[]>;
  /**
   * Disallow use of `user-scalable=no` in `<meta name="viewport">`.
   *
   * @see https://html-eslint.org/docs/rules/no-non-scalable-viewport
   */
  'html/no-non-scalable-viewport'?: Linter.RuleEntry<[]>;
  /**
   * Disallow use of obsolete attributes in HTML5
   *
   * @see https://html-eslint.org/docs/rules/no-obsolete-attrs
   */
  'html/no-obsolete-attrs'?: Linter.RuleEntry<[]>;
  /**
   * Disallow use of obsolete elements in HTML5
   *
   * @see https://html-eslint.org/docs/rules/no-obsolete-tags
   */
  'html/no-obsolete-tags'?: Linter.RuleEntry<[]>;
  /**
   * Disallow use of positive `tabindex`.
   *
   * @see https://html-eslint.org/docs/rules/no-positive-tabindex
   */
  'html/no-positive-tabindex'?: Linter.RuleEntry<[]>;
  /**
   * Disallow redundant role attributes that match the element's implicit role
   *
   * @see https://html-eslint.org/docs/rules/no-redundant-role
   */
  'html/no-redundant-role'?: Linter.RuleEntry<[]>;
  /**
   * Disallow specified attributes
   *
   * @see https://html-eslint.org/docs/rules/no-restricted-attr-values
   */
  'html/no-restricted-attr-values'?: Linter.RuleEntry<HtmlNoRestrictedAttrValues>;
  /**
   * Disallow specified attributes
   *
   * @see https://html-eslint.org/docs/rules/no-restricted-attrs
   */
  'html/no-restricted-attrs'?: Linter.RuleEntry<HtmlNoRestrictedAttrs>;
  /**
   * Disallow specified tags
   *
   * @see https://html-eslint.org/docs/rules/no-restricted-tags
   */
  'html/no-restricted-tags'?: Linter.RuleEntry<HtmlNoRestrictedTags>;
  /**
   * Enforce to omit type attributes for style sheets and scripts
   *
   * @see https://html-eslint.org/docs/rules/no-script-style-type
   */
  'html/no-script-style-type'?: Linter.RuleEntry<[]>;
  /**
   * Disallow skipping heading levels
   *
   * @see https://html-eslint.org/docs/rules/no-skip-heading-levels
   */
  'html/no-skip-heading-levels'?: Linter.RuleEntry<[]>;
  /**
   * Disallow usage of unsafe `target='_blank'`
   *
   * @see https://html-eslint.org/docs/rules/no-target-blank
   */
  'html/no-target-blank'?: Linter.RuleEntry<[]>;
  /**
   * Disallow trailing whitespace at the end of lines
   *
   * @see https://html-eslint.org/docs/rules/no-trailing-spaces
   */
  'html/no-trailing-spaces'?: Linter.RuleEntry<[]>;
  /**
   * Disallow tags with only whitespace children.
   *
   * @see https://html-eslint.org/docs/rules/no-whitespace-only-children
   */
  'html/no-whitespace-only-children'?: Linter.RuleEntry<HtmlNoWhitespaceOnlyChildren>;
  /**
   * Prefer to use HTTPS for embedded resources
   *
   * @see https://html-eslint.org/docs/rules/prefer-https
   */
  'html/prefer-https'?: Linter.RuleEntry<[]>;
  /**
   * Enforce consistent quoting attributes with double(") or single(')
   *
   * @see https://html-eslint.org/docs/rules/quotes
   */
  'html/quotes'?: Linter.RuleEntry<HtmlQuotes>;
  /**
   * Require specified attributes
   *
   * @see https://html-eslint.org/docs/rules/require-attrs
   */
  'html/require-attrs'?: Linter.RuleEntry<HtmlRequireAttrs>;
  /**
   * Require use of the button element with a valid type attribute.
   *
   * @see https://html-eslint.org/docs/rules/require-button-type
   */
  'html/require-button-type'?: Linter.RuleEntry<[]>;
  /**
   * Require closing tags.
   *
   * @see https://html-eslint.org/docs/rules/require-closing-tags
   */
  'html/require-closing-tags'?: Linter.RuleEntry<HtmlRequireClosingTags>;
  /**
   * Require that certain elements have meaningful content.
   *
   * @see https://html-eslint.org/docs/rules/require-content
   */
  'html/require-content'?: Linter.RuleEntry<[]>;
  /**
   * Require `<details>` elements to have a `<summary>` as their first child
   * element.
   *
   * @see https://html-eslint.org/docs/rules/require-details-summary
   */
  'html/require-details-summary'?: Linter.RuleEntry<[]>;
  /**
   * Require `<!DOCTYPE HTML>` in HTML
   *
   * @see https://html-eslint.org/docs/rules/require-doctype
   */
  'html/require-doctype'?: Linter.RuleEntry<[]>;
  /**
   * Enforces that some elements (img, iframe) have explicitly defined width and
   * height attributes.
   *
   * @see https://html-eslint.org/docs/rules/require-explicit-size
   */
  'html/require-explicit-size'?: Linter.RuleEntry<HtmlRequireExplicitSize>;
  /**
   * Require `method` attribute in `<form>`
   *
   * @see https://html-eslint.org/docs/rules/require-form-method
   */
  'html/require-form-method'?: Linter.RuleEntry<[]>;
  /**
   * Require `title` in `<frame>`, `<iframe>`
   *
   * @see https://html-eslint.org/docs/rules/require-frame-title
   */
  'html/require-frame-title'?: Linter.RuleEntry<[]>;
  /**
   * Require `alt` attribute on `<img>` tag
   *
   * @see https://html-eslint.org/docs/rules/require-img-alt
   */
  'html/require-img-alt'?: Linter.RuleEntry<HtmlRequireImgAlt>;
  /**
   * Enforces use of label for form elements(`input`, `textarea`, `select`)
   *
   * @see https://html-eslint.org/docs/rules/require-input-label
   */
  'html/require-input-label'?: Linter.RuleEntry<[]>;
  /**
   * Require `lang` attribute on `<html>` tag
   *
   * @see https://html-eslint.org/docs/rules/require-lang
   */
  'html/require-lang'?: Linter.RuleEntry<[]>;
  /**
   * Enforce `<li>` to be in `<ul>`, `<ol>` or `<menu>`.
   *
   * @see https://html-eslint.org/docs/rules/require-li-container
   */
  'html/require-li-container'?: Linter.RuleEntry<[]>;
  /**
   * Enforce use of `<meta charset="...">` in `<head>`
   *
   * @see https://html-eslint.org/docs/rules/require-meta-charset
   */
  'html/require-meta-charset'?: Linter.RuleEntry<[]>;
  /**
   * Require use of `<meta name="description">` in `<head>`
   *
   * @see https://html-eslint.org/docs/rules/require-meta-description
   */
  'html/require-meta-description'?: Linter.RuleEntry<[]>;
  /**
   * Enforce use of `<meta name="viewport">` in `<head>`
   *
   * @see https://html-eslint.org/docs/rules/require-meta-viewport
   */
  'html/require-meta-viewport'?: Linter.RuleEntry<[]>;
  /**
   * Enforce use of specified meta tags for open graph protocol.
   *
   * @see https://html-eslint.org/docs/rules/require-open-graph-protocol
   */
  'html/require-open-graph-protocol'?: Linter.RuleEntry<HtmlRequireOpenGraphProtocol>;
  /**
   * Require `<title>` in the `<head>`
   *
   * @see https://html-eslint.org/docs/rules/require-title
   */
  'html/require-title'?: Linter.RuleEntry<[]>;
  /**
   * Enforce priority and alphabetical sorting of attributes
   *
   * @see https://html-eslint.org/docs/rules/sort-attrs
   */
  'html/sort-attrs'?: Linter.RuleEntry<HtmlSortAttrs>;
  /**
   * Require `viewBox` attribute on `<svg>` elements
   *
   * @see https://html-eslint.org/docs/rules/svg-require-viewbox
   */
  'html/svg-require-viewbox'?: Linter.RuleEntry<[]>;
  /**
   * Enforce the use of baseline features.
   *
   * @see https://html-eslint.org/docs/rules/use-baseline
   */
  'html/use-baseline'?: Linter.RuleEntry<HtmlUseBaseline>;
  /**
   * Disallow specified identifiers
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/id-blacklist
   */
  '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
   *
   * @deprecated
   * @see https://eslint.org/docs/latest/rules/implicit-arrow-linebreak
   */
  'implicit-arrow-linebreak'?: Linter.RuleEntry<ImplicitArrowLinebreak>;
  /**
   * Enforce or ban the use of inline type-only markers for named imports.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/consistent-type-specifier-style.md
   */
  'import/consistent-type-specifier-style'?: Linter.RuleEntry<ImportConsistentTypeSpecifierStyle>;
  /**
   * Ensure a default export is present, given a default import.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/default.md
   */
  'import/default'?: Linter.RuleEntry<[]>;
  /**
   * Enforce a leading comment with the webpackChunkName for dynamic imports.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/dynamic-import-chunkname.md
   */
  'import/dynamic-import-chunkname'?: Linter.RuleEntry<ImportDynamicImportChunkname>;
  /**
   * Forbid any invalid exports, i.e. re-export of the same name.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/export.md
   */
  'import/export'?: Linter.RuleEntry<[]>;
  /**
   * Ensure all exports appear after other statements.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/exports-last.md
   */
  'import/exports-last'?: Linter.RuleEntry<[]>;
  /**
   * Ensure consistent use of file extension within the import path.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/extensions.md
   */
  'import/extensions'?: Linter.RuleEntry<ImportExtensions>;
  /**
   * Ensure all imports appear before other statements.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/first.md
   */
  'import/first'?: Linter.RuleEntry<ImportFirst>;
  /**
   * Prefer named exports to be grouped together in a single export declaration.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/group-exports.md
   */
  'import/group-exports'?: Linter.RuleEntry<[]>;
  /**
   * Replaced by `import-x/first`.
   *
   * @deprecated
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/imports-first.md
   */
  'import/imports-first'?: Linter.RuleEntry<ImportImportsFirst>;
  /**
   * Enforce the maximum number of dependencies a module can have.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/max-dependencies.md
   */
  'import/max-dependencies'?: Linter.RuleEntry<ImportMaxDependencies>;
  /**
   * Ensure named imports correspond to a named export in the remote file.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/named.md
   */
  'import/named'?: Linter.RuleEntry<ImportNamed>;
  /**
   * Ensure imported namespaces contain dereferenced properties as they are
   * dereferenced.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/namespace.md
   */
  'import/namespace'?: Linter.RuleEntry<ImportNamespace>;
  /**
   * Enforce a newline after import statements.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/newline-after-import.md
   */
  'import/newline-after-import'?: Linter.RuleEntry<ImportNewlineAfterImport>;
  /**
   * Forbid import of modules using absolute paths.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-absolute-path.md
   */
  'import/no-absolute-path'?: Linter.RuleEntry<ImportNoAbsolutePath>;
  /**
   * Forbid AMD `require` and `define` calls.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-amd.md
   */
  'import/no-amd'?: Linter.RuleEntry<[]>;
  /**
   * Forbid anonymous values as default exports.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-anonymous-default-export.md
   */
  'import/no-anonymous-default-export'?: Linter.RuleEntry<ImportNoAnonymousDefaultExport>;
  /**
   * Forbid CommonJS `require` calls and `module.exports` or `exports.*`.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-commonjs.md
   */
  'import/no-commonjs'?: Linter.RuleEntry<ImportNoCommonjs>;
  /**
   * Forbid a module from importing a module with a dependency path back to
   * itself.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-cycle.md
   */
  'import/no-cycle'?: Linter.RuleEntry<ImportNoCycle>;
  /**
   * Forbid default exports.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-default-export.md
   */
  'import/no-default-export'?: Linter.RuleEntry<[]>;
  /**
   * Forbid imported names marked with `@deprecated` documentation tag.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-deprecated.md
   */
  'import/no-deprecated'?: Linter.RuleEntry<[]>;
  /**
   * Forbid repeated import of the same module in multiple places.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-duplicates.md
   */
  'import/no-duplicates'?: Linter.RuleEntry<ImportNoDuplicates>;
  /**
   * Forbid `require()` calls with expressions.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-dynamic-require.md
   */
  'import/no-dynamic-require'?: Linter.RuleEntry<ImportNoDynamicRequire>;
  /**
   * Forbid empty named import blocks.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-empty-named-blocks.md
   */
  'import/no-empty-named-blocks'?: Linter.RuleEntry<[]>;
  /**
   * Forbid the use of extraneous packages.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-extraneous-dependencies.md
   */
  'import/no-extraneous-dependencies'?: Linter.RuleEntry<ImportNoExtraneousDependencies>;
  /**
   * Forbid import statements with CommonJS module.exports.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.2/docs/rules/no-import-module-exports.md
   */
  'import/no-import-module-exports'?: Linter.RuleEntry<ImportNoImportModuleExports>;
  /**
   * Forbid importing the submodules of other modules.
   *
   * @see https://github.com/un-ts/eslint-plugin-import-x