@kazupon/eslint-config 0.8.0 → 0.9.1

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

@@ -0,0 +1,2465 @@
+import type { Linter } from 'eslint';
+export interface VueRules {
+    /**
+     * Enforce linebreaks after opening and before closing array brackets in `<template>`
+     * @see https://eslint.vuejs.org/rules/array-bracket-newline.html
+     */
+    'vue/array-bracket-newline'?: Linter.RuleEntry<VueArrayBracketNewline>;
+    /**
+     * Enforce consistent spacing inside array brackets in `<template>`
+     * @see https://eslint.vuejs.org/rules/array-bracket-spacing.html
+     */
+    'vue/array-bracket-spacing'?: Linter.RuleEntry<VueArrayBracketSpacing>;
+    /**
+     * Enforce line breaks after each array element in `<template>`
+     * @see https://eslint.vuejs.org/rules/array-element-newline.html
+     */
+    'vue/array-element-newline'?: Linter.RuleEntry<VueArrayElementNewline>;
+    /**
+     * Enforce consistent spacing before and after the arrow in arrow functions in `<template>`
+     * @see https://eslint.vuejs.org/rules/arrow-spacing.html
+     */
+    'vue/arrow-spacing'?: Linter.RuleEntry<VueArrowSpacing>;
+    /**
+     * enforce attribute naming style on custom components in template
+     * @see https://eslint.vuejs.org/rules/attribute-hyphenation.html
+     */
+    'vue/attribute-hyphenation'?: Linter.RuleEntry<VueAttributeHyphenation>;
+    /**
+     * enforce order of attributes
+     * @see https://eslint.vuejs.org/rules/attributes-order.html
+     */
+    'vue/attributes-order'?: Linter.RuleEntry<VueAttributesOrder>;
+    /**
+     * disallow use other than available `lang`
+     * @see https://eslint.vuejs.org/rules/block-lang.html
+     */
+    'vue/block-lang'?: Linter.RuleEntry<VueBlockLang>;
+    /**
+     * enforce order of component top-level elements
+     * @see https://eslint.vuejs.org/rules/block-order.html
+     */
+    'vue/block-order'?: Linter.RuleEntry<VueBlockOrder>;
+    /**
+     * Disallow or enforce spaces inside of blocks after opening block and before closing block in `<template>`
+     * @see https://eslint.vuejs.org/rules/block-spacing.html
+     */
+    'vue/block-spacing'?: Linter.RuleEntry<VueBlockSpacing>;
+    /**
+     * enforce line breaks after opening and before closing block-level tags
+     * @see https://eslint.vuejs.org/rules/block-tag-newline.html
+     */
+    'vue/block-tag-newline'?: Linter.RuleEntry<VueBlockTagNewline>;
+    /**
+     * Enforce consistent brace style for blocks in `<template>`
+     * @see https://eslint.vuejs.org/rules/brace-style.html
+     */
+    'vue/brace-style'?: Linter.RuleEntry<VueBraceStyle>;
+    /**
+     * Enforce camelcase naming convention in `<template>`
+     * @see https://eslint.vuejs.org/rules/camelcase.html
+     */
+    'vue/camelcase'?: Linter.RuleEntry<VueCamelcase>;
+    /**
+     * Require or disallow trailing commas in `<template>`
+     * @see https://eslint.vuejs.org/rules/comma-dangle.html
+     */
+    'vue/comma-dangle'?: Linter.RuleEntry<VueCommaDangle>;
+    /**
+     * Enforce consistent spacing before and after commas in `<template>`
+     * @see https://eslint.vuejs.org/rules/comma-spacing.html
+     */
+    'vue/comma-spacing'?: Linter.RuleEntry<VueCommaSpacing>;
+    /**
+     * Enforce consistent comma style in `<template>`
+     * @see https://eslint.vuejs.org/rules/comma-style.html
+     */
+    'vue/comma-style'?: Linter.RuleEntry<VueCommaStyle>;
+    /**
+     * support comment-directives in `<template>`
+     * @see https://eslint.vuejs.org/rules/comment-directive.html
+     */
+    'vue/comment-directive'?: Linter.RuleEntry<VueCommentDirective>;
+    /**
+     * enforce component API style
+     * @see https://eslint.vuejs.org/rules/component-api-style.html
+     */
+    'vue/component-api-style'?: Linter.RuleEntry<VueComponentApiStyle>;
+    /**
+     * enforce specific casing for component definition name
+     * @see https://eslint.vuejs.org/rules/component-definition-name-casing.html
+     */
+    'vue/component-definition-name-casing'?: Linter.RuleEntry<VueComponentDefinitionNameCasing>;
+    /**
+     * enforce specific casing for the component naming style in template
+     * @see https://eslint.vuejs.org/rules/component-name-in-template-casing.html
+     */
+    'vue/component-name-in-template-casing'?: Linter.RuleEntry<VueComponentNameInTemplateCasing>;
+    /**
+     * enforce the casing of component name in `components` options
+     * @see https://eslint.vuejs.org/rules/component-options-name-casing.html
+     */
+    'vue/component-options-name-casing'?: Linter.RuleEntry<VueComponentOptionsNameCasing>;
+    /**
+     * enforce order of component top-level elements
+     * @see https://eslint.vuejs.org/rules/component-tags-order.html
+     * @deprecated
+     */
+    'vue/component-tags-order'?: Linter.RuleEntry<VueComponentTagsOrder>;
+    /**
+     * enforce specific casing for custom event name
+     * @see https://eslint.vuejs.org/rules/custom-event-name-casing.html
+     */
+    'vue/custom-event-name-casing'?: Linter.RuleEntry<VueCustomEventNameCasing>;
+    /**
+     * enforce declaration style of `defineEmits`
+     * @see https://eslint.vuejs.org/rules/define-emits-declaration.html
+     */
+    'vue/define-emits-declaration'?: Linter.RuleEntry<VueDefineEmitsDeclaration>;
+    /**
+     * enforce order of `defineEmits` and `defineProps` compiler macros
+     * @see https://eslint.vuejs.org/rules/define-macros-order.html
+     */
+    'vue/define-macros-order'?: Linter.RuleEntry<VueDefineMacrosOrder>;
+    /**
+     * enforce declaration style of `defineProps`
+     * @see https://eslint.vuejs.org/rules/define-props-declaration.html
+     */
+    'vue/define-props-declaration'?: Linter.RuleEntry<VueDefinePropsDeclaration>;
+    /**
+     * Enforce consistent newlines before and after dots in `<template>`
+     * @see https://eslint.vuejs.org/rules/dot-location.html
+     */
+    'vue/dot-location'?: Linter.RuleEntry<VueDotLocation>;
+    /**
+     * Enforce dot notation whenever possible in `<template>`
+     * @see https://eslint.vuejs.org/rules/dot-notation.html
+     */
+    'vue/dot-notation'?: Linter.RuleEntry<VueDotNotation>;
+    /**
+     * enforce or forbid the use of the `scoped` and `module` attributes in SFC top level style tags
+     * @see https://eslint.vuejs.org/rules/enforce-style-attribute.html
+     */
+    'vue/enforce-style-attribute'?: Linter.RuleEntry<VueEnforceStyleAttribute>;
+    /**
+     * Require the use of `===` and `!==` in `<template>`
+     * @see https://eslint.vuejs.org/rules/eqeqeq.html
+     */
+    'vue/eqeqeq'?: Linter.RuleEntry<VueEqeqeq>;
+    /**
+     * enforce the location of first attribute
+     * @see https://eslint.vuejs.org/rules/first-attribute-linebreak.html
+     */
+    'vue/first-attribute-linebreak'?: Linter.RuleEntry<VueFirstAttributeLinebreak>;
+    /**
+     * Require or disallow spacing between function identifiers and their invocations in `<template>`
+     * @see https://eslint.vuejs.org/rules/func-call-spacing.html
+     */
+    'vue/func-call-spacing'?: Linter.RuleEntry<VueFuncCallSpacing>;
+    /**
+     * disallow usage of button without an explicit type attribute
+     * @see https://eslint.vuejs.org/rules/html-button-has-type.html
+     */
+    'vue/html-button-has-type'?: Linter.RuleEntry<VueHtmlButtonHasType>;
+    /**
+     * require or disallow a line break before tag's closing brackets
+     * @see https://eslint.vuejs.org/rules/html-closing-bracket-newline.html
+     */
+    'vue/html-closing-bracket-newline'?: Linter.RuleEntry<VueHtmlClosingBracketNewline>;
+    /**
+     * require or disallow a space before tag's closing brackets
+     * @see https://eslint.vuejs.org/rules/html-closing-bracket-spacing.html
+     */
+    'vue/html-closing-bracket-spacing'?: Linter.RuleEntry<VueHtmlClosingBracketSpacing>;
+    /**
+     * enforce unified line brake in HTML comments
+     * @see https://eslint.vuejs.org/rules/html-comment-content-newline.html
+     */
+    'vue/html-comment-content-newline'?: Linter.RuleEntry<VueHtmlCommentContentNewline>;
+    /**
+     * enforce unified spacing in HTML comments
+     * @see https://eslint.vuejs.org/rules/html-comment-content-spacing.html
+     */
+    'vue/html-comment-content-spacing'?: Linter.RuleEntry<VueHtmlCommentContentSpacing>;
+    /**
+     * enforce consistent indentation in HTML comments
+     * @see https://eslint.vuejs.org/rules/html-comment-indent.html
+     */
+    'vue/html-comment-indent'?: Linter.RuleEntry<VueHtmlCommentIndent>;
+    /**
+     * enforce end tag style
+     * @see https://eslint.vuejs.org/rules/html-end-tags.html
+     */
+    'vue/html-end-tags'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce consistent indentation in `<template>`
+     * @see https://eslint.vuejs.org/rules/html-indent.html
+     */
+    'vue/html-indent'?: Linter.RuleEntry<VueHtmlIndent>;
+    /**
+     * enforce quotes style of HTML attributes
+     * @see https://eslint.vuejs.org/rules/html-quotes.html
+     */
+    'vue/html-quotes'?: Linter.RuleEntry<VueHtmlQuotes>;
+    /**
+     * enforce self-closing style
+     * @see https://eslint.vuejs.org/rules/html-self-closing.html
+     */
+    'vue/html-self-closing'?: Linter.RuleEntry<VueHtmlSelfClosing>;
+    /**
+     * prevent variables used in JSX to be marked as unused
+     * @see https://eslint.vuejs.org/rules/jsx-uses-vars.html
+     */
+    'vue/jsx-uses-vars'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce consistent spacing between keys and values in object literal properties in `<template>`
+     * @see https://eslint.vuejs.org/rules/key-spacing.html
+     */
+    'vue/key-spacing'?: Linter.RuleEntry<VueKeySpacing>;
+    /**
+     * Enforce consistent spacing before and after keywords in `<template>`
+     * @see https://eslint.vuejs.org/rules/keyword-spacing.html
+     */
+    'vue/keyword-spacing'?: Linter.RuleEntry<VueKeywordSpacing>;
+    /**
+     * require component name property to match its file name
+     * @see https://eslint.vuejs.org/rules/match-component-file-name.html
+     */
+    'vue/match-component-file-name'?: Linter.RuleEntry<VueMatchComponentFileName>;
+    /**
+     * require the registered component name to match the imported component name
+     * @see https://eslint.vuejs.org/rules/match-component-import-name.html
+     */
+    'vue/match-component-import-name'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce the maximum number of attributes per line
+     * @see https://eslint.vuejs.org/rules/max-attributes-per-line.html
+     */
+    'vue/max-attributes-per-line'?: Linter.RuleEntry<VueMaxAttributesPerLine>;
+    /**
+     * enforce a maximum line length in `.vue` files
+     * @see https://eslint.vuejs.org/rules/max-len.html
+     */
+    'vue/max-len'?: Linter.RuleEntry<VueMaxLen>;
+    /**
+     * enforce maximum number of lines in Vue SFC blocks
+     * @see https://eslint.vuejs.org/rules/max-lines-per-block.html
+     */
+    'vue/max-lines-per-block'?: Linter.RuleEntry<VueMaxLinesPerBlock>;
+    /**
+     * require component names to be always multi-word
+     * @see https://eslint.vuejs.org/rules/multi-word-component-names.html
+     */
+    'vue/multi-word-component-names'?: Linter.RuleEntry<VueMultiWordComponentNames>;
+    /**
+     * require a line break before and after the contents of a multiline element
+     * @see https://eslint.vuejs.org/rules/multiline-html-element-content-newline.html
+     */
+    'vue/multiline-html-element-content-newline'?: Linter.RuleEntry<VueMultilineHtmlElementContentNewline>;
+    /**
+     * Enforce newlines between operands of ternary expressions in `<template>`
+     * @see https://eslint.vuejs.org/rules/multiline-ternary.html
+     */
+    'vue/multiline-ternary'?: Linter.RuleEntry<VueMultilineTernary>;
+    /**
+     * enforce unified spacing in mustache interpolations
+     * @see https://eslint.vuejs.org/rules/mustache-interpolation-spacing.html
+     */
+    'vue/mustache-interpolation-spacing'?: Linter.RuleEntry<VueMustacheInterpolationSpacing>;
+    /**
+     * enforce new lines between multi-line properties in Vue components
+     * @see https://eslint.vuejs.org/rules/new-line-between-multi-line-property.html
+     */
+    'vue/new-line-between-multi-line-property'?: Linter.RuleEntry<VueNewLineBetweenMultiLineProperty>;
+    /**
+     * enforce Promise or callback style in `nextTick`
+     * @see https://eslint.vuejs.org/rules/next-tick-style.html
+     */
+    'vue/next-tick-style'?: Linter.RuleEntry<VueNextTickStyle>;
+    /**
+     * disallow using arrow functions to define watcher
+     * @see https://eslint.vuejs.org/rules/no-arrow-functions-in-watch.html
+     */
+    'vue/no-arrow-functions-in-watch'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow asynchronous actions in computed properties
+     * @see https://eslint.vuejs.org/rules/no-async-in-computed-properties.html
+     */
+    'vue/no-async-in-computed-properties'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow the use of bare strings in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-bare-strings-in-template.html
+     */
+    'vue/no-bare-strings-in-template'?: Linter.RuleEntry<VueNoBareStringsInTemplate>;
+    /**
+     * disallow boolean defaults
+     * @see https://eslint.vuejs.org/rules/no-boolean-default.html
+     */
+    'vue/no-boolean-default'?: Linter.RuleEntry<VueNoBooleanDefault>;
+    /**
+     * disallow element's child contents which would be overwritten by a directive like `v-html` or `v-text`
+     * @see https://eslint.vuejs.org/rules/no-child-content.html
+     */
+    'vue/no-child-content'?: Linter.RuleEntry<VueNoChildContent>;
+    /**
+     * disallow accessing computed properties in `data`.
+     * @see https://eslint.vuejs.org/rules/no-computed-properties-in-data.html
+     */
+    'vue/no-computed-properties-in-data'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow the use of `console` in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-console.html
+     */
+    'vue/no-console'?: Linter.RuleEntry<VueNoConsole>;
+    /**
+     * Disallow constant expressions in conditions in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-constant-condition.html
+     */
+    'vue/no-constant-condition'?: Linter.RuleEntry<VueNoConstantCondition>;
+    /**
+     * disallow custom modifiers on v-model used on the component
+     * @see https://eslint.vuejs.org/rules/no-custom-modifiers-on-v-model.html
+     */
+    'vue/no-custom-modifiers-on-v-model'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated object declaration on data (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-data-object-declaration.html
+     */
+    'vue/no-deprecated-data-object-declaration'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `destroyed` and `beforeDestroy` lifecycle hooks (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-destroyed-lifecycle.html
+     */
+    'vue/no-deprecated-destroyed-lifecycle'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `$listeners` (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-dollar-listeners-api.html
+     */
+    'vue/no-deprecated-dollar-listeners-api'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `$scopedSlots` (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-dollar-scopedslots-api.html
+     */
+    'vue/no-deprecated-dollar-scopedslots-api'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated events api (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-events-api.html
+     */
+    'vue/no-deprecated-events-api'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated filters syntax (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-filter.html
+     */
+    'vue/no-deprecated-filter'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated the `functional` template (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-functional-template.html
+     */
+    'vue/no-deprecated-functional-template'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated the `is` attribute on HTML elements (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-html-element-is.html
+     */
+    'vue/no-deprecated-html-element-is'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `inline-template` attribute (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-inline-template.html
+     */
+    'vue/no-deprecated-inline-template'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow deprecated `model` definition (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-model-definition.html
+     */
+    'vue/no-deprecated-model-definition'?: Linter.RuleEntry<VueNoDeprecatedModelDefinition>;
+    /**
+     * disallow deprecated `this` access in props default function (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-props-default-this.html
+     */
+    'vue/no-deprecated-props-default-this'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `tag` property on `RouterLink` (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-router-link-tag-prop.html
+     */
+    'vue/no-deprecated-router-link-tag-prop'?: Linter.RuleEntry<VueNoDeprecatedRouterLinkTagProp>;
+    /**
+     * disallow deprecated `scope` attribute (in Vue.js 2.5.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-scope-attribute.html
+     */
+    'vue/no-deprecated-scope-attribute'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow deprecated `slot` attribute (in Vue.js 2.6.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-slot-attribute.html
+     */
+    'vue/no-deprecated-slot-attribute'?: Linter.RuleEntry<VueNoDeprecatedSlotAttribute>;
+    /**
+     * disallow deprecated `slot-scope` attribute (in Vue.js 2.6.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-slot-scope-attribute.html
+     */
+    'vue/no-deprecated-slot-scope-attribute'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow use of deprecated `.sync` modifier on `v-bind` directive (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-v-bind-sync.html
+     */
+    'vue/no-deprecated-v-bind-sync'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow deprecated `v-is` directive (in Vue.js 3.1.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-v-is.html
+     */
+    'vue/no-deprecated-v-is'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `.native` modifiers (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-v-on-native-modifier.html
+     */
+    'vue/no-deprecated-v-on-native-modifier'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated number (keycode) modifiers (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-v-on-number-modifiers.html
+     */
+    'vue/no-deprecated-v-on-number-modifiers'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using deprecated `Vue.config.keyCodes` (in Vue.js 3.0.0+)
+     * @see https://eslint.vuejs.org/rules/no-deprecated-vue-config-keycodes.html
+     */
+    'vue/no-deprecated-vue-config-keycodes'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow duplication of field names
+     * @see https://eslint.vuejs.org/rules/no-dupe-keys.html
+     */
+    'vue/no-dupe-keys'?: Linter.RuleEntry<VueNoDupeKeys>;
+    /**
+     * disallow duplicate conditions in `v-if` / `v-else-if` chains
+     * @see https://eslint.vuejs.org/rules/no-dupe-v-else-if.html
+     */
+    'vue/no-dupe-v-else-if'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce `inheritAttrs` to be set to `false` when using `v-bind="$attrs"`
+     * @see https://eslint.vuejs.org/rules/no-duplicate-attr-inheritance.html
+     */
+    'vue/no-duplicate-attr-inheritance'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow duplication of attributes
+     * @see https://eslint.vuejs.org/rules/no-duplicate-attributes.html
+     */
+    'vue/no-duplicate-attributes'?: Linter.RuleEntry<VueNoDuplicateAttributes>;
+    /**
+     * disallow the `<template>` `<script>` `<style>` block to be empty
+     * @see https://eslint.vuejs.org/rules/no-empty-component-block.html
+     */
+    'vue/no-empty-component-block'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow empty destructuring patterns in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-empty-pattern.html
+     */
+    'vue/no-empty-pattern'?: Linter.RuleEntry<VueNoEmptyPattern>;
+    /**
+     * disallow `export` in `<script setup>`
+     * @see https://eslint.vuejs.org/rules/no-export-in-script-setup.html
+     */
+    'vue/no-export-in-script-setup'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow asynchronously registered `expose`
+     * @see https://eslint.vuejs.org/rules/no-expose-after-await.html
+     */
+    'vue/no-expose-after-await'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow unnecessary parentheses in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-extra-parens.html
+     */
+    'vue/no-extra-parens'?: Linter.RuleEntry<VueNoExtraParens>;
+    /**
+     * require valid keys in model option
+     * @see https://eslint.vuejs.org/rules/no-invalid-model-keys.html
+     * @deprecated
+     */
+    'vue/no-invalid-model-keys'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow irregular whitespace in `.vue` files
+     * @see https://eslint.vuejs.org/rules/no-irregular-whitespace.html
+     */
+    'vue/no-irregular-whitespace'?: Linter.RuleEntry<VueNoIrregularWhitespace>;
+    /**
+     * disallow asynchronously registered lifecycle hooks
+     * @see https://eslint.vuejs.org/rules/no-lifecycle-after-await.html
+     */
+    'vue/no-lifecycle-after-await'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow unnecessary `<template>`
+     * @see https://eslint.vuejs.org/rules/no-lone-template.html
+     */
+    'vue/no-lone-template'?: Linter.RuleEntry<VueNoLoneTemplate>;
+    /**
+     * Disallow literal numbers that lose precision in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-loss-of-precision.html
+     */
+    'vue/no-loss-of-precision'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow multiple spaces
+     * @see https://eslint.vuejs.org/rules/no-multi-spaces.html
+     */
+    'vue/no-multi-spaces'?: Linter.RuleEntry<VueNoMultiSpaces>;
+    /**
+     * disallow to pass multiple objects into array to class
+     * @see https://eslint.vuejs.org/rules/no-multiple-objects-in-class.html
+     */
+    'vue/no-multiple-objects-in-class'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow to pass multiple arguments to scoped slots
+     * @see https://eslint.vuejs.org/rules/no-multiple-slot-args.html
+     */
+    'vue/no-multiple-slot-args'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow adding multiple root nodes to the template
+     * @see https://eslint.vuejs.org/rules/no-multiple-template-root.html
+     */
+    'vue/no-multiple-template-root'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow mutation of component props
+     * @see https://eslint.vuejs.org/rules/no-mutating-props.html
+     */
+    'vue/no-mutating-props'?: Linter.RuleEntry<VueNoMutatingProps>;
+    /**
+     * disallow parsing errors in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-parsing-error.html
+     */
+    'vue/no-parsing-error'?: Linter.RuleEntry<VueNoParsingError>;
+    /**
+     * disallow a potential typo in your component property
+     * @see https://eslint.vuejs.org/rules/no-potential-component-option-typo.html
+     */
+    'vue/no-potential-component-option-typo'?: Linter.RuleEntry<VueNoPotentialComponentOptionTypo>;
+    /**
+     * disallow use of value wrapped by `ref()` (Composition API) as an operand
+     * @see https://eslint.vuejs.org/rules/no-ref-as-operand.html
+     */
+    'vue/no-ref-as-operand'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow usages of ref objects that can lead to loss of reactivity
+     * @see https://eslint.vuejs.org/rules/no-ref-object-destructure.html
+     * @deprecated
+     */
+    'vue/no-ref-object-destructure'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow usages of ref objects that can lead to loss of reactivity
+     * @see https://eslint.vuejs.org/rules/no-ref-object-reactivity-loss.html
+     */
+    'vue/no-ref-object-reactivity-loss'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce props with default values to be optional
+     * @see https://eslint.vuejs.org/rules/no-required-prop-with-default.html
+     */
+    'vue/no-required-prop-with-default'?: Linter.RuleEntry<VueNoRequiredPropWithDefault>;
+    /**
+     * disallow the use of reserved names in component definitions
+     * @see https://eslint.vuejs.org/rules/no-reserved-component-names.html
+     */
+    'vue/no-reserved-component-names'?: Linter.RuleEntry<VueNoReservedComponentNames>;
+    /**
+     * disallow overwriting reserved keys
+     * @see https://eslint.vuejs.org/rules/no-reserved-keys.html
+     */
+    'vue/no-reserved-keys'?: Linter.RuleEntry<VueNoReservedKeys>;
+    /**
+     * disallow reserved names in props
+     * @see https://eslint.vuejs.org/rules/no-reserved-props.html
+     */
+    'vue/no-reserved-props'?: Linter.RuleEntry<VueNoReservedProps>;
+    /**
+     * disallow specific block
+     * @see https://eslint.vuejs.org/rules/no-restricted-block.html
+     */
+    'vue/no-restricted-block'?: Linter.RuleEntry<VueNoRestrictedBlock>;
+    /**
+     * disallow asynchronously called restricted methods
+     * @see https://eslint.vuejs.org/rules/no-restricted-call-after-await.html
+     */
+    'vue/no-restricted-call-after-await'?: Linter.RuleEntry<VueNoRestrictedCallAfterAwait>;
+    /**
+     * disallow specific classes in Vue components
+     * @see https://eslint.vuejs.org/rules/no-restricted-class.html
+     */
+    'vue/no-restricted-class'?: Linter.RuleEntry<VueNoRestrictedClass>;
+    /**
+     * disallow specific component names
+     * @see https://eslint.vuejs.org/rules/no-restricted-component-names.html
+     */
+    'vue/no-restricted-component-names'?: Linter.RuleEntry<VueNoRestrictedComponentNames>;
+    /**
+     * disallow specific component option
+     * @see https://eslint.vuejs.org/rules/no-restricted-component-options.html
+     */
+    'vue/no-restricted-component-options'?: Linter.RuleEntry<VueNoRestrictedComponentOptions>;
+    /**
+     * disallow specific custom event
+     * @see https://eslint.vuejs.org/rules/no-restricted-custom-event.html
+     */
+    'vue/no-restricted-custom-event'?: Linter.RuleEntry<VueNoRestrictedCustomEvent>;
+    /**
+     * disallow specific HTML elements
+     * @see https://eslint.vuejs.org/rules/no-restricted-html-elements.html
+     */
+    'vue/no-restricted-html-elements'?: Linter.RuleEntry<VueNoRestrictedHtmlElements>;
+    /**
+     * disallow specific props
+     * @see https://eslint.vuejs.org/rules/no-restricted-props.html
+     */
+    'vue/no-restricted-props'?: Linter.RuleEntry<VueNoRestrictedProps>;
+    /**
+     * disallow specific attribute
+     * @see https://eslint.vuejs.org/rules/no-restricted-static-attribute.html
+     */
+    'vue/no-restricted-static-attribute'?: Linter.RuleEntry<VueNoRestrictedStaticAttribute>;
+    /**
+     * Disallow specified syntax in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-restricted-syntax.html
+     */
+    'vue/no-restricted-syntax'?: Linter.RuleEntry<VueNoRestrictedSyntax>;
+    /**
+     * disallow specific argument in `v-bind`
+     * @see https://eslint.vuejs.org/rules/no-restricted-v-bind.html
+     */
+    'vue/no-restricted-v-bind'?: Linter.RuleEntry<VueNoRestrictedVBind>;
+    /**
+     * disallow specific argument in `v-on`
+     * @see https://eslint.vuejs.org/rules/no-restricted-v-on.html
+     */
+    'vue/no-restricted-v-on'?: Linter.RuleEntry<VueNoRestrictedVOn>;
+    /**
+     * disallow `v-if` directives on root element
+     * @see https://eslint.vuejs.org/rules/no-root-v-if.html
+     */
+    'vue/no-root-v-if'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow usages that lose the reactivity of `props` passed to `setup`
+     * @see https://eslint.vuejs.org/rules/no-setup-props-destructure.html
+     * @deprecated
+     */
+    'vue/no-setup-props-destructure'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow usages that lose the reactivity of `props` passed to `setup`
+     * @see https://eslint.vuejs.org/rules/no-setup-props-reactivity-loss.html
+     */
+    'vue/no-setup-props-reactivity-loss'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce component's data property to be a function
+     * @see https://eslint.vuejs.org/rules/no-shared-component-data.html
+     */
+    'vue/no-shared-component-data'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow side effects in computed properties
+     * @see https://eslint.vuejs.org/rules/no-side-effects-in-computed-properties.html
+     */
+    'vue/no-side-effects-in-computed-properties'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow spaces around equal signs in attribute
+     * @see https://eslint.vuejs.org/rules/no-spaces-around-equal-signs-in-attribute.html
+     */
+    'vue/no-spaces-around-equal-signs-in-attribute'?: Linter.RuleEntry<[]>;
+    /**
+     * Disallow sparse arrays in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-sparse-arrays.html
+     */
+    'vue/no-sparse-arrays'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow static inline `style` attributes
+     * @see https://eslint.vuejs.org/rules/no-static-inline-styles.html
+     */
+    'vue/no-static-inline-styles'?: Linter.RuleEntry<VueNoStaticInlineStyles>;
+    /**
+     * disallow `key` attribute on `<template>`
+     * @see https://eslint.vuejs.org/rules/no-template-key.html
+     */
+    'vue/no-template-key'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow variable declarations from shadowing variables declared in the outer scope
+     * @see https://eslint.vuejs.org/rules/no-template-shadow.html
+     */
+    'vue/no-template-shadow'?: Linter.RuleEntry<VueNoTemplateShadow>;
+    /**
+     * disallow target="_blank" attribute without rel="noopener noreferrer"
+     * @see https://eslint.vuejs.org/rules/no-template-target-blank.html
+     */
+    'vue/no-template-target-blank'?: Linter.RuleEntry<VueNoTemplateTargetBlank>;
+    /**
+     * disallow mustaches in `<textarea>`
+     * @see https://eslint.vuejs.org/rules/no-textarea-mustache.html
+     */
+    'vue/no-textarea-mustache'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow `this` usage in a `beforeRouteEnter` method
+     * @see https://eslint.vuejs.org/rules/no-this-in-before-route-enter.html
+     */
+    'vue/no-this-in-before-route-enter'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow use of undefined components in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-undef-components.html
+     */
+    'vue/no-undef-components'?: Linter.RuleEntry<VueNoUndefComponents>;
+    /**
+     * disallow undefined properties
+     * @see https://eslint.vuejs.org/rules/no-undef-properties.html
+     */
+    'vue/no-undef-properties'?: Linter.RuleEntry<VueNoUndefProperties>;
+    /**
+     * disallow unsupported Vue.js syntax on the specified version
+     * @see https://eslint.vuejs.org/rules/no-unsupported-features.html
+     */
+    'vue/no-unsupported-features'?: Linter.RuleEntry<VueNoUnsupportedFeatures>;
+    /**
+     * disallow registering components that are not used inside templates
+     * @see https://eslint.vuejs.org/rules/no-unused-components.html
+     */
+    'vue/no-unused-components'?: Linter.RuleEntry<VueNoUnusedComponents>;
+    /**
+     * disallow unused emit declarations
+     * @see https://eslint.vuejs.org/rules/no-unused-emit-declarations.html
+     */
+    'vue/no-unused-emit-declarations'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow unused properties
+     * @see https://eslint.vuejs.org/rules/no-unused-properties.html
+     */
+    'vue/no-unused-properties'?: Linter.RuleEntry<VueNoUnusedProperties>;
+    /**
+     * disallow unused refs
+     * @see https://eslint.vuejs.org/rules/no-unused-refs.html
+     */
+    'vue/no-unused-refs'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow unused variable definitions of v-for directives or scope attributes
+     * @see https://eslint.vuejs.org/rules/no-unused-vars.html
+     */
+    'vue/no-unused-vars'?: Linter.RuleEntry<VueNoUnusedVars>;
+    /**
+     * disallow use computed property like method
+     * @see https://eslint.vuejs.org/rules/no-use-computed-property-like-method.html
+     */
+    'vue/no-use-computed-property-like-method'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using `v-else-if`/`v-else` on the same element as `v-for`
+     * @see https://eslint.vuejs.org/rules/no-use-v-else-with-v-for.html
+     */
+    'vue/no-use-v-else-with-v-for'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow using `v-if` on the same element as `v-for`
+     * @see https://eslint.vuejs.org/rules/no-use-v-if-with-v-for.html
+     */
+    'vue/no-use-v-if-with-v-for'?: Linter.RuleEntry<VueNoUseVIfWithVFor>;
+    /**
+     * Disallow unnecessary concatenation of literals or template literals in `<template>`
+     * @see https://eslint.vuejs.org/rules/no-useless-concat.html
+     */
+    'vue/no-useless-concat'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow unnecessary mustache interpolations
+     * @see https://eslint.vuejs.org/rules/no-useless-mustaches.html
+     */
+    'vue/no-useless-mustaches'?: Linter.RuleEntry<VueNoUselessMustaches>;
+    /**
+     * disallow useless attribute on `<template>`
+     * @see https://eslint.vuejs.org/rules/no-useless-template-attributes.html
+     */
+    'vue/no-useless-template-attributes'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow unnecessary `v-bind` directives
+     * @see https://eslint.vuejs.org/rules/no-useless-v-bind.html
+     */
+    'vue/no-useless-v-bind'?: Linter.RuleEntry<VueNoUselessVBind>;
+    /**
+     * disallow `key` attribute on `<template v-for>`
+     * @see https://eslint.vuejs.org/rules/no-v-for-template-key.html
+     */
+    'vue/no-v-for-template-key'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow key of `<template v-for>` placed on child elements
+     * @see https://eslint.vuejs.org/rules/no-v-for-template-key-on-child.html
+     */
+    'vue/no-v-for-template-key-on-child'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow use of v-html to prevent XSS attack
+     * @see https://eslint.vuejs.org/rules/no-v-html.html
+     */
+    'vue/no-v-html'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow adding an argument to `v-model` used in custom component
+     * @see https://eslint.vuejs.org/rules/no-v-model-argument.html
+     */
+    'vue/no-v-model-argument'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow use of v-text
+     * @see https://eslint.vuejs.org/rules/no-v-text.html
+     */
+    'vue/no-v-text'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow v-text / v-html on component
+     * @see https://eslint.vuejs.org/rules/no-v-text-v-html-on-component.html
+     */
+    'vue/no-v-text-v-html-on-component'?: Linter.RuleEntry<VueNoVTextVHtmlOnComponent>;
+    /**
+     * disallow asynchronously registered `watch`
+     * @see https://eslint.vuejs.org/rules/no-watch-after-await.html
+     */
+    'vue/no-watch-after-await'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce consistent line breaks after opening and before closing braces in `<template>`
+     * @see https://eslint.vuejs.org/rules/object-curly-newline.html
+     */
+    'vue/object-curly-newline'?: Linter.RuleEntry<VueObjectCurlyNewline>;
+    /**
+     * Enforce consistent spacing inside braces in `<template>`
+     * @see https://eslint.vuejs.org/rules/object-curly-spacing.html
+     */
+    'vue/object-curly-spacing'?: Linter.RuleEntry<VueObjectCurlySpacing>;
+    /**
+     * Enforce placing object properties on separate lines in `<template>`
+     * @see https://eslint.vuejs.org/rules/object-property-newline.html
+     */
+    'vue/object-property-newline'?: Linter.RuleEntry<VueObjectPropertyNewline>;
+    /**
+     * Require or disallow method and property shorthand syntax for object literals in `<template>`
+     * @see https://eslint.vuejs.org/rules/object-shorthand.html
+     */
+    'vue/object-shorthand'?: Linter.RuleEntry<VueObjectShorthand>;
+    /**
+     * enforce that each component should be in its own file
+     * @see https://eslint.vuejs.org/rules/one-component-per-file.html
+     */
+    'vue/one-component-per-file'?: Linter.RuleEntry<[]>;
+    /**
+     * Enforce consistent linebreak style for operators in `<template>`
+     * @see https://eslint.vuejs.org/rules/operator-linebreak.html
+     */
+    'vue/operator-linebreak'?: Linter.RuleEntry<VueOperatorLinebreak>;
+    /**
+     * enforce order of properties in components
+     * @see https://eslint.vuejs.org/rules/order-in-components.html
+     */
+    'vue/order-in-components'?: Linter.RuleEntry<VueOrderInComponents>;
+    /**
+     * require or disallow padding lines between blocks
+     * @see https://eslint.vuejs.org/rules/padding-line-between-blocks.html
+     */
+    'vue/padding-line-between-blocks'?: Linter.RuleEntry<VuePaddingLineBetweenBlocks>;
+    /**
+     * require or disallow newlines between sibling tags in template
+     * @see https://eslint.vuejs.org/rules/padding-line-between-tags.html
+     */
+    'vue/padding-line-between-tags'?: Linter.RuleEntry<VuePaddingLineBetweenTags>;
+    /**
+     * require or disallow padding lines in component definition
+     * @see https://eslint.vuejs.org/rules/padding-lines-in-component-definition.html
+     */
+    'vue/padding-lines-in-component-definition'?: Linter.RuleEntry<VuePaddingLinesInComponentDefinition>;
+    /**
+     * enforce use of `defineOptions` instead of default export.
+     * @see https://eslint.vuejs.org/rules/prefer-define-options.html
+     */
+    'vue/prefer-define-options'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce import from 'vue' instead of import from '@vue/*'
+     * @see https://eslint.vuejs.org/rules/prefer-import-from-vue.html
+     */
+    'vue/prefer-import-from-vue'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce `Boolean` comes first in component prop types
+     * @see https://eslint.vuejs.org/rules/prefer-prop-type-boolean-first.html
+     */
+    'vue/prefer-prop-type-boolean-first'?: Linter.RuleEntry<[]>;
+    /**
+     * require static class names in template to be in a separate `class` attribute
+     * @see https://eslint.vuejs.org/rules/prefer-separate-static-class.html
+     */
+    'vue/prefer-separate-static-class'?: Linter.RuleEntry<[]>;
+    /**
+     * Require template literals instead of string concatenation in `<template>`
+     * @see https://eslint.vuejs.org/rules/prefer-template.html
+     */
+    'vue/prefer-template'?: Linter.RuleEntry<[]>;
+    /**
+     * require shorthand form attribute when `v-bind` value is `true`
+     * @see https://eslint.vuejs.org/rules/prefer-true-attribute-shorthand.html
+     */
+    'vue/prefer-true-attribute-shorthand'?: Linter.RuleEntry<VuePreferTrueAttributeShorthand>;
+    /**
+     * enforce specific casing for the Prop name in Vue components
+     * @see https://eslint.vuejs.org/rules/prop-name-casing.html
+     */
+    'vue/prop-name-casing'?: Linter.RuleEntry<VuePropNameCasing>;
+    /**
+     * Require quotes around object literal property names in `<template>`
+     * @see https://eslint.vuejs.org/rules/quote-props.html
+     */
+    'vue/quote-props'?: Linter.RuleEntry<VueQuoteProps>;
+    /**
+     * require `v-bind:is` of `<component>` elements
+     * @see https://eslint.vuejs.org/rules/require-component-is.html
+     */
+    'vue/require-component-is'?: Linter.RuleEntry<[]>;
+    /**
+     * require default value for props
+     * @see https://eslint.vuejs.org/rules/require-default-prop.html
+     */
+    'vue/require-default-prop'?: Linter.RuleEntry<[]>;
+    /**
+     * require the component to be directly exported
+     * @see https://eslint.vuejs.org/rules/require-direct-export.html
+     */
+    'vue/require-direct-export'?: Linter.RuleEntry<VueRequireDirectExport>;
+    /**
+     * require type definitions in emits
+     * @see https://eslint.vuejs.org/rules/require-emit-validator.html
+     */
+    'vue/require-emit-validator'?: Linter.RuleEntry<[]>;
+    /**
+     * require `emits` option with name triggered by `$emit()`
+     * @see https://eslint.vuejs.org/rules/require-explicit-emits.html
+     */
+    'vue/require-explicit-emits'?: Linter.RuleEntry<VueRequireExplicitEmits>;
+    /**
+     * require slots to be explicitly defined
+     * @see https://eslint.vuejs.org/rules/require-explicit-slots.html
+     */
+    'vue/require-explicit-slots'?: Linter.RuleEntry<[]>;
+    /**
+     * require declare public properties using `expose`
+     * @see https://eslint.vuejs.org/rules/require-expose.html
+     */
+    'vue/require-expose'?: Linter.RuleEntry<[]>;
+    /**
+     * require a certain macro variable name
+     * @see https://eslint.vuejs.org/rules/require-macro-variable-name.html
+     */
+    'vue/require-macro-variable-name'?: Linter.RuleEntry<VueRequireMacroVariableName>;
+    /**
+     * require a name property in Vue components
+     * @see https://eslint.vuejs.org/rules/require-name-property.html
+     */
+    'vue/require-name-property'?: Linter.RuleEntry<[]>;
+    /**
+     * require props to have a comment
+     * @see https://eslint.vuejs.org/rules/require-prop-comment.html
+     */
+    'vue/require-prop-comment'?: Linter.RuleEntry<VueRequirePropComment>;
+    /**
+     * require prop type to be a constructor
+     * @see https://eslint.vuejs.org/rules/require-prop-type-constructor.html
+     */
+    'vue/require-prop-type-constructor'?: Linter.RuleEntry<[]>;
+    /**
+     * require type definitions in props
+     * @see https://eslint.vuejs.org/rules/require-prop-types.html
+     */
+    'vue/require-prop-types'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce render function to always return value
+     * @see https://eslint.vuejs.org/rules/require-render-return.html
+     */
+    'vue/require-render-return'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce properties of `$slots` to be used as a function
+     * @see https://eslint.vuejs.org/rules/require-slots-as-functions.html
+     */
+    'vue/require-slots-as-functions'?: Linter.RuleEntry<[]>;
+    /**
+     * require control the display of the content inside `<transition>`
+     * @see https://eslint.vuejs.org/rules/require-toggle-inside-transition.html
+     */
+    'vue/require-toggle-inside-transition'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce adding type declarations to object props
+     * @see https://eslint.vuejs.org/rules/require-typed-object-prop.html
+     */
+    'vue/require-typed-object-prop'?: Linter.RuleEntry<[]>;
+    /**
+     * require `ref` and `shallowRef` functions to be strongly typed
+     * @see https://eslint.vuejs.org/rules/require-typed-ref.html
+     */
+    'vue/require-typed-ref'?: Linter.RuleEntry<[]>;
+    /**
+     * require `v-bind:key` with `v-for` directives
+     * @see https://eslint.vuejs.org/rules/require-v-for-key.html
+     */
+    'vue/require-v-for-key'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce props default values to be valid
+     * @see https://eslint.vuejs.org/rules/require-valid-default-prop.html
+     */
+    'vue/require-valid-default-prop'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce that a return statement is present in computed property
+     * @see https://eslint.vuejs.org/rules/return-in-computed-property.html
+     */
+    'vue/return-in-computed-property'?: Linter.RuleEntry<VueReturnInComputedProperty>;
+    /**
+     * enforce that a return statement is present in emits validator
+     * @see https://eslint.vuejs.org/rules/return-in-emits-validator.html
+     */
+    'vue/return-in-emits-validator'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce consistent indentation in `<script>`
+     * @see https://eslint.vuejs.org/rules/script-indent.html
+     */
+    'vue/script-indent'?: Linter.RuleEntry<VueScriptIndent>;
+    /**
+     * prevent `<script setup>` variables used in `<template>` to be marked as unused
+     * @see https://eslint.vuejs.org/rules/script-setup-uses-vars.html
+     * @deprecated
+     */
+    'vue/script-setup-uses-vars'?: Linter.RuleEntry<[]>;
+    /**
+     * require a line break before and after the contents of a singleline element
+     * @see https://eslint.vuejs.org/rules/singleline-html-element-content-newline.html
+     */
+    'vue/singleline-html-element-content-newline'?: Linter.RuleEntry<VueSinglelineHtmlElementContentNewline>;
+    /**
+     * enforce sort-keys in a manner that is compatible with order-in-components
+     * @see https://eslint.vuejs.org/rules/sort-keys.html
+     */
+    'vue/sort-keys'?: Linter.RuleEntry<VueSortKeys>;
+    /**
+     * Enforce consistent spacing inside parentheses in `<template>`
+     * @see https://eslint.vuejs.org/rules/space-in-parens.html
+     */
+    'vue/space-in-parens'?: Linter.RuleEntry<VueSpaceInParens>;
+    /**
+     * Require spacing around infix operators in `<template>`
+     * @see https://eslint.vuejs.org/rules/space-infix-ops.html
+     */
+    'vue/space-infix-ops'?: Linter.RuleEntry<VueSpaceInfixOps>;
+    /**
+     * Enforce consistent spacing before or after unary operators in `<template>`
+     * @see https://eslint.vuejs.org/rules/space-unary-ops.html
+     */
+    'vue/space-unary-ops'?: Linter.RuleEntry<VueSpaceUnaryOps>;
+    /**
+     * enforce static class names order
+     * @see https://eslint.vuejs.org/rules/static-class-names-order.html
+     */
+    'vue/static-class-names-order'?: Linter.RuleEntry<[]>;
+    /**
+     * Require or disallow spacing around embedded expressions of template strings in `<template>`
+     * @see https://eslint.vuejs.org/rules/template-curly-spacing.html
+     */
+    'vue/template-curly-spacing'?: Linter.RuleEntry<VueTemplateCurlySpacing>;
+    /**
+     * disallow usage of `this` in template
+     * @see https://eslint.vuejs.org/rules/this-in-template.html
+     */
+    'vue/this-in-template'?: Linter.RuleEntry<VueThisInTemplate>;
+    /**
+     * enforce usage of `exact` modifier on `v-on`
+     * @see https://eslint.vuejs.org/rules/use-v-on-exact.html
+     */
+    'vue/use-v-on-exact'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce `v-bind` directive style
+     * @see https://eslint.vuejs.org/rules/v-bind-style.html
+     */
+    'vue/v-bind-style'?: Linter.RuleEntry<VueVBindStyle>;
+    /**
+     * enforce `v-for` directive's delimiter style
+     * @see https://eslint.vuejs.org/rules/v-for-delimiter-style.html
+     */
+    'vue/v-for-delimiter-style'?: Linter.RuleEntry<VueVForDelimiterStyle>;
+    /**
+     * require key attribute for conditionally rendered repeated components
+     * @see https://eslint.vuejs.org/rules/v-if-else-key.html
+     */
+    'vue/v-if-else-key'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce v-on event naming style on custom components in template
+     * @see https://eslint.vuejs.org/rules/v-on-event-hyphenation.html
+     */
+    'vue/v-on-event-hyphenation'?: Linter.RuleEntry<VueVOnEventHyphenation>;
+    /**
+     * enforce or forbid parentheses after method calls without arguments in `v-on` directives
+     * @see https://eslint.vuejs.org/rules/v-on-function-call.html
+     * @deprecated
+     */
+    'vue/v-on-function-call'?: Linter.RuleEntry<VueVOnFunctionCall>;
+    /**
+     * enforce writing style for handlers in `v-on` directives
+     * @see https://eslint.vuejs.org/rules/v-on-handler-style.html
+     */
+    'vue/v-on-handler-style'?: Linter.RuleEntry<VueVOnHandlerStyle>;
+    /**
+     * enforce `v-on` directive style
+     * @see https://eslint.vuejs.org/rules/v-on-style.html
+     */
+    'vue/v-on-style'?: Linter.RuleEntry<VueVOnStyle>;
+    /**
+     * enforce `v-slot` directive style
+     * @see https://eslint.vuejs.org/rules/v-slot-style.html
+     */
+    'vue/v-slot-style'?: Linter.RuleEntry<VueVSlotStyle>;
+    /**
+     * require valid attribute names
+     * @see https://eslint.vuejs.org/rules/valid-attribute-name.html
+     */
+    'vue/valid-attribute-name'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `defineEmits` compiler macro
+     * @see https://eslint.vuejs.org/rules/valid-define-emits.html
+     */
+    'vue/valid-define-emits'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `defineOptions` compiler macro
+     * @see https://eslint.vuejs.org/rules/valid-define-options.html
+     */
+    'vue/valid-define-options'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `defineProps` compiler macro
+     * @see https://eslint.vuejs.org/rules/valid-define-props.html
+     */
+    'vue/valid-define-props'?: Linter.RuleEntry<[]>;
+    /**
+     * require valid keys in model option
+     * @see https://eslint.vuejs.org/rules/valid-model-definition.html
+     */
+    'vue/valid-model-definition'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `nextTick` function calls
+     * @see https://eslint.vuejs.org/rules/valid-next-tick.html
+     */
+    'vue/valid-next-tick'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid template root
+     * @see https://eslint.vuejs.org/rules/valid-template-root.html
+     */
+    'vue/valid-template-root'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-bind` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-bind.html
+     */
+    'vue/valid-v-bind'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `.sync` modifier on `v-bind` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-bind-sync.html
+     */
+    'vue/valid-v-bind-sync'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-cloak` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-cloak.html
+     */
+    'vue/valid-v-cloak'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-else` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-else.html
+     */
+    'vue/valid-v-else'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-else-if` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-else-if.html
+     */
+    'vue/valid-v-else-if'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-for` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-for.html
+     */
+    'vue/valid-v-for'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-html` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-html.html
+     */
+    'vue/valid-v-html'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-if` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-if.html
+     */
+    'vue/valid-v-if'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-is` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-is.html
+     */
+    'vue/valid-v-is'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-memo` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-memo.html
+     */
+    'vue/valid-v-memo'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-model` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-model.html
+     */
+    'vue/valid-v-model'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-on` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-on.html
+     */
+    'vue/valid-v-on'?: Linter.RuleEntry<VueValidVOn>;
+    /**
+     * enforce valid `v-once` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-once.html
+     */
+    'vue/valid-v-once'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-pre` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-pre.html
+     */
+    'vue/valid-v-pre'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-show` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-show.html
+     */
+    'vue/valid-v-show'?: Linter.RuleEntry<[]>;
+    /**
+     * enforce valid `v-slot` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-slot.html
+     */
+    'vue/valid-v-slot'?: Linter.RuleEntry<VueValidVSlot>;
+    /**
+     * enforce valid `v-text` directives
+     * @see https://eslint.vuejs.org/rules/valid-v-text.html
+     */
+    'vue/valid-v-text'?: Linter.RuleEntry<[]>;
+}
+type VueArrayBracketNewline = [] | [
+    (("always" | "never" | "consistent") | {
+        multiline?: boolean;
+        minItems?: (number | null);
+    })
+];
+type VueArrayBracketSpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        singleValue?: boolean;
+        objectsInArrays?: boolean;
+        arraysInArrays?: boolean;
+    }
+];
+type VueArrayElementNewline = [] | [
+    (_VueArrayElementNewlineBasicConfig | {
+        ArrayExpression?: _VueArrayElementNewlineBasicConfig;
+        ArrayPattern?: _VueArrayElementNewlineBasicConfig;
+    })
+];
+type _VueArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
+    multiline?: boolean;
+    minItems?: (number | null);
+});
+type VueArrowSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+    }
+];
+type VueAttributeHyphenation = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        ignore?: (string & {
+            [k: string]: unknown | undefined;
+        } & {
+            [k: string]: unknown | undefined;
+        })[];
+    }
+];
+type VueAttributesOrder = [] | [
+    {
+        order?: (("DEFINITION" | "LIST_RENDERING" | "CONDITIONALS" | "RENDER_MODIFIERS" | "GLOBAL" | "UNIQUE" | "SLOT" | "TWO_WAY_BINDING" | "OTHER_DIRECTIVES" | "OTHER_ATTR" | "ATTR_STATIC" | "ATTR_DYNAMIC" | "ATTR_SHORTHAND_BOOL" | "EVENTS" | "CONTENT") | ("DEFINITION" | "LIST_RENDERING" | "CONDITIONALS" | "RENDER_MODIFIERS" | "GLOBAL" | "UNIQUE" | "SLOT" | "TWO_WAY_BINDING" | "OTHER_DIRECTIVES" | "OTHER_ATTR" | "ATTR_STATIC" | "ATTR_DYNAMIC" | "ATTR_SHORTHAND_BOOL" | "EVENTS" | "CONTENT")[])[];
+        alphabetical?: boolean;
+    }
+];
+type VueBlockLang = [] | [
+    {
+        [k: string]: {
+            lang?: (string | string[]);
+            allowNoLang?: boolean;
+        };
+    }
+];
+type VueBlockOrder = [] | [
+    {
+        order?: (string | string[])[];
+    }
+];
+type VueBlockSpacing = [] | [("always" | "never")];
+type VueBlockTagNewline = [] | [
+    {
+        singleline?: ("always" | "never" | "consistent" | "ignore");
+        multiline?: ("always" | "never" | "consistent" | "ignore");
+        maxEmptyLines?: number;
+        blocks?: {
+            [k: string]: {
+                singleline?: ("always" | "never" | "consistent" | "ignore");
+                multiline?: ("always" | "never" | "consistent" | "ignore");
+                maxEmptyLines?: number;
+            };
+        };
+    }
+];
+type VueBraceStyle = [] | [("1tbs" | "stroustrup" | "allman")] | [
+    ("1tbs" | "stroustrup" | "allman"),
+    {
+        allowSingleLine?: boolean;
+    }
+];
+type VueCamelcase = [] | [
+    {
+        ignoreDestructuring?: boolean;
+        ignoreImports?: boolean;
+        ignoreGlobals?: boolean;
+        properties?: ("always" | "never");
+        allow?: string[];
+    }
+];
+type VueCommaDangle = [] | [
+    (_VueCommaDangleValue | {
+        arrays?: _VueCommaDangleValueWithIgnore;
+        objects?: _VueCommaDangleValueWithIgnore;
+        imports?: _VueCommaDangleValueWithIgnore;
+        exports?: _VueCommaDangleValueWithIgnore;
+        functions?: _VueCommaDangleValueWithIgnore;
+    })
+];
+type _VueCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline");
+type _VueCommaDangleValueWithIgnore = ("always-multiline" | "always" | "ignore" | "never" | "only-multiline");
+type VueCommaSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+    }
+];
+type VueCommaStyle = [] | [("first" | "last")] | [
+    ("first" | "last"),
+    {
+        exceptions?: {
+            [k: string]: boolean | undefined;
+        };
+    }
+];
+type VueCommentDirective = [] | [
+    {
+        reportUnusedDisableDirectives?: boolean;
+    }
+];
+type VueComponentApiStyle = [] | [[("script-setup" | "composition" | "composition-vue2" | "options"), ...(("script-setup" | "composition" | "composition-vue2" | "options"))[]]];
+type VueComponentDefinitionNameCasing = [] | [("PascalCase" | "kebab-case")];
+type VueComponentNameInTemplateCasing = [] | [("PascalCase" | "kebab-case")] | [
+    ("PascalCase" | "kebab-case"),
+    {
+        globals?: string[];
+        ignores?: string[];
+        registeredComponentsOnly?: boolean;
+    }
+];
+type VueComponentOptionsNameCasing = [] | [("camelCase" | "kebab-case" | "PascalCase")];
+type VueComponentTagsOrder = [] | [
+    {
+        order?: (string | string[])[];
+    }
+];
+type VueCustomEventNameCasing = ([] | [("kebab-case" | "camelCase")] | [
+    ("kebab-case" | "camelCase"),
+    {
+        ignores?: string[];
+    }
+] | [] | [
+    {
+        ignores?: string[];
+    }
+]);
+type VueDefineEmitsDeclaration = [] | [("type-based" | "type-literal" | "runtime")];
+type VueDefineMacrosOrder = [] | [
+    {
+        order?: ("defineEmits" | "defineProps" | "defineOptions" | "defineSlots" | "defineModel")[];
+        defineExposeLast?: boolean;
+    }
+];
+type VueDefinePropsDeclaration = [] | [("type-based" | "runtime")];
+type VueDotLocation = [] | [("object" | "property")];
+type VueDotNotation = [] | [
+    {
+        allowKeywords?: boolean;
+        allowPattern?: string;
+    }
+];
+type VueEnforceStyleAttribute = [] | [
+    {
+        allow?: [("plain" | "scoped" | "module"), ...(("plain" | "scoped" | "module"))[]];
+    }
+];
+type VueEqeqeq = ([] | ["always"] | [
+    "always",
+    {
+        null?: ("always" | "never" | "ignore");
+    }
+] | [] | [("smart" | "allow-null")]);
+type VueFirstAttributeLinebreak = [] | [
+    {
+        multiline?: ("below" | "beside" | "ignore");
+        singleline?: ("below" | "beside" | "ignore");
+    }
+];
+type VueFuncCallSpacing = ([] | ["never"] | [] | ["always"] | [
+    "always",
+    {
+        allowNewlines?: boolean;
+    }
+]);
+type VueHtmlButtonHasType = [] | [
+    {
+        button?: boolean;
+        submit?: boolean;
+        reset?: boolean;
+    }
+];
+type VueHtmlClosingBracketNewline = [] | [
+    {
+        singleline?: ("always" | "never");
+        multiline?: ("always" | "never");
+        selfClosingTag?: {
+            singleline?: ("always" | "never");
+            multiline?: ("always" | "never");
+        };
+    }
+];
+type VueHtmlClosingBracketSpacing = [] | [
+    {
+        startTag?: ("always" | "never");
+        endTag?: ("always" | "never");
+        selfClosingTag?: ("always" | "never");
+    }
+];
+type VueHtmlCommentContentNewline = [] | [
+    (("always" | "never") | {
+        singleline?: ("always" | "never" | "ignore");
+        multiline?: ("always" | "never" | "ignore");
+    })
+] | [
+    (("always" | "never") | {
+        singleline?: ("always" | "never" | "ignore");
+        multiline?: ("always" | "never" | "ignore");
+    }),
+    {
+        exceptions?: string[];
+    }
+];
+type VueHtmlCommentContentSpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        exceptions?: string[];
+    }
+];
+type VueHtmlCommentIndent = [] | [(number | "tab")];
+type VueHtmlIndent = [] | [(number | "tab")] | [
+    (number | "tab"),
+    {
+        attribute?: number;
+        baseIndent?: number;
+        closeBracket?: (number | {
+            startTag?: number;
+            endTag?: number;
+            selfClosingTag?: number;
+        });
+        switchCase?: number;
+        alignAttributesVertically?: boolean;
+        ignores?: (string & {
+            [k: string]: unknown | undefined;
+        } & {
+            [k: string]: unknown | undefined;
+        })[];
+    }
+];
+type VueHtmlQuotes = [] | [("double" | "single")] | [
+    ("double" | "single"),
+    {
+        avoidEscape?: boolean;
+    }
+];
+type VueHtmlSelfClosing = [] | [
+    {
+        html?: {
+            normal?: _VueHtmlSelfClosingOptionValue;
+            void?: _VueHtmlSelfClosingOptionValue;
+            component?: _VueHtmlSelfClosingOptionValue;
+        };
+        svg?: _VueHtmlSelfClosingOptionValue;
+        math?: _VueHtmlSelfClosingOptionValue;
+    }
+];
+type _VueHtmlSelfClosingOptionValue = ("always" | "never" | "any");
+type VueKeySpacing = [] | [
+    ({
+        align?: (("colon" | "value") | {
+            mode?: ("strict" | "minimum");
+            on?: ("colon" | "value");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        });
+        mode?: ("strict" | "minimum");
+        beforeColon?: boolean;
+        afterColon?: boolean;
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            align?: (("colon" | "value") | {
+                mode?: ("strict" | "minimum");
+                on?: ("colon" | "value");
+                beforeColon?: boolean;
+                afterColon?: boolean;
+            });
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        align?: {
+            mode?: ("strict" | "minimum");
+            on?: ("colon" | "value");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    })
+];
+type VueKeywordSpacing = [] | [
+    {
+        before?: boolean;
+        after?: boolean;
+        overrides?: {
+            abstract?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            as?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            async?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            await?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            boolean?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            break?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            byte?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            case?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            catch?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            char?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            class?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            const?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            continue?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            debugger?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            default?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            delete?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            do?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            double?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            else?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            enum?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            export?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            extends?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            false?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            final?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            finally?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            float?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            for?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            from?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            function?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            get?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            goto?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            if?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            implements?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            import?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            in?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            instanceof?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            int?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            interface?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            let?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            long?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            native?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            new?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            null?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            of?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            package?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            private?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            protected?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            public?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            return?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            set?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            short?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            static?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            super?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            switch?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            synchronized?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            this?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            throw?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            throws?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            transient?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            true?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            try?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            typeof?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            var?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            void?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            volatile?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            while?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            with?: {
+                before?: boolean;
+                after?: boolean;
+            };
+            yield?: {
+                before?: boolean;
+                after?: boolean;
+            };
+        };
+    }
+];
+type VueMatchComponentFileName = [] | [
+    {
+        extensions?: string[];
+        shouldMatchCase?: boolean;
+    }
+];
+type VueMaxAttributesPerLine = [] | [
+    {
+        singleline?: (number | {
+            max?: number;
+        });
+        multiline?: (number | {
+            max?: number;
+        });
+    }
+];
+type VueMaxLen = [] | [
+    ({
+        code?: number;
+        template?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreTrailingComments?: boolean;
+        ignoreUrls?: boolean;
+        ignoreStrings?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreHTMLAttributeValues?: boolean;
+        ignoreHTMLTextContents?: boolean;
+    } | number)
+] | [
+    ({
+        code?: number;
+        template?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreTrailingComments?: boolean;
+        ignoreUrls?: boolean;
+        ignoreStrings?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreHTMLAttributeValues?: boolean;
+        ignoreHTMLTextContents?: boolean;
+    } | number),
+    ({
+        code?: number;
+        template?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreTrailingComments?: boolean;
+        ignoreUrls?: boolean;
+        ignoreStrings?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreHTMLAttributeValues?: boolean;
+        ignoreHTMLTextContents?: boolean;
+    } | number)
+] | [
+    ({
+        code?: number;
+        template?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreTrailingComments?: boolean;
+        ignoreUrls?: boolean;
+        ignoreStrings?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreHTMLAttributeValues?: boolean;
+        ignoreHTMLTextContents?: boolean;
+    } | number),
+    ({
+        code?: number;
+        template?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreTrailingComments?: boolean;
+        ignoreUrls?: boolean;
+        ignoreStrings?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreHTMLAttributeValues?: boolean;
+        ignoreHTMLTextContents?: boolean;
+    } | number),
+    {
+        code?: number;
+        template?: number;
+        comments?: number;
+        tabWidth?: number;
+        ignorePattern?: string;
+        ignoreComments?: boolean;
+        ignoreTrailingComments?: boolean;
+        ignoreUrls?: boolean;
+        ignoreStrings?: boolean;
+        ignoreTemplateLiterals?: boolean;
+        ignoreRegExpLiterals?: boolean;
+        ignoreHTMLAttributeValues?: boolean;
+        ignoreHTMLTextContents?: boolean;
+    }
+];
+type VueMaxLinesPerBlock = [] | [
+    {
+        style?: number;
+        template?: number;
+        script?: number;
+        skipBlankLines?: boolean;
+    }
+];
+type VueMultiWordComponentNames = [] | [
+    {
+        ignores?: string[];
+    }
+];
+type VueMultilineHtmlElementContentNewline = [] | [
+    {
+        ignoreWhenEmpty?: boolean;
+        ignores?: string[];
+        allowEmptyLines?: boolean;
+    }
+];
+type VueMultilineTernary = [] | [("always" | "always-multiline" | "never")];
+type VueMustacheInterpolationSpacing = [] | [("always" | "never")];
+type VueNewLineBetweenMultiLineProperty = [] | [
+    {
+        minLineOfMultilineProperty?: number;
+    }
+];
+type VueNextTickStyle = [] | [("promise" | "callback")];
+type VueNoBareStringsInTemplate = [] | [
+    {
+        allowlist?: string[];
+        attributes?: {
+            [k: string]: string[];
+        };
+        directives?: string[];
+    }
+];
+type VueNoBooleanDefault = [] | [("default-false" | "no-default")];
+type VueNoChildContent = [] | [
+    {
+        additionalDirectives: [string, ...(string)[]];
+    }
+];
+type VueNoConsole = [] | [
+    {
+        allow?: [string, ...(string)[]];
+    }
+];
+type VueNoConstantCondition = [] | [
+    {
+        checkLoops?: ("all" | "allExceptWhileTrue" | "none" | true | false);
+    }
+];
+type VueNoDeprecatedModelDefinition = [] | [
+    {
+        allowVue3Compat?: boolean;
+    }
+];
+type VueNoDeprecatedRouterLinkTagProp = [] | [
+    {
+        components?: [string, ...(string)[]];
+    }
+];
+type VueNoDeprecatedSlotAttribute = [] | [
+    {
+        ignore?: string[];
+    }
+];
+type VueNoDupeKeys = [] | [
+    {
+        groups?: unknown[];
+    }
+];
+type VueNoDuplicateAttributes = [] | [
+    {
+        allowCoexistClass?: boolean;
+        allowCoexistStyle?: boolean;
+    }
+];
+type VueNoEmptyPattern = [] | [
+    {
+        allowObjectPatternsAsParameters?: boolean;
+    }
+];
+type VueNoExtraParens = ([] | ["functions"] | [] | ["all"] | [
+    "all",
+    {
+        conditionalAssign?: boolean;
+        ternaryOperandBinaryExpressions?: boolean;
+        nestedBinaryExpressions?: boolean;
+        returnAssign?: boolean;
+        ignoreJSX?: ("none" | "all" | "single-line" | "multi-line");
+        enforceForArrowConditionals?: boolean;
+        enforceForSequenceExpressions?: boolean;
+        enforceForNewInMemberExpressions?: boolean;
+        enforceForFunctionPrototypeMethods?: boolean;
+        allowParensAfterCommentPattern?: string;
+    }
+]);
+type VueNoIrregularWhitespace = [] | [
+    {
+        skipComments?: boolean;
+        skipStrings?: boolean;
+        skipTemplates?: boolean;
+        skipRegExps?: boolean;
+        skipHTMLAttributeValues?: boolean;
+        skipHTMLTextContents?: boolean;
+    }
+];
+type VueNoLoneTemplate = [] | [
+    {
+        ignoreAccessible?: boolean;
+    }
+];
+type VueNoMultiSpaces = [] | [
+    {
+        ignoreProperties?: boolean;
+    }
+];
+type VueNoMutatingProps = [] | [
+    {
+        shallowOnly?: boolean;
+    }
+];
+type VueNoParsingError = [] | [
+    {
+        "abrupt-closing-of-empty-comment"?: boolean;
+        "absence-of-digits-in-numeric-character-reference"?: boolean;
+        "cdata-in-html-content"?: boolean;
+        "character-reference-outside-unicode-range"?: boolean;
+        "control-character-in-input-stream"?: boolean;
+        "control-character-reference"?: boolean;
+        "eof-before-tag-name"?: boolean;
+        "eof-in-cdata"?: boolean;
+        "eof-in-comment"?: boolean;
+        "eof-in-tag"?: boolean;
+        "incorrectly-closed-comment"?: boolean;
+        "incorrectly-opened-comment"?: boolean;
+        "invalid-first-character-of-tag-name"?: boolean;
+        "missing-attribute-value"?: boolean;
+        "missing-end-tag-name"?: boolean;
+        "missing-semicolon-after-character-reference"?: boolean;
+        "missing-whitespace-between-attributes"?: boolean;
+        "nested-comment"?: boolean;
+        "noncharacter-character-reference"?: boolean;
+        "noncharacter-in-input-stream"?: boolean;
+        "null-character-reference"?: boolean;
+        "surrogate-character-reference"?: boolean;
+        "surrogate-in-input-stream"?: boolean;
+        "unexpected-character-in-attribute-name"?: boolean;
+        "unexpected-character-in-unquoted-attribute-value"?: boolean;
+        "unexpected-equals-sign-before-attribute-name"?: boolean;
+        "unexpected-null-character"?: boolean;
+        "unexpected-question-mark-instead-of-tag-name"?: boolean;
+        "unexpected-solidus-in-tag"?: boolean;
+        "unknown-named-character-reference"?: boolean;
+        "end-tag-with-attributes"?: boolean;
+        "duplicate-attribute"?: boolean;
+        "end-tag-with-trailing-solidus"?: boolean;
+        "non-void-html-element-start-tag-with-trailing-solidus"?: boolean;
+        "x-invalid-end-tag"?: boolean;
+        "x-invalid-namespace"?: boolean;
+    }
+];
+type VueNoPotentialComponentOptionTypo = [] | [
+    {
+        presets?: ("all" | "vue" | "vue-router" | "nuxt")[];
+        custom?: string[];
+        threshold?: number;
+    }
+];
+type VueNoRequiredPropWithDefault = [] | [
+    {
+        autofix?: boolean;
+    }
+];
+type VueNoReservedComponentNames = [] | [
+    {
+        disallowVueBuiltInComponents?: boolean;
+        disallowVue3BuiltInComponents?: boolean;
+    }
+];
+type VueNoReservedKeys = [] | [
+    {
+        reserved?: unknown[];
+        groups?: unknown[];
+    }
+];
+type VueNoReservedProps = [] | [
+    {
+        vueVersion?: (2 | 3);
+    }
+];
+type VueNoRestrictedBlock = (string | {
+    element: string;
+    message?: string;
+})[];
+type VueNoRestrictedCallAfterAwait = {
+    module: string;
+    path?: (string | string[]);
+    message?: string;
+}[];
+type VueNoRestrictedClass = string[];
+type VueNoRestrictedComponentNames = (string | {
+    name: string;
+    message?: string;
+    suggest?: string;
+})[];
+type VueNoRestrictedComponentOptions = (string | string[] | {
+    name: (string | string[]);
+    message?: string;
+})[];
+type VueNoRestrictedCustomEvent = (string | {
+    event: string;
+    message?: string;
+    suggest?: string;
+})[];
+type VueNoRestrictedHtmlElements = (string | {
+    element: string;
+    message?: string;
+})[];
+type VueNoRestrictedProps = (string | {
+    name: string;
+    message?: string;
+    suggest?: string;
+})[];
+type VueNoRestrictedStaticAttribute = (string | {
+    key: string;
+    value?: (string | true);
+    element?: string;
+    message?: string;
+})[];
+type VueNoRestrictedSyntax = (string | {
+    selector: string;
+    message?: string;
+})[];
+type VueNoRestrictedVBind = ((string | null) | {
+    argument: (string | null);
+    modifiers?: ("prop" | "camel" | "sync" | "attr")[];
+    element?: string;
+    message?: string;
+})[];
+type VueNoRestrictedVOn = ((string | null) | {
+    argument: (string | null);
+    element?: string;
+    message?: string;
+    modifiers?: [("prevent" | "stop" | "capture" | "self" | "once" | "passive"), ...(("prevent" | "stop" | "capture" | "self" | "once" | "passive"))[]];
+})[];
+type VueNoStaticInlineStyles = [] | [
+    {
+        allowBinding?: boolean;
+    }
+];
+type VueNoTemplateShadow = [] | [
+    {
+        allow?: string[];
+    }
+];
+type VueNoTemplateTargetBlank = [] | [
+    {
+        allowReferrer?: boolean;
+        enforceDynamicLinks?: ("always" | "never");
+    }
+];
+type VueNoUndefComponents = [] | [
+    {
+        ignorePatterns?: unknown[];
+    }
+];
+type VueNoUndefProperties = [] | [
+    {
+        ignores?: string[];
+    }
+];
+type VueNoUnsupportedFeatures = [] | [
+    {
+        version?: string;
+        ignores?: ("slot-scope-attribute" | "dynamic-directive-arguments" | "v-slot" | "script-setup" | "style-css-vars-injection" | "v-model-argument" | "v-model-custom-modifiers" | "v-is" | "is-attribute-with-vue-prefix" | "v-memo" | "v-bind-prop-modifier-shorthand" | "v-bind-attr-modifier" | "define-options" | "define-slots" | "define-model" | "v-bind-same-name-shorthand")[];
+    }
+];
+type VueNoUnusedComponents = [] | [
+    {
+        ignoreWhenBindingPresent?: boolean;
+    }
+];
+type VueNoUnusedProperties = [] | [
+    {
+        groups?: ("props" | "data" | "asyncData" | "computed" | "methods" | "setup")[];
+        deepData?: boolean;
+        ignorePublicMembers?: boolean;
+        unreferencedOptions?: ("unknownMemberAsUnreferenced" | "returnAsUnreferenced")[];
+    }
+];
+type VueNoUnusedVars = [] | [
+    {
+        ignorePattern?: string;
+    }
+];
+type VueNoUseVIfWithVFor = [] | [
+    {
+        allowUsingIterationVar?: boolean;
+    }
+];
+type VueNoUselessMustaches = [] | [
+    {
+        ignoreIncludesComment?: boolean;
+        ignoreStringEscape?: boolean;
+    }
+];
+type VueNoUselessVBind = [] | [
+    {
+        ignoreIncludesComment?: boolean;
+        ignoreStringEscape?: boolean;
+    }
+];
+type VueNoVTextVHtmlOnComponent = [] | [
+    {
+        allow?: string[];
+    }
+];
+type VueObjectCurlyNewline = [] | [
+    ((("always" | "never") | {
+        multiline?: boolean;
+        minProperties?: number;
+        consistent?: boolean;
+    }) | {
+        ObjectExpression?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ObjectPattern?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ImportDeclaration?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+        ExportDeclaration?: (("always" | "never") | {
+            multiline?: boolean;
+            minProperties?: number;
+            consistent?: boolean;
+        });
+    })
+];
+type VueObjectCurlySpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        arraysInObjects?: boolean;
+        objectsInObjects?: boolean;
+    }
+];
+type VueObjectPropertyNewline = [] | [
+    {
+        allowAllPropertiesOnSameLine?: boolean;
+        allowMultiplePropertiesPerLine?: boolean;
+    }
+];
+type VueObjectShorthand = ([] | [("always" | "methods" | "properties" | "never" | "consistent" | "consistent-as-needed")] | [] | [("always" | "methods" | "properties")] | [
+    ("always" | "methods" | "properties"),
+    {
+        avoidQuotes?: boolean;
+    }
+] | [] | [("always" | "methods")] | [
+    ("always" | "methods"),
+    {
+        ignoreConstructors?: boolean;
+        methodsIgnorePattern?: string;
+        avoidQuotes?: boolean;
+        avoidExplicitReturnArrows?: boolean;
+    }
+]);
+type VueOperatorLinebreak = [] | [("after" | "before" | "none" | null)] | [
+    ("after" | "before" | "none" | null),
+    {
+        overrides?: {
+            [k: string]: ("after" | "before" | "none" | "ignore") | undefined;
+        };
+    }
+];
+type VueOrderInComponents = [] | [
+    {
+        order?: unknown[];
+    }
+];
+type VuePaddingLineBetweenBlocks = [] | [("never" | "always")];
+type VuePaddingLineBetweenTags = [] | [
+    {
+        blankLine: ("always" | "never" | "consistent");
+        prev: string;
+        next: string;
+    }[]
+];
+type VuePaddingLinesInComponentDefinition = [] | [
+    (("always" | "never") | {
+        betweenOptions?: ("never" | "always" | "ignore");
+        withinOption?: (("never" | "always" | "ignore") | {
+            [k: string]: (("never" | "always" | "ignore") | {
+                betweenItems?: ("never" | "always" | "ignore");
+                withinEach?: ("never" | "always" | "ignore");
+            });
+        });
+        groupSingleLineProperties?: boolean;
+    })
+];
+type VuePreferTrueAttributeShorthand = [] | [("always" | "never")];
+type VuePropNameCasing = [] | [("camelCase" | "snake_case")];
+type VueQuoteProps = ([] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [
+    ("always" | "as-needed" | "consistent" | "consistent-as-needed"),
+    {
+        keywords?: boolean;
+        unnecessary?: boolean;
+        numbers?: boolean;
+    }
+]);
+type VueRequireDirectExport = [] | [
+    {
+        disallowFunctionalComponentFunction?: boolean;
+    }
+];
+type VueRequireExplicitEmits = [] | [
+    {
+        allowProps?: boolean;
+    }
+];
+type VueRequireMacroVariableName = [] | [
+    {
+        defineProps?: string;
+        defineEmits?: string;
+        defineSlots?: string;
+        useSlots?: string;
+        useAttrs?: string;
+    }
+];
+type VueRequirePropComment = [] | [
+    {
+        type?: ("JSDoc" | "line" | "block" | "any");
+    }
+];
+type VueReturnInComputedProperty = [] | [
+    {
+        treatUndefinedAsUnspecified?: boolean;
+    }
+];
+type VueScriptIndent = [] | [(number | "tab")] | [
+    (number | "tab"),
+    {
+        baseIndent?: number;
+        switchCase?: number;
+        ignores?: (string & {
+            [k: string]: unknown | undefined;
+        } & {
+            [k: string]: unknown | undefined;
+        })[];
+    }
+];
+type VueSinglelineHtmlElementContentNewline = [] | [
+    {
+        ignoreWhenNoAttributes?: boolean;
+        ignoreWhenEmpty?: boolean;
+        ignores?: string[];
+        externalIgnores?: string[];
+    }
+];
+type VueSortKeys = [] | [("asc" | "desc")] | [
+    ("asc" | "desc"),
+    {
+        caseSensitive?: boolean;
+        ignoreChildrenOf?: unknown[];
+        ignoreGrandchildrenOf?: unknown[];
+        minKeys?: number;
+        natural?: boolean;
+        runOutsideVue?: boolean;
+    }
+];
+type VueSpaceInParens = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        exceptions?: ("{}" | "[]" | "()" | "empty")[];
+    }
+];
+type VueSpaceInfixOps = [] | [
+    {
+        int32Hint?: boolean;
+    }
+];
+type VueSpaceUnaryOps = [] | [
+    {
+        words?: boolean;
+        nonwords?: boolean;
+        overrides?: {
+            [k: string]: boolean | undefined;
+        };
+    }
+];
+type VueTemplateCurlySpacing = [] | [("always" | "never")];
+type VueThisInTemplate = [] | [("always" | "never")];
+type VueVBindStyle = [] | [("shorthand" | "longform")] | [
+    ("shorthand" | "longform"),
+    {
+        sameNameShorthand?: ("always" | "never" | "ignore");
+    }
+];
+type VueVForDelimiterStyle = [] | [("in" | "of")];
+type VueVOnEventHyphenation = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        autofix?: boolean;
+        ignore?: (string & {
+            [k: string]: unknown | undefined;
+        } & {
+            [k: string]: unknown | undefined;
+        })[];
+    }
+];
+type VueVOnFunctionCall = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        ignoreIncludesComment?: boolean;
+    }
+];
+type VueVOnHandlerStyle = [] | [(("inline" | "inline-function") | ["method", ("inline" | "inline-function")])] | [
+    (("inline" | "inline-function") | ["method", ("inline" | "inline-function")]),
+    {
+        ignoreIncludesComment?: boolean;
+    }
+];
+type VueVOnStyle = [] | [("shorthand" | "longform")];
+type VueVSlotStyle = [] | [
+    (("shorthand" | "longform") | {
+        atComponent?: ("shorthand" | "longform" | "v-slot");
+        default?: ("shorthand" | "longform" | "v-slot");
+        named?: ("shorthand" | "longform");
+    })
+];
+type VueValidVOn = [] | [
+    {
+        modifiers?: unknown[];
+    }
+];
+type VueValidVSlot = [] | [
+    {
+        allowModifiers?: boolean;
+    }
+];
+export {};