├── .github
    ├── FUNDING.yml
    └── workflows
    │   ├── release.yml
    │   └── ci.yml
├── .npmrc
├── CONTRIBUTING.md
├── .gitignore
├── eslint.config.js
├── tsconfig.json
├── test
    ├── input
    │   ├── invalid-json-schema-plugin.ts
    │   └── plugin-with-schema-ids.ts
    ├── output
    │   ├── invalid-json-schema-plugin.d.ts
    │   ├── plugin-with-schema-ids.d.ts
    │   ├── no-rule-meta.d.ts
    │   ├── jsx-a11y.d.ts
    │   ├── plugins.d.ts
    │   └── flat-config-vue.d.ts
    └── index.test.ts
├── pnpm-workspace.yaml
├── LICENSE
├── .vscode
    └── settings.json
├── package.json
├── src
    ├── index.ts
    └── core.ts
└── README.md


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: [antfu]
2 | 


--------------------------------------------------------------------------------
/.npmrc:
--------------------------------------------------------------------------------
1 | ignore-workspace-root-check=true
2 | shell-emulator=true
3 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | Please refer to https://github.com/antfu/contribute
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .cache
 2 | .DS_Store
 3 | .idea
 4 | *.log
 5 | *.tgz
 6 | coverage
 7 | dist
 8 | lib-cov
 9 | logs
10 | node_modules
11 | temp
12 | eslint-typegen.d.ts
13 | 


--------------------------------------------------------------------------------
/eslint.config.js:
--------------------------------------------------------------------------------
 1 | // @ts-check
 2 | /// <reference path="./eslint-typegen.d.ts" />
 3 | import antfu from '@antfu/eslint-config'
 4 | // eslint-disable-next-line antfu/no-import-dist
 5 | import typegen from './dist/index.mjs'
 6 | 
 7 | export default typegen(await antfu({
 8 |   vue: true,
 9 |   typescript: true,
10 |   pnpm: true,
11 | }),
12 | )
13 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "ESNext",
 4 |     "lib": ["ESNext"],
 5 |     "module": "ESNext",
 6 |     "moduleResolution": "Bundler",
 7 |     "resolveJsonModule": true,
 8 |     "strict": true,
 9 |     "strictNullChecks": true,
10 |     "esModuleInterop": true,
11 |     "skipDefaultLibCheck": true,
12 |     "skipLibCheck": true
13 |   },
14 |   "include": ["**/*.ts"],
15 |   "exclude": ["node_modules", "dist"]
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | 
 3 | permissions:
 4 |   contents: write
 5 | 
 6 | on:
 7 |   push:
 8 |     tags:
 9 |       - 'v*'
10 | 
11 | jobs:
12 |   release:
13 |     runs-on: ubuntu-latest
14 |     steps:
15 |       - uses: actions/checkout@v3
16 |         with:
17 |           fetch-depth: 0
18 | 
19 |       - name: Install pnpm
20 |         uses: pnpm/action-setup@v2
21 | 
22 |       - name: Set node
23 |         uses: actions/setup-node@v3
24 |         with:
25 |           node-version: lts/*
26 | 
27 |       - run: npx changelogithub
28 |         env:
29 |           GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
30 | 


--------------------------------------------------------------------------------
/test/input/invalid-json-schema-plugin.ts:
--------------------------------------------------------------------------------
 1 | import type { ESLint, Rule } from 'eslint'
 2 | 
 3 | export const invalidJsonSchemaPlugin: ESLint.Plugin = {
 4 |   rules: {
 5 |     'invalid-json-schema-rule': {
 6 |       create: () => null as unknown as Rule.RuleListener,
 7 |       meta: {
 8 |         docs: {
 9 |           description: 'This rules points to a non-existing schema',
10 |         },
11 |         schema: {
12 |           allOf: [
13 |             {
14 |               $ref: '#/definitions/some-definition-that-does-not-exist',
15 |             },
16 |           ],
17 |           type: 'object',
18 |         },
19 |       },
20 |     },
21 |   },
22 | }
23 | 


--------------------------------------------------------------------------------
/test/output/invalid-json-schema-plugin.d.ts:
--------------------------------------------------------------------------------
 1 | /* eslint-disable */
 2 | /* prettier-ignore */
 3 | import type { Linter } from 'eslint'
 4 | 
 5 | declare module 'eslint' {
 6 |   namespace Linter {
 7 |     interface RulesRecord extends RuleOptions {}
 8 |   }
 9 | }
10 | 
11 | export interface RuleOptions {
12 |   /**
13 |    * This rules points to a non-existing schema
14 |    */
15 |   'invalid-json-schema-plugin/invalid-json-schema-rule'?: Linter.RuleEntry<InvalidJsonSchemaPluginInvalidJsonSchemaRule>
16 | }
17 | 
18 | /* ======= Declarations ======= */
19 | // ----- invalid-json-schema-plugin/invalid-json-schema-rule -----
20 | type InvalidJsonSchemaPluginInvalidJsonSchemaRule = unknown


--------------------------------------------------------------------------------
/test/output/plugin-with-schema-ids.d.ts:
--------------------------------------------------------------------------------
 1 | /* eslint-disable */
 2 | /* prettier-ignore */
 3 | import type { Linter } from 'eslint'
 4 | 
 5 | declare module 'eslint' {
 6 |   namespace Linter {
 7 |     interface RulesRecord extends RuleOptions {}
 8 |   }
 9 | }
10 | 
11 | export interface RuleOptions {
12 |   'plugin/schema-with-id-at-root'?: Linter.RuleEntry<_PluginSchemaWithIdAtRootSchemaId>
13 | }
14 | 
15 | /* ======= Declarations ======= */
16 | // ----- plugin/schema-with-id-at-root -----
17 | type _PluginSchemaWithIdAtRootAId = string
18 | type _PluginSchemaWithIdAtRootC1Id = string
19 | interface _PluginSchemaWithIdAtRootSchemaId {
20 |   a?: _PluginSchemaWithIdAtRootAId
21 |   b?: _PluginSchemaWithIdAtRootBId
22 |   c?: {
23 |     c1?: _PluginSchemaWithIdAtRootC1Id
24 |   }
25 |   d?: {
26 |     da?: string
27 |   }
28 | }
29 | interface _PluginSchemaWithIdAtRootBId {
30 |   b1?: string
31 | }


--------------------------------------------------------------------------------
/pnpm-workspace.yaml:
--------------------------------------------------------------------------------
 1 | packages:
 2 |   - playground
 3 |   - docs
 4 |   - packages/*
 5 |   - examples/*
 6 | catalogs:
 7 |   dev:
 8 |     '@antfu/eslint-config': ^4.19.0
 9 |     '@antfu/ni': ^25.0.0
10 |     '@types/json-schema': ^7.0.15
11 |     '@types/node': ^24.1.0
12 |     bumpp: ^10.2.0
13 |     eslint: ^9.31.0
14 |     lint-staged: ^16.1.2
15 |     pnpm: ^10.13.1
16 |     simple-git-hooks: ^2.13.0
17 |     tsx: ^4.20.3
18 |     typescript: ^5.8.3
19 |     unbuild: ^3.6.0
20 |     vite: ^7.0.6
21 |   prod:
22 |     json-schema-to-typescript-lite: ^15.0.0
23 |     ohash: ^2.0.11
24 |   test:
25 |     '@typescript-eslint/eslint-plugin': ^8.38.0
26 |     eslint-plugin-antfu: ^3.1.1
27 |     eslint-plugin-import-x: ^4.16.1
28 |     eslint-plugin-jsx-a11y: ^6.10.2
29 |     eslint-plugin-you-dont-need-lodash-underscore: ^6.14.0
30 |     vitest: ^3.2.4
31 | onlyBuiltDependencies:
32 |   - esbuild
33 |   - simple-git-hooks
34 |   - unrs-resolver
35 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Anthony Fu <https://github.com/antfu>
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   // Enable the ESlint flat config support
 3 |   "eslint.experimental.useFlatConfig": true,
 4 | 
 5 |   // Disable the default formatter, use eslint instead
 6 |   "prettier.enable": false,
 7 |   "editor.formatOnSave": false,
 8 | 
 9 |   // Auto fix
10 |   "editor.codeActionsOnSave": {
11 |     "source.fixAll": "explicit",
12 |     "source.organizeImports": "never"
13 |   },
14 | 
15 |   // Silent the stylistic rules in you IDE, but still auto fix them
16 |   "eslint.rules.customizations": [
17 |     { "rule": "style/*", "severity": "off" },
18 |     { "rule": "*-indent", "severity": "off" },
19 |     { "rule": "*-spacing", "severity": "off" },
20 |     { "rule": "*-spaces", "severity": "off" },
21 |     { "rule": "*-order", "severity": "off" },
22 |     { "rule": "*-dangle", "severity": "off" },
23 |     { "rule": "*-newline", "severity": "off" },
24 |     { "rule": "*quotes", "severity": "off" },
25 |     { "rule": "*semi", "severity": "off" }
26 |   ],
27 | 
28 |   // Enable eslint for all supported languages
29 |   "eslint.validate": [
30 |     "javascript",
31 |     "javascriptreact",
32 |     "typescript",
33 |     "typescriptreact",
34 |     "vue",
35 |     "html",
36 |     "markdown",
37 |     "json",
38 |     "jsonc",
39 |     "yaml"
40 |   ]
41 | }
42 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - main
 7 | 
 8 |   pull_request:
 9 |     branches:
10 |       - main
11 | 
12 | jobs:
13 |   lint:
14 |     runs-on: ubuntu-latest
15 |     steps:
16 |       - uses: actions/checkout@v3
17 | 
18 |       - name: Install pnpm
19 |         uses: pnpm/action-setup@v2
20 | 
21 |       - name: Set node
22 |         uses: actions/setup-node@v3
23 |         with:
24 |           node-version: lts/*
25 | 
26 |       - name: Setup
27 |         run: npm i -g @antfu/ni
28 | 
29 |       - name: Install
30 |         run: nci
31 | 
32 |       - name: Lint
33 |         run: nr lint
34 | 
35 |       - name: Typecheck
36 |         run: nr typecheck
37 | 
38 |   test:
39 |     runs-on: ${{ matrix.os }}
40 | 
41 |     strategy:
42 |       matrix:
43 |         node: [lts/*]
44 |         os: [ubuntu-latest, windows-latest, macos-latest]
45 |       fail-fast: false
46 | 
47 |     steps:
48 |       - uses: actions/checkout@v3
49 | 
50 |       - name: Install pnpm
51 |         uses: pnpm/action-setup@v2
52 | 
53 |       - name: Set node ${{ matrix.node }}
54 |         uses: actions/setup-node@v3
55 |         with:
56 |           node-version: ${{ matrix.node }}
57 | 
58 |       - name: Setup
59 |         run: npm i -g @antfu/ni
60 | 
61 |       - name: Install
62 |         run: nci
63 | 
64 |       - name: Build
65 |         run: nr build
66 | 
67 |       - name: Test
68 |         run: nr test
69 | 


--------------------------------------------------------------------------------
/test/input/plugin-with-schema-ids.ts:
--------------------------------------------------------------------------------
 1 | import type { ESLint, Rule } from 'eslint'
 2 | 
 3 | export const pluginWithSchemaIds: ESLint.Plugin = {
 4 |   rules: {
 5 |     'schema-with-id-at-root': {
 6 |       create: () => null as unknown as Rule.RuleListener,
 7 |       meta: {
 8 |         schema: {
 9 |           id: 'schemaId',
10 |           type: 'object',
11 |           additionalProperties: false,
12 |           properties: {
13 |             a: {
14 |               id: 'aId',
15 |               type: 'string',
16 |             },
17 |             b: {
18 |               id: 'bId',
19 |               additionalProperties: false,
20 |               type: 'object',
21 |               properties: {
22 |                 b1: {
23 |                   type: 'string',
24 |                 },
25 |               },
26 |             },
27 |             c: {
28 |               additionalProperties: false,
29 |               type: 'object',
30 |               properties: {
31 |                 c1: {
32 |                   type: 'string',
33 |                   id: 'c1Id',
34 |                 },
35 |               },
36 |             },
37 |             d: {
38 |               additionalProperties: false,
39 |               type: 'object',
40 |               properties: {
41 |                 da: {
42 |                   type: 'string',
43 |                 },
44 |               },
45 |             },
46 |           },
47 |         },
48 |       },
49 |     },
50 |   },
51 | }
52 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "eslint-typegen",
 3 |   "type": "module",
 4 |   "version": "2.3.0",
 5 |   "packageManager": "pnpm@10.13.1",
 6 |   "description": "Generate types from ESLint rule schemas automatically, with auto-completion and type-checking for rule options.",
 7 |   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
 8 |   "license": "MIT",
 9 |   "funding": "https://github.com/sponsors/antfu",
10 |   "homepage": "https://github.com/antfu/eslint-typegen#readme",
11 |   "repository": {
12 |     "type": "git",
13 |     "url": "git+https://github.com/antfu/eslint-typegen.git"
14 |   },
15 |   "bugs": "https://github.com/antfu/eslint-typegen/issues",
16 |   "keywords": [
17 |     "eslint"
18 |   ],
19 |   "sideEffects": false,
20 |   "exports": {
21 |     ".": "./dist/index.mjs",
22 |     "./core": "./dist/core.mjs"
23 |   },
24 |   "main": "./dist/index.mjs",
25 |   "module": "./dist/index.mjs",
26 |   "types": "./dist/index.d.mts",
27 |   "files": [
28 |     "dist"
29 |   ],
30 |   "scripts": {
31 |     "build": "unbuild",
32 |     "dev": "unbuild --stub",
33 |     "lint": "nr build && eslint .",
34 |     "prepublishOnly": "nr build",
35 |     "release": "bumpp && pnpm publish",
36 |     "start": "tsx src/index.ts",
37 |     "test": "vitest",
38 |     "typecheck": "tsc --noEmit",
39 |     "prepare": "simple-git-hooks"
40 |   },
41 |   "peerDependencies": {
42 |     "eslint": "^9.0.0"
43 |   },
44 |   "dependencies": {
45 |     "json-schema-to-typescript-lite": "catalog:prod",
46 |     "ohash": "catalog:prod"
47 |   },
48 |   "devDependencies": {
49 |     "@antfu/eslint-config": "catalog:dev",
50 |     "@antfu/ni": "catalog:dev",
51 |     "@types/json-schema": "catalog:dev",
52 |     "@types/node": "catalog:dev",
53 |     "@typescript-eslint/eslint-plugin": "catalog:test",
54 |     "bumpp": "catalog:dev",
55 |     "eslint": "catalog:dev",
56 |     "eslint-plugin-antfu": "catalog:test",
57 |     "eslint-plugin-import-x": "catalog:test",
58 |     "eslint-plugin-jsx-a11y": "catalog:test",
59 |     "eslint-plugin-you-dont-need-lodash-underscore": "catalog:test",
60 |     "lint-staged": "catalog:dev",
61 |     "pnpm": "catalog:dev",
62 |     "simple-git-hooks": "catalog:dev",
63 |     "tsx": "catalog:dev",
64 |     "typescript": "catalog:dev",
65 |     "unbuild": "catalog:dev",
66 |     "vite": "catalog:dev",
67 |     "vitest": "catalog:test"
68 |   },
69 |   "simple-git-hooks": {
70 |     "pre-commit": "pnpm lint-staged"
71 |   },
72 |   "lint-staged": {
73 |     "*": "eslint --fix"
74 |   }
75 | }
76 | 


--------------------------------------------------------------------------------
/test/index.test.ts:
--------------------------------------------------------------------------------
 1 | import { vue } from '@antfu/eslint-config'
 2 | import { expect, it } from 'vitest'
 3 | import { flatConfigsToRulesDTS, pluginsToRulesDTS } from '../src/core'
 4 | import { invalidJsonSchemaPlugin } from './input/invalid-json-schema-plugin'
 5 | import { pluginWithSchemaIds } from './input/plugin-with-schema-ids'
 6 | 
 7 | it('pluginsToRuleOptions', async () => {
 8 |   await expect(await pluginsToRulesDTS({
 9 |     // @ts-expect-error missing types
10 |     import: await import('eslint-plugin-import-x').then(m => m.default),
11 |     antfu: await import('eslint-plugin-antfu').then(m => m.default),
12 |   }))
13 |     .toMatchFileSnapshot('./output/plugins.d.ts')
14 | })
15 | 
16 | it('pluginsToRuleOptions ts expect no warnings', async () => {
17 |   await pluginsToRulesDTS({
18 |     // @ts-expect-error missing types
19 |     ts: await import('@typescript-eslint/eslint-plugin').then(m => m.default),
20 |   })
21 | })
22 | 
23 | it('core rules', async () => {
24 |   const { builtinRules } = await import('eslint/use-at-your-own-risk')
25 | 
26 |   await expect(await pluginsToRulesDTS({
27 |     '': { rules: Object.fromEntries(builtinRules.entries()) },
28 |   }))
29 |     .toMatchFileSnapshot('./output/core-rules.d.ts')
30 | })
31 | 
32 | it('invalid JSON schema plugin', async () => {
33 |   await expect(await pluginsToRulesDTS({
34 |     'invalid-json-schema-plugin': invalidJsonSchemaPlugin,
35 |   }))
36 |     .toMatchFileSnapshot('./output/invalid-json-schema-plugin.d.ts')
37 | })
38 | 
39 | it('json schema with ids', async () => {
40 |   await expect(await pluginsToRulesDTS({
41 |     plugin: pluginWithSchemaIds,
42 |   }))
43 |     .toMatchFileSnapshot('./output/plugin-with-schema-ids.d.ts')
44 | })
45 | 
46 | it('flatConfigsToRuleOptions', async () => {
47 |   await expect(await flatConfigsToRulesDTS(await vue() as any))
48 |     .toMatchFileSnapshot('./output/flat-config-vue.d.ts')
49 | })
50 | 
51 | it('jsx-a11y', async () => {
52 |   await expect(await pluginsToRulesDTS({
53 |     // @ts-expect-error missing types
54 |     'jsx-a11y': await import('eslint-plugin-jsx-a11y').then(m => m.default),
55 |   }))
56 |     .toMatchFileSnapshot('./output/jsx-a11y.d.ts')
57 | })
58 | 
59 | it('no rule `meta`', async () => {
60 |   await expect(await pluginsToRulesDTS({
61 |     // @ts-expect-error missing types
62 |     'you-dont-need-lodash-underscore': await import('eslint-plugin-you-dont-need-lodash-underscore').then(m => m.default),
63 |   }))
64 |     .toMatchFileSnapshot('./output/no-rule-meta.d.ts')
65 | })
66 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
 1 | import type { Linter } from 'eslint'
 2 | import type { FlatConfigsToRulesOptions } from './core'
 3 | import { existsSync } from 'node:fs'
 4 | import fs from 'node:fs/promises'
 5 | import { hash as makeHash } from 'ohash'
 6 | import { version } from '../package.json'
 7 | import { flatConfigsToPlugins, pluginsToRulesDTS } from './core'
 8 | 
 9 | export interface TypeGenOptions extends FlatConfigsToRulesOptions {
10 |   /**
11 |    * Include core rules in the generated types.
12 |    *
13 |    * @default true
14 |    */
15 |   includeCoreRules?: boolean
16 | 
17 |   /**
18 |    * Path to the generated types file.
19 |    */
20 |   dtsPath?: string
21 | }
22 | 
23 | /**
24 |  * Wrap with resolved flat configs to generates types for rules.
25 |  */
26 | export default async function typegen(
27 |   configs: Promise<Linter.Config[]> | Linter.Config[],
28 |   options: TypeGenOptions = {},
29 | ): Promise<Linter.Config[]> {
30 |   const {
31 |     includeCoreRules = true,
32 |     dtsPath = 'eslint-typegen.d.ts',
33 |   } = options
34 | 
35 |   const resolved = await configs
36 |   let configsInput = resolved
37 | 
38 |   if (includeCoreRules) {
39 |     const { builtinRules } = await import('eslint/use-at-your-own-risk')
40 |     configsInput = [
41 |       {
42 |         plugins: {
43 |           '': { rules: Object.fromEntries(builtinRules.entries()) },
44 |         },
45 |       },
46 |       ...configsInput,
47 |     ]
48 |   }
49 | 
50 |   const plugins = await flatConfigsToPlugins(configsInput, options)
51 |   const configNames = configsInput.flatMap(c => c.name).filter(Boolean) as string[]
52 |   const hashSource = [
53 |     // version of eslint-typegen
54 |     version,
55 |     // plugins name and version
56 |     ...Object.entries(plugins)
57 |       .map(([n, p]) => [p.meta?.name, p.meta?.version].filter(Boolean).join('@') || p.name || n)
58 |       .sort(),
59 |     // config names
60 |     ...configNames,
61 |   ].join(' ')
62 |   const hash = makeHash(hashSource)
63 | 
64 |   const previousHash = existsSync(dtsPath)
65 |     ? (await fs.readFile(dtsPath, 'utf-8')).match(/\/\* eslint-typegen-hash: (\S*) \*\//)?.[1]?.trim()
66 |     : undefined
67 | 
68 |   if (previousHash !== hash) {
69 |     const dts = [
70 |       '/* This file is generated by eslint-typegen, for augmenting rules types in ESLint */',
71 |       '/* You might want to include this file in tsconfig.json but excluded from git */',
72 |       `/* eslint-typegen-hash: ${hash} */`,
73 |       '',
74 |       await pluginsToRulesDTS(plugins, {
75 |         ...options,
76 |         configNames,
77 |       }),
78 |     ].join('\n')
79 | 
80 |     fs.writeFile(dtsPath, dts, 'utf-8')
81 |   }
82 | 
83 |   return resolved
84 | }
85 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # eslint-typegen
 2 | 
 3 | [![npm version][npm-version-src]][npm-version-href]
 4 | [![npm downloads][npm-downloads-src]][npm-downloads-href]
 5 | [![bundle][bundle-src]][bundle-href]
 6 | [![JSDocs][jsdocs-src]][jsdocs-href]
 7 | [![License][license-src]][license-href]
 8 | 
 9 | Generate types from ESLint rule schemas automatically, with auto-completion and type-checking for rule options.
10 | 
11 | ![](https://github.com/antfu/eslint-typegen/assets/11247099/642ffdc0-c662-4f3b-9237-16d776be1c3e)
12 | 
13 | > Btw, if you are using [`@antfu/eslint-config`](https://github.com/antfu/eslint-config), you may NOT need to setup this, as the types for rules [are already shipped with the package](https://github.com/antfu/eslint-config/blob/95963ac345d27cd06a4eeb5ebc16e1848cb2fd81/scripts/typegen.ts#L29-L33).
14 | 
15 | ## Usage
16 | 
17 | ```bash
18 | npm i eslint-typegen
19 | ```
20 | 
21 | In your `eslint.config.mjs`, wrap the export with `typegen` function:
22 | 
23 | ```ts
24 | // @ts-check
25 | /// <reference path="./eslint-typegen.d.ts" />
26 | import typegen from 'eslint-typegen'
27 | 
28 | export default typegen(
29 |   [
30 |     // ...your normal eslint flat config
31 |   ]
32 | )
33 | ```
34 | 
35 | Run ESLint once, an `eslint-typegen.d.ts` file will be generated to augment ESLint's `Linter.RulesRecord` types, to provide you with auto-completion and type-checking for your ESLint rules configuration based on the ESLint plugins you are using.
36 | 
37 | > It will caluclate the hash of the plugins meta from your flat config, and only regenerate the types when they changes. If you want to force regenerate the types, you can delete the `eslint-typegen.d.ts` file and run ESLint again.
38 | 
39 | ## Low-level API
40 | 
41 | You can find low-level APIs in the `eslint-typegen/core` modules.
42 | 
43 | ```ts
44 | import fs from 'node:fs/promises'
45 | import pluginTs from '@typescript-eslint/eslint-plugin'
46 | import pluginN from 'eslint-plugin-n'
47 | import { pluginsToRulesDTS } from 'eslint-typegen/core'
48 | 
49 | const dts = await pluginsToRulesDTS({
50 |   '@typescript-eslint': pluginTs,
51 |   'n': pluginN,
52 | })
53 | 
54 | await fs.writeFile('eslint-typegen.d.ts', dts)
55 | ```
56 | 
57 | This can be useful if you want to have more control over the generation process, or even bundle the types with your config package. For example, [here](https://github.com/antfu/eslint-config/blob/95963ac345d27cd06a4eeb5ebc16e1848cb2fd81/scripts/typegen.ts#L29-L33) is how [`@antfu/eslint-config`](https://github.com/antfu/eslint-config) does.
58 | 
59 | ## How it works
60 | 
61 | Thanks to that [ESLint requires rules to provide the JSONSchema for options](https://eslint.org/docs/latest/extend/custom-rules#options-schemas), we could leverage that to generate types with [`json-schema-to-typescript`](https://github.com/bcherny/json-schema-to-typescript). With the new flat config allowing you to execute the code with fully resolved configs, we managed to sneak in the type generation process on the fly.
62 | 
63 | ## Credits
64 | 
65 | The initial idea comes from [@Shinigami92](https://github.com/Shinigami92) via his work on [`eslint-define-config`](https://github.com/eslint-types/eslint-define-config), thanks to him!
66 | 
67 | ## Sponsors
68 | 
69 | <p align="center">
70 |   <a href="https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg">
71 |     <img src='https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg'/>
72 |   </a>
73 | </p>
74 | 
75 | ## License
76 | 
77 | [MIT](./LICENSE) License © 2023-PRESENT [Anthony Fu](https://github.com/antfu)
78 | 
79 | <!-- Badges -->
80 | 
81 | [npm-version-src]: https://img.shields.io/npm/v/eslint-typegen?style=flat&colorA=080f12&colorB=1fa669
82 | [npm-version-href]: https://npmjs.com/package/eslint-typegen
83 | [npm-downloads-src]: https://img.shields.io/npm/dm/eslint-typegen?style=flat&colorA=080f12&colorB=1fa669
84 | [npm-downloads-href]: https://npmjs.com/package/eslint-typegen
85 | [bundle-src]: https://img.shields.io/bundlephobia/minzip/eslint-typegen?style=flat&colorA=080f12&colorB=1fa669&label=minzip
86 | [bundle-href]: https://bundlephobia.com/result?p=eslint-typegen
87 | [license-src]: https://img.shields.io/github/license/antfu/eslint-typegen.svg?style=flat&colorA=080f12&colorB=1fa669
88 | [license-href]: https://github.com/antfu/eslint-typegen/blob/main/LICENSE
89 | [jsdocs-src]: https://img.shields.io/badge/jsdocs-reference-080f12?style=flat&colorA=080f12&colorB=1fa669
90 | [jsdocs-href]: https://www.jsdocs.io/package/eslint-typegen
91 | 


--------------------------------------------------------------------------------
/test/output/no-rule-meta.d.ts:
--------------------------------------------------------------------------------
 1 | /* eslint-disable */
 2 | /* prettier-ignore */
 3 | import type { Linter } from 'eslint'
 4 | 
 5 | declare module 'eslint' {
 6 |   namespace Linter {
 7 |     interface RulesRecord extends RuleOptions {}
 8 |   }
 9 | }
10 | 
11 | export interface RuleOptions {
12 |   'you-dont-need-lodash-underscore/all'?: Linter.RuleEntry<[]>
13 |   'you-dont-need-lodash-underscore/any'?: Linter.RuleEntry<[]>
14 |   'you-dont-need-lodash-underscore/assign'?: Linter.RuleEntry<[]>
15 |   'you-dont-need-lodash-underscore/bind'?: Linter.RuleEntry<[]>
16 |   'you-dont-need-lodash-underscore/capitalize'?: Linter.RuleEntry<[]>
17 |   'you-dont-need-lodash-underscore/cast-array'?: Linter.RuleEntry<[]>
18 |   'you-dont-need-lodash-underscore/clone-deep'?: Linter.RuleEntry<[]>
19 |   'you-dont-need-lodash-underscore/collect'?: Linter.RuleEntry<[]>
20 |   'you-dont-need-lodash-underscore/concat'?: Linter.RuleEntry<[]>
21 |   'you-dont-need-lodash-underscore/contains'?: Linter.RuleEntry<[]>
22 |   'you-dont-need-lodash-underscore/defaults'?: Linter.RuleEntry<[]>
23 |   'you-dont-need-lodash-underscore/detect'?: Linter.RuleEntry<[]>
24 |   'you-dont-need-lodash-underscore/drop'?: Linter.RuleEntry<[]>
25 |   'you-dont-need-lodash-underscore/drop-right'?: Linter.RuleEntry<[]>
26 |   'you-dont-need-lodash-underscore/each'?: Linter.RuleEntry<[]>
27 |   'you-dont-need-lodash-underscore/ends-with'?: Linter.RuleEntry<[]>
28 |   'you-dont-need-lodash-underscore/entries'?: Linter.RuleEntry<[]>
29 |   'you-dont-need-lodash-underscore/every'?: Linter.RuleEntry<[]>
30 |   'you-dont-need-lodash-underscore/extend-own'?: Linter.RuleEntry<[]>
31 |   'you-dont-need-lodash-underscore/fill'?: Linter.RuleEntry<[]>
32 |   'you-dont-need-lodash-underscore/filter'?: Linter.RuleEntry<[]>
33 |   'you-dont-need-lodash-underscore/find'?: Linter.RuleEntry<[]>
34 |   'you-dont-need-lodash-underscore/find-index'?: Linter.RuleEntry<[]>
35 |   'you-dont-need-lodash-underscore/first'?: Linter.RuleEntry<[]>
36 |   'you-dont-need-lodash-underscore/flatten'?: Linter.RuleEntry<[]>
37 |   'you-dont-need-lodash-underscore/foldl'?: Linter.RuleEntry<[]>
38 |   'you-dont-need-lodash-underscore/foldr'?: Linter.RuleEntry<[]>
39 |   'you-dont-need-lodash-underscore/for-each'?: Linter.RuleEntry<[]>
40 |   'you-dont-need-lodash-underscore/get'?: Linter.RuleEntry<[]>
41 |   'you-dont-need-lodash-underscore/head'?: Linter.RuleEntry<[]>
42 |   'you-dont-need-lodash-underscore/includes'?: Linter.RuleEntry<[]>
43 |   'you-dont-need-lodash-underscore/index-of'?: Linter.RuleEntry<[]>
44 |   'you-dont-need-lodash-underscore/inject'?: Linter.RuleEntry<[]>
45 |   'you-dont-need-lodash-underscore/is-array'?: Linter.RuleEntry<[]>
46 |   'you-dont-need-lodash-underscore/is-array-buffer'?: Linter.RuleEntry<[]>
47 |   'you-dont-need-lodash-underscore/is-date'?: Linter.RuleEntry<[]>
48 |   'you-dont-need-lodash-underscore/is-finite'?: Linter.RuleEntry<[]>
49 |   'you-dont-need-lodash-underscore/is-function'?: Linter.RuleEntry<[]>
50 |   'you-dont-need-lodash-underscore/is-integer'?: Linter.RuleEntry<[]>
51 |   'you-dont-need-lodash-underscore/is-nan'?: Linter.RuleEntry<[]>
52 |   'you-dont-need-lodash-underscore/is-nil'?: Linter.RuleEntry<[]>
53 |   'you-dont-need-lodash-underscore/is-null'?: Linter.RuleEntry<[]>
54 |   'you-dont-need-lodash-underscore/is-string'?: Linter.RuleEntry<[]>
55 |   'you-dont-need-lodash-underscore/is-undefined'?: Linter.RuleEntry<[]>
56 |   'you-dont-need-lodash-underscore/join'?: Linter.RuleEntry<[]>
57 |   'you-dont-need-lodash-underscore/keys'?: Linter.RuleEntry<[]>
58 |   'you-dont-need-lodash-underscore/last'?: Linter.RuleEntry<[]>
59 |   'you-dont-need-lodash-underscore/last-index-of'?: Linter.RuleEntry<[]>
60 |   'you-dont-need-lodash-underscore/map'?: Linter.RuleEntry<[]>
61 |   'you-dont-need-lodash-underscore/omit'?: Linter.RuleEntry<[]>
62 |   'you-dont-need-lodash-underscore/pad-end'?: Linter.RuleEntry<[]>
63 |   'you-dont-need-lodash-underscore/pad-start'?: Linter.RuleEntry<[]>
64 |   'you-dont-need-lodash-underscore/pairs'?: Linter.RuleEntry<[]>
65 |   'you-dont-need-lodash-underscore/reduce'?: Linter.RuleEntry<[]>
66 |   'you-dont-need-lodash-underscore/reduce-right'?: Linter.RuleEntry<[]>
67 |   'you-dont-need-lodash-underscore/repeat'?: Linter.RuleEntry<[]>
68 |   'you-dont-need-lodash-underscore/replace'?: Linter.RuleEntry<[]>
69 |   'you-dont-need-lodash-underscore/reverse'?: Linter.RuleEntry<[]>
70 |   'you-dont-need-lodash-underscore/select'?: Linter.RuleEntry<[]>
71 |   'you-dont-need-lodash-underscore/size'?: Linter.RuleEntry<[]>
72 |   'you-dont-need-lodash-underscore/slice'?: Linter.RuleEntry<[]>
73 |   'you-dont-need-lodash-underscore/some'?: Linter.RuleEntry<[]>
74 |   'you-dont-need-lodash-underscore/split'?: Linter.RuleEntry<[]>
75 |   'you-dont-need-lodash-underscore/starts-with'?: Linter.RuleEntry<[]>
76 |   'you-dont-need-lodash-underscore/take-right'?: Linter.RuleEntry<[]>
77 |   'you-dont-need-lodash-underscore/throttle'?: Linter.RuleEntry<[]>
78 |   'you-dont-need-lodash-underscore/to-lower'?: Linter.RuleEntry<[]>
79 |   'you-dont-need-lodash-underscore/to-pairs'?: Linter.RuleEntry<[]>
80 |   'you-dont-need-lodash-underscore/to-upper'?: Linter.RuleEntry<[]>
81 |   'you-dont-need-lodash-underscore/trim'?: Linter.RuleEntry<[]>
82 |   'you-dont-need-lodash-underscore/union-by'?: Linter.RuleEntry<[]>
83 |   'you-dont-need-lodash-underscore/uniq'?: Linter.RuleEntry<[]>
84 |   'you-dont-need-lodash-underscore/values'?: Linter.RuleEntry<[]>
85 | }
86 | 
87 | /* ======= Declarations ======= */
88 | 


--------------------------------------------------------------------------------
/src/core.ts:
--------------------------------------------------------------------------------
  1 | import type { ESLint, Linter, Rule } from 'eslint'
  2 | import type { JSONSchema4 } from 'json-schema'
  3 | import type { Options as CompileOptions } from 'json-schema-to-typescript-lite'
  4 | import { compile as compileSchema, normalizeIdentifier } from 'json-schema-to-typescript-lite'
  5 | 
  6 | export interface RulesTypeGenOptions {
  7 |   /**
  8 |    * Insert type imports for the generated types.
  9 |    *
 10 |    * @default true
 11 |    */
 12 |   includeTypeImports?: boolean
 13 | 
 14 |   /**
 15 |    * Include comments to disable ESLint and Prettier.
 16 |    *
 17 |    * @default true
 18 |    */
 19 |   includeIgnoreComments?: boolean
 20 | 
 21 |   /**
 22 |    * Augment the interface to ESLint's `Linter.RulesRecord`.
 23 |    *
 24 |    * @default true
 25 |    */
 26 |   includeAugmentation?: boolean
 27 | 
 28 |   /**
 29 |    * Augment the `DefaultConfigNamesMap` interface for `eslint-flat-config-utils`
 30 |    * For auto-completion of config names etc.
 31 |    *
 32 |    * @see https://github.com/antfu/eslint-flat-config-utils
 33 |    * @default false
 34 |    */
 35 |   augmentFlatConfigUtils?: boolean
 36 | 
 37 |   /**
 38 |    * The name of the exported type.
 39 |    *
 40 |    * @default 'RuleOptions'
 41 |    */
 42 |   exportTypeName?: string
 43 | 
 44 |   /**
 45 |    * Options for json-schema-to-typescript
 46 |    */
 47 |   compileOptions?: Partial<CompileOptions>
 48 | }
 49 | 
 50 | export interface FlatConfigsToPluginsOptions {
 51 |   filterConfig?: (config: Linter.Config) => boolean
 52 |   filterPlugin?: (name: string, plugin: ESLint.Plugin) => boolean
 53 | }
 54 | 
 55 | export interface FlatConfigsToRulesOptions
 56 |   extends RulesTypeGenOptions, FlatConfigsToPluginsOptions {
 57 | }
 58 | 
 59 | export async function flatConfigsToPlugins(
 60 |   configs: Linter.Config[],
 61 |   options: FlatConfigsToPluginsOptions = {},
 62 | ) {
 63 |   const plugins: Record<string, ESLint.Plugin> = {}
 64 |   for (const config of configs) {
 65 |     if (!config.plugins)
 66 |       continue
 67 |     if (options.filterConfig?.(config) === false)
 68 |       continue
 69 |     for (const [name, plugin] of Object.entries(config.plugins)) {
 70 |       if (options.filterPlugin?.(name, plugin) === false)
 71 |         continue
 72 |       plugins[name] = plugin
 73 |     }
 74 |   }
 75 |   return plugins
 76 | }
 77 | 
 78 | /**
 79 |  * Generate types for rules from an array of ESLint configurations.
 80 |  */
 81 | export async function flatConfigsToRulesDTS(
 82 |   configs: Linter.Config[],
 83 |   options: FlatConfigsToRulesOptions = {},
 84 | ) {
 85 |   return pluginsToRulesDTS(
 86 |     await flatConfigsToPlugins(configs, options),
 87 |     options,
 88 |   )
 89 | }
 90 | 
 91 | /**
 92 |  * Generate types for rule from an object of ESLint plugins.
 93 |  */
 94 | export async function pluginsToRulesDTS(
 95 |   plugins: Record<string, ESLint.Plugin>,
 96 |   options: RulesTypeGenOptions & { configNames?: string[] } = {},
 97 | ) {
 98 |   const {
 99 |     includeTypeImports = true,
100 |     includeIgnoreComments = true,
101 |     includeAugmentation = true,
102 |     augmentFlatConfigUtils = false,
103 |     exportTypeName = 'RuleOptions',
104 |     compileOptions = {},
105 |     configNames = [],
106 |   } = options
107 | 
108 |   const rules: [name: string, rule: Rule.RuleModule][] = []
109 | 
110 |   for (const [pluginName, plugin] of Object.entries(plugins)) {
111 |     for (const [ruleName, rule] of Object.entries(plugin.rules || {})) {
112 |       if (rule?.meta == null || typeof rule.meta === 'object') {
113 |         rules.push([
114 |           pluginName
115 |             ? `${pluginName}/${ruleName}`
116 |             : ruleName,
117 |           rule,
118 |         ])
119 |       }
120 |     }
121 |   }
122 | 
123 |   rules.sort(([a], [b]) => a.localeCompare(b))
124 |   const resolved = await Promise.all(rules
125 |     .map(([name, rule]) => compileRule(name, rule, compileOptions)))
126 | 
127 |   const exports = [
128 |     ...(includeIgnoreComments
129 |       ? [
130 |           '/* eslint-disable */',
131 |           '/* prettier-ignore */',
132 |         ]
133 |       : []),
134 |     ...(includeTypeImports
135 |       ? [
136 |           'import type { Linter } from \'eslint\'',
137 |         ]
138 |       : []),
139 |     ...(includeAugmentation
140 |       ? [
141 |           '',
142 |           `declare module 'eslint' {`,
143 |           `  namespace Linter {`,
144 |           `    interface RulesRecord extends ${exportTypeName} {}`,
145 |           `  }`,
146 |           `}`,
147 |         ]
148 |       : []),
149 |     ...(augmentFlatConfigUtils && configNames.length
150 |       ? [
151 |           '',
152 |           '// @ts-ignore - In case the package is not installed',
153 |           `declare module 'eslint-flat-config-utils' {`,
154 |           `  interface DefaultConfigNamesMap {`,
155 |           ...configNames.map(name => `    '${name}'?: true,`),
156 |           `  }`,
157 |           `}`,
158 |         ]
159 |       : []),
160 |     '',
161 |     `export interface ${exportTypeName} {`,
162 |     ...resolved.flatMap(({ typeName, name, jsdoc }) => [
163 |       jsdoc?.length
164 |         ? `  /**\n${jsdoc.map(i => `   * ${i}`).join('\n').replaceAll(/\*\//g, '*\\/')}\n   */`
165 |         : undefined,
166 |       `  '${name}'?: Linter.RuleEntry<${typeName}>`,
167 |     ]).filter(Boolean),
168 |     `}`,
169 |   ]
170 |   const typeDeclarations = resolved.flatMap(({ typeDeclarations }) => typeDeclarations).join('\n')
171 | 
172 |   return [
173 |     ...exports,
174 |     '',
175 |     '/* ======= Declarations ======= */',
176 |     typeDeclarations,
177 |   ].join('\n')
178 | }
179 | 
180 | export async function compileRule(
181 |   ruleName: string,
182 |   rule: Rule.RuleModule,
183 |   compileOptions: Partial<CompileOptions> = {},
184 | ) {
185 |   const meta = rule.meta ?? {}
186 |   let schemas = meta.schema as JSONSchema4[] ?? []
187 |   if (!Array.isArray(schemas))
188 |     schemas = [schemas]
189 | 
190 |   const id = normalizeIdentifier(ruleName)
191 | 
192 |   const jsdoc: string[] = []
193 |   if (meta.docs?.description)
194 |     jsdoc.push(meta.docs.description)
195 |   if (meta.docs?.url)
196 |     jsdoc.push(`@see ${meta.docs.url}`)
197 |   if (meta.deprecated)
198 |     jsdoc.push('@deprecated')
199 | 
200 |   if (!meta.schema || !schemas.length) {
201 |     return {
202 |       jsdoc,
203 |       name: ruleName,
204 |       typeName: '[]',
205 |       typeDeclarations: [],
206 |     }
207 |   }
208 | 
209 |   let lines: string[] = []
210 | 
211 |   const schema: JSONSchema4 = Array.isArray(meta.schema)
212 |     ? { type: 'array', items: meta.schema, definitions: meta.schema?.[0]?.definitions }
213 |     : meta.schema
214 | 
215 |   let overriddenRootSchemaId: string | undefined
216 |   let isRootSchema = true
217 | 
218 |   try {
219 |     const compiled = await compileSchema(schema, id, {
220 |       unreachableDefinitions: false,
221 |       strictIndexSignatures: true,
222 |       customName(schema, keyName) {
223 |         const canOverrideRootSchemaId = isRootSchema
224 |         isRootSchema = false
225 | 
226 |         const resolved = schema.title || schema.$id || keyName
227 |         if (resolved === id)
228 |           return id
229 |         if (!resolved)
230 |           return undefined!
231 | 
232 |         const normalizedName = `_${normalizeIdentifier(`${id}_${resolved}`)}`
233 |         if (canOverrideRootSchemaId)
234 |           overriddenRootSchemaId = normalizedName
235 | 
236 |         return normalizedName
237 |       },
238 |       ...compileOptions,
239 |     })
240 |     lines.push(
241 |       compiled
242 |         .replace(/\/\*[\s\S]*?\*\//g, ''),
243 |     )
244 |   }
245 |   catch (error) {
246 |     console.warn(`Failed to compile schema ${ruleName} for rule ${ruleName}. Falling back to unknown.`)
247 |     console.error(error)
248 |     lines.push(`export type ${id} = unknown\n`)
249 |   }
250 | 
251 |   lines = lines
252 |     .join('\n')
253 |     .split('\n')
254 |     .map(line => line.replace(/^(export )/, ''))
255 |     .filter(Boolean)
256 | 
257 |   lines.unshift(`// ----- ${ruleName} -----`)
258 | 
259 |   return {
260 |     name: ruleName,
261 |     jsdoc,
262 |     typeName: overriddenRootSchemaId ?? id,
263 |     typeDeclarations: lines,
264 |   }
265 | }
266 | 


--------------------------------------------------------------------------------
/test/output/jsx-a11y.d.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable */
  2 | /* prettier-ignore */
  3 | import type { Linter } from 'eslint'
  4 | 
  5 | declare module 'eslint' {
  6 |   namespace Linter {
  7 |     interface RulesRecord extends RuleOptions {}
  8 |   }
  9 | }
 10 | 
 11 | export interface RuleOptions {
 12 |   /**
 13 |    * Enforce emojis are wrapped in `<span>` and provide screen reader access.
 14 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/accessible-emoji.md
 15 |    * @deprecated
 16 |    */
 17 |   'jsx-a11y/accessible-emoji'?: Linter.RuleEntry<JsxA11YAccessibleEmoji>
 18 |   /**
 19 |    * Enforce all elements that require alternative text have meaningful information to relay back to end user.
 20 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/alt-text.md
 21 |    */
 22 |   'jsx-a11y/alt-text'?: Linter.RuleEntry<JsxA11YAltText>
 23 |   /**
 24 |    * Enforce `<a>` text to not exactly match "click here", "here", "link", or "a link".
 25 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-ambiguous-text.md
 26 |    */
 27 |   'jsx-a11y/anchor-ambiguous-text'?: Linter.RuleEntry<JsxA11YAnchorAmbiguousText>
 28 |   /**
 29 |    * Enforce all anchors to contain accessible content.
 30 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-has-content.md
 31 |    */
 32 |   'jsx-a11y/anchor-has-content'?: Linter.RuleEntry<JsxA11YAnchorHasContent>
 33 |   /**
 34 |    * Enforce all anchors are valid, navigable elements.
 35 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/anchor-is-valid.md
 36 |    */
 37 |   'jsx-a11y/anchor-is-valid'?: Linter.RuleEntry<JsxA11YAnchorIsValid>
 38 |   /**
 39 |    * Enforce elements with aria-activedescendant are tabbable.
 40 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-activedescendant-has-tabindex.md
 41 |    */
 42 |   'jsx-a11y/aria-activedescendant-has-tabindex'?: Linter.RuleEntry<JsxA11YAriaActivedescendantHasTabindex>
 43 |   /**
 44 |    * Enforce all `aria-*` props are valid.
 45 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-props.md
 46 |    */
 47 |   'jsx-a11y/aria-props'?: Linter.RuleEntry<JsxA11YAriaProps>
 48 |   /**
 49 |    * Enforce ARIA state and property values are valid.
 50 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-proptypes.md
 51 |    */
 52 |   'jsx-a11y/aria-proptypes'?: Linter.RuleEntry<JsxA11YAriaProptypes>
 53 |   /**
 54 |    * Enforce that elements with ARIA roles must use a valid, non-abstract ARIA role.
 55 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-role.md
 56 |    */
 57 |   'jsx-a11y/aria-role'?: Linter.RuleEntry<JsxA11YAriaRole>
 58 |   /**
 59 |    * Enforce that elements that do not support ARIA roles, states, and properties do not have those attributes.
 60 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/aria-unsupported-elements.md
 61 |    */
 62 |   'jsx-a11y/aria-unsupported-elements'?: Linter.RuleEntry<JsxA11YAriaUnsupportedElements>
 63 |   /**
 64 |    * Enforce that autocomplete attributes are used correctly.
 65 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/autocomplete-valid.md
 66 |    */
 67 |   'jsx-a11y/autocomplete-valid'?: Linter.RuleEntry<JsxA11YAutocompleteValid>
 68 |   /**
 69 |    * Enforce a clickable non-interactive element has at least one keyboard event listener.
 70 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/click-events-have-key-events.md
 71 |    */
 72 |   'jsx-a11y/click-events-have-key-events'?: Linter.RuleEntry<JsxA11YClickEventsHaveKeyEvents>
 73 |   /**
 74 |    * Enforce that a control (an interactive element) has a text label.
 75 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/control-has-associated-label.md
 76 |    */
 77 |   'jsx-a11y/control-has-associated-label'?: Linter.RuleEntry<JsxA11YControlHasAssociatedLabel>
 78 |   /**
 79 |    * Enforce heading (`h1`, `h2`, etc) elements contain accessible content.
 80 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/heading-has-content.md
 81 |    */
 82 |   'jsx-a11y/heading-has-content'?: Linter.RuleEntry<JsxA11YHeadingHasContent>
 83 |   /**
 84 |    * Enforce `<html>` element has `lang` prop.
 85 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/html-has-lang.md
 86 |    */
 87 |   'jsx-a11y/html-has-lang'?: Linter.RuleEntry<JsxA11YHtmlHasLang>
 88 |   /**
 89 |    * Enforce iframe elements have a title attribute.
 90 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/iframe-has-title.md
 91 |    */
 92 |   'jsx-a11y/iframe-has-title'?: Linter.RuleEntry<JsxA11YIframeHasTitle>
 93 |   /**
 94 |    * Enforce `<img>` alt prop does not contain the word "image", "picture", or "photo".
 95 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/img-redundant-alt.md
 96 |    */
 97 |   'jsx-a11y/img-redundant-alt'?: Linter.RuleEntry<JsxA11YImgRedundantAlt>
 98 |   /**
 99 |    * Enforce that elements with interactive handlers like `onClick` must be focusable.
100 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/interactive-supports-focus.md
101 |    */
102 |   'jsx-a11y/interactive-supports-focus'?: Linter.RuleEntry<JsxA11YInteractiveSupportsFocus>
103 |   /**
104 |    * Enforce that a `label` tag has a text label and an associated control.
105 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/blob/main/docs/rules/label-has-associated-control.md
106 |    */
107 |   'jsx-a11y/label-has-associated-control'?: Linter.RuleEntry<JsxA11YLabelHasAssociatedControl>
108 |   /**
109 |    * Enforce that `<label>` elements have the `htmlFor` prop.
110 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/label-has-for.md
111 |    * @deprecated
112 |    */
113 |   'jsx-a11y/label-has-for'?: Linter.RuleEntry<JsxA11YLabelHasFor>
114 |   /**
115 |    * Enforce lang attribute has a valid value.
116 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/lang.md
117 |    */
118 |   'jsx-a11y/lang'?: Linter.RuleEntry<JsxA11YLang>
119 |   /**
120 |    * Enforces that `<audio>` and `<video>` elements must have a `<track>` for captions.
121 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/media-has-caption.md
122 |    */
123 |   'jsx-a11y/media-has-caption'?: Linter.RuleEntry<JsxA11YMediaHasCaption>
124 |   /**
125 |    * Enforce that `onMouseOver`/`onMouseOut` are accompanied by `onFocus`/`onBlur` for keyboard-only users.
126 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/mouse-events-have-key-events.md
127 |    */
128 |   'jsx-a11y/mouse-events-have-key-events'?: Linter.RuleEntry<JsxA11YMouseEventsHaveKeyEvents>
129 |   /**
130 |    * Enforce that the `accessKey` prop is not used on any element to avoid complications with keyboard commands used by a screen reader.
131 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-access-key.md
132 |    */
133 |   'jsx-a11y/no-access-key'?: Linter.RuleEntry<JsxA11YNoAccessKey>
134 |   /**
135 |    * Disallow `aria-hidden="true"` from being set on focusable elements.
136 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-aria-hidden-on-focusable.md
137 |    */
138 |   'jsx-a11y/no-aria-hidden-on-focusable'?: Linter.RuleEntry<JsxA11YNoAriaHiddenOnFocusable>
139 |   /**
140 |    * Enforce autoFocus prop is not used.
141 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-autofocus.md
142 |    */
143 |   'jsx-a11y/no-autofocus'?: Linter.RuleEntry<JsxA11YNoAutofocus>
144 |   /**
145 |    * Enforce distracting elements are not used.
146 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-distracting-elements.md
147 |    */
148 |   'jsx-a11y/no-distracting-elements'?: Linter.RuleEntry<JsxA11YNoDistractingElements>
149 |   /**
150 |    * Interactive elements should not be assigned non-interactive roles.
151 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-interactive-element-to-noninteractive-role.md
152 |    */
153 |   'jsx-a11y/no-interactive-element-to-noninteractive-role'?: Linter.RuleEntry<JsxA11YNoInteractiveElementToNoninteractiveRole>
154 |   /**
155 |    * Non-interactive elements should not be assigned mouse or keyboard event listeners.
156 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-noninteractive-element-interactions.md
157 |    */
158 |   'jsx-a11y/no-noninteractive-element-interactions'?: Linter.RuleEntry<JsxA11YNoNoninteractiveElementInteractions>
159 |   /**
160 |    * Non-interactive elements should not be assigned interactive roles.
161 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-noninteractive-element-to-interactive-role.md
162 |    */
163 |   'jsx-a11y/no-noninteractive-element-to-interactive-role'?: Linter.RuleEntry<JsxA11YNoNoninteractiveElementToInteractiveRole>
164 |   /**
165 |    * `tabIndex` should only be declared on interactive elements.
166 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-noninteractive-tabindex.md
167 |    */
168 |   'jsx-a11y/no-noninteractive-tabindex'?: Linter.RuleEntry<JsxA11YNoNoninteractiveTabindex>
169 |   /**
170 |    * Enforce usage of `onBlur` over `onChange` on select menus for accessibility.
171 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-onchange.md
172 |    * @deprecated
173 |    */
174 |   'jsx-a11y/no-onchange'?: Linter.RuleEntry<JsxA11YNoOnchange>
175 |   /**
176 |    * Enforce explicit role property is not the same as implicit/default role property on element.
177 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-redundant-roles.md
178 |    */
179 |   'jsx-a11y/no-redundant-roles'?: Linter.RuleEntry<JsxA11YNoRedundantRoles>
180 |   /**
181 |    * Enforce that non-interactive, visible elements (such as `<div>`) that have click handlers use the role attribute.
182 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/no-static-element-interactions.md
183 |    */
184 |   'jsx-a11y/no-static-element-interactions'?: Linter.RuleEntry<JsxA11YNoStaticElementInteractions>
185 |   /**
186 |    * Enforces using semantic DOM elements over the ARIA `role` property.
187 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/prefer-tag-over-role.md
188 |    */
189 |   'jsx-a11y/prefer-tag-over-role'?: Linter.RuleEntry<JsxA11YPreferTagOverRole>
190 |   /**
191 |    * Enforce that elements with ARIA roles must have all required attributes for that role.
192 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/role-has-required-aria-props.md
193 |    */
194 |   'jsx-a11y/role-has-required-aria-props'?: Linter.RuleEntry<JsxA11YRoleHasRequiredAriaProps>
195 |   /**
196 |    * Enforce that elements with explicit or implicit roles defined contain only `aria-*` properties supported by that `role`.
197 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/role-supports-aria-props.md
198 |    */
199 |   'jsx-a11y/role-supports-aria-props'?: Linter.RuleEntry<JsxA11YRoleSupportsAriaProps>
200 |   /**
201 |    * Enforce `scope` prop is only used on `<th>` elements.
202 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/scope.md
203 |    */
204 |   'jsx-a11y/scope'?: Linter.RuleEntry<JsxA11YScope>
205 |   /**
206 |    * Enforce `tabIndex` value is not greater than zero.
207 |    * @see https://github.com/jsx-eslint/eslint-plugin-jsx-a11y/tree/HEAD/docs/rules/tabindex-no-positive.md
208 |    */
209 |   'jsx-a11y/tabindex-no-positive'?: Linter.RuleEntry<JsxA11YTabindexNoPositive>
210 | }
211 | 
212 | /* ======= Declarations ======= */
213 | // ----- jsx-a11y/accessible-emoji -----
214 | type JsxA11YAccessibleEmoji = []|[{
215 |   [k: string]: unknown | undefined
216 | }]
217 | // ----- jsx-a11y/alt-text -----
218 | type JsxA11YAltText = []|[{
219 |   elements?: string[]
220 |   img?: string[]
221 |   object?: string[]
222 |   area?: string[]
223 |   "input[type=\"image\"]"?: string[]
224 |   [k: string]: unknown | undefined
225 | }]
226 | // ----- jsx-a11y/anchor-ambiguous-text -----
227 | type JsxA11YAnchorAmbiguousText = []|[{
228 |   words?: string[]
229 |   [k: string]: unknown | undefined
230 | }]
231 | // ----- jsx-a11y/anchor-has-content -----
232 | type JsxA11YAnchorHasContent = []|[{
233 |   components?: string[]
234 |   [k: string]: unknown | undefined
235 | }]
236 | // ----- jsx-a11y/anchor-is-valid -----
237 | type JsxA11YAnchorIsValid = []|[{
238 |   components?: string[]
239 |   specialLink?: string[]
240 |   
241 |   aspects?: [("noHref" | "invalidHref" | "preferButton"), ...(("noHref" | "invalidHref" | "preferButton"))[]]
242 |   [k: string]: unknown | undefined
243 | }]
244 | // ----- jsx-a11y/aria-activedescendant-has-tabindex -----
245 | type JsxA11YAriaActivedescendantHasTabindex = []|[{
246 |   [k: string]: unknown | undefined
247 | }]
248 | // ----- jsx-a11y/aria-props -----
249 | type JsxA11YAriaProps = []|[{
250 |   [k: string]: unknown | undefined
251 | }]
252 | // ----- jsx-a11y/aria-proptypes -----
253 | type JsxA11YAriaProptypes = []|[{
254 |   [k: string]: unknown | undefined
255 | }]
256 | // ----- jsx-a11y/aria-role -----
257 | type JsxA11YAriaRole = []|[{
258 |   allowedInvalidRoles?: string[]
259 |   ignoreNonDOM?: boolean
260 |   [k: string]: unknown | undefined
261 | }]
262 | // ----- jsx-a11y/aria-unsupported-elements -----
263 | type JsxA11YAriaUnsupportedElements = []|[{
264 |   [k: string]: unknown | undefined
265 | }]
266 | // ----- jsx-a11y/autocomplete-valid -----
267 | type JsxA11YAutocompleteValid = []|[{
268 |   inputComponents?: string[]
269 |   [k: string]: unknown | undefined
270 | }]
271 | // ----- jsx-a11y/click-events-have-key-events -----
272 | type JsxA11YClickEventsHaveKeyEvents = []|[{
273 |   [k: string]: unknown | undefined
274 | }]
275 | // ----- jsx-a11y/control-has-associated-label -----
276 | type JsxA11YControlHasAssociatedLabel = []|[{
277 |   labelAttributes?: string[]
278 |   controlComponents?: string[]
279 |   ignoreElements?: string[]
280 |   ignoreRoles?: string[]
281 |   
282 |   depth?: number
283 |   [k: string]: unknown | undefined
284 | }]
285 | // ----- jsx-a11y/heading-has-content -----
286 | type JsxA11YHeadingHasContent = []|[{
287 |   components?: string[]
288 |   [k: string]: unknown | undefined
289 | }]
290 | // ----- jsx-a11y/html-has-lang -----
291 | type JsxA11YHtmlHasLang = []|[{
292 |   [k: string]: unknown | undefined
293 | }]
294 | // ----- jsx-a11y/iframe-has-title -----
295 | type JsxA11YIframeHasTitle = []|[{
296 |   [k: string]: unknown | undefined
297 | }]
298 | // ----- jsx-a11y/img-redundant-alt -----
299 | type JsxA11YImgRedundantAlt = []|[{
300 |   components?: string[]
301 |   words?: string[]
302 |   [k: string]: unknown | undefined
303 | }]
304 | // ----- jsx-a11y/interactive-supports-focus -----
305 | type JsxA11YInteractiveSupportsFocus = []|[{
306 |   
307 |   tabbable?: ("button" | "checkbox" | "columnheader" | "combobox" | "grid" | "gridcell" | "link" | "listbox" | "menu" | "menubar" | "menuitem" | "menuitemcheckbox" | "menuitemradio" | "option" | "progressbar" | "radio" | "radiogroup" | "row" | "rowheader" | "scrollbar" | "searchbox" | "slider" | "spinbutton" | "switch" | "tab" | "tablist" | "textbox" | "tree" | "treegrid" | "treeitem" | "doc-backlink" | "doc-biblioref" | "doc-glossref" | "doc-noteref")[]
308 |   [k: string]: unknown | undefined
309 | }]
310 | // ----- jsx-a11y/label-has-associated-control -----
311 | type JsxA11YLabelHasAssociatedControl = []|[{
312 |   labelComponents?: string[]
313 |   labelAttributes?: string[]
314 |   controlComponents?: string[]
315 |   
316 |   assert?: ("htmlFor" | "nesting" | "both" | "either")
317 |   
318 |   depth?: number
319 |   [k: string]: unknown | undefined
320 | }]
321 | // ----- jsx-a11y/label-has-for -----
322 | type JsxA11YLabelHasFor = []|[{
323 |   components?: string[]
324 |   required?: (("nesting" | "id") | {
325 |     
326 |     some: ("nesting" | "id")[]
327 |     [k: string]: unknown | undefined
328 |   } | {
329 |     
330 |     every: ("nesting" | "id")[]
331 |     [k: string]: unknown | undefined
332 |   })
333 |   allowChildren?: boolean
334 |   [k: string]: unknown | undefined
335 | }]
336 | // ----- jsx-a11y/lang -----
337 | type JsxA11YLang = []|[{
338 |   [k: string]: unknown | undefined
339 | }]
340 | // ----- jsx-a11y/media-has-caption -----
341 | type JsxA11YMediaHasCaption = []|[{
342 |   audio?: string[]
343 |   video?: string[]
344 |   track?: string[]
345 |   [k: string]: unknown | undefined
346 | }]
347 | // ----- jsx-a11y/mouse-events-have-key-events -----
348 | type JsxA11YMouseEventsHaveKeyEvents = []|[{
349 |   
350 |   hoverInHandlers?: string[]
351 |   
352 |   hoverOutHandlers?: string[]
353 |   [k: string]: unknown | undefined
354 | }]
355 | // ----- jsx-a11y/no-access-key -----
356 | type JsxA11YNoAccessKey = []|[{
357 |   [k: string]: unknown | undefined
358 | }]
359 | // ----- jsx-a11y/no-aria-hidden-on-focusable -----
360 | type JsxA11YNoAriaHiddenOnFocusable = []|[{
361 |   [k: string]: unknown | undefined
362 | }]
363 | // ----- jsx-a11y/no-autofocus -----
364 | type JsxA11YNoAutofocus = []|[{
365 |   ignoreNonDOM?: boolean
366 |   [k: string]: unknown | undefined
367 | }]
368 | // ----- jsx-a11y/no-distracting-elements -----
369 | type JsxA11YNoDistractingElements = []|[{
370 |   
371 |   elements?: ("marquee" | "blink")[]
372 |   [k: string]: unknown | undefined
373 | }]
374 | // ----- jsx-a11y/no-interactive-element-to-noninteractive-role -----
375 | type JsxA11YNoInteractiveElementToNoninteractiveRole = []|[{
376 |   [k: string]: string[] | undefined
377 | }]
378 | // ----- jsx-a11y/no-noninteractive-element-interactions -----
379 | type JsxA11YNoNoninteractiveElementInteractions = []|[{
380 |   handlers?: string[]
381 |   [k: string]: unknown | undefined
382 | }]
383 | // ----- jsx-a11y/no-noninteractive-element-to-interactive-role -----
384 | type JsxA11YNoNoninteractiveElementToInteractiveRole = []|[{
385 |   [k: string]: string[] | undefined
386 | }]
387 | // ----- jsx-a11y/no-noninteractive-tabindex -----
388 | type JsxA11YNoNoninteractiveTabindex = []|[{
389 |   
390 |   roles?: string[]
391 |   
392 |   tags?: string[]
393 |   [k: string]: unknown | undefined
394 | }]
395 | // ----- jsx-a11y/no-onchange -----
396 | type JsxA11YNoOnchange = []|[{
397 |   [k: string]: unknown | undefined
398 | }]
399 | // ----- jsx-a11y/no-redundant-roles -----
400 | type JsxA11YNoRedundantRoles = []|[{
401 |   [k: string]: string[] | undefined
402 | }]
403 | // ----- jsx-a11y/no-static-element-interactions -----
404 | type JsxA11YNoStaticElementInteractions = []|[{
405 |   handlers?: string[]
406 |   [k: string]: unknown | undefined
407 | }]
408 | // ----- jsx-a11y/prefer-tag-over-role -----
409 | type JsxA11YPreferTagOverRole = []|[{
410 |   [k: string]: unknown | undefined
411 | }]
412 | // ----- jsx-a11y/role-has-required-aria-props -----
413 | type JsxA11YRoleHasRequiredAriaProps = []|[{
414 |   [k: string]: unknown | undefined
415 | }]
416 | // ----- jsx-a11y/role-supports-aria-props -----
417 | type JsxA11YRoleSupportsAriaProps = []|[{
418 |   [k: string]: unknown | undefined
419 | }]
420 | // ----- jsx-a11y/scope -----
421 | type JsxA11YScope = []|[{
422 |   [k: string]: unknown | undefined
423 | }]
424 | // ----- jsx-a11y/tabindex-no-positive -----
425 | type JsxA11YTabindexNoPositive = []|[{
426 |   [k: string]: unknown | undefined
427 | }]


--------------------------------------------------------------------------------
/test/output/plugins.d.ts:
--------------------------------------------------------------------------------
  1 | /* eslint-disable */
  2 | /* prettier-ignore */
  3 | import type { Linter } from 'eslint'
  4 | 
  5 | declare module 'eslint' {
  6 |   namespace Linter {
  7 |     interface RulesRecord extends RuleOptions {}
  8 |   }
  9 | }
 10 | 
 11 | export interface RuleOptions {
 12 |   /**
 13 |    * Having line breaks styles to object, array and named imports
 14 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/consistent-chaining.md
 15 |    */
 16 |   'antfu/consistent-chaining'?: Linter.RuleEntry<AntfuConsistentChaining>
 17 |   /**
 18 |    * Having line breaks styles to object, array and named imports
 19 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/consistent-list-newline.md
 20 |    */
 21 |   'antfu/consistent-list-newline'?: Linter.RuleEntry<AntfuConsistentListNewline>
 22 |   /**
 23 |    * Enforce Anthony's style of curly bracket
 24 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/curly.md
 25 |    */
 26 |   'antfu/curly'?: Linter.RuleEntry<[]>
 27 |   /**
 28 |    * Newline after if
 29 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/if-newline.md
 30 |    */
 31 |   'antfu/if-newline'?: Linter.RuleEntry<[]>
 32 |   /**
 33 |    * Fix duplication in imports
 34 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/import-dedupe.md
 35 |    */
 36 |   'antfu/import-dedupe'?: Linter.RuleEntry<[]>
 37 |   /**
 38 |    * Enforce consistent indentation in `unindent` template tag
 39 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/indent-unindent.md
 40 |    */
 41 |   'antfu/indent-unindent'?: Linter.RuleEntry<AntfuIndentUnindent>
 42 |   /**
 43 |    * Prevent importing modules in `dist` folder
 44 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/no-import-dist.test.ts
 45 |    */
 46 |   'antfu/no-import-dist'?: Linter.RuleEntry<[]>
 47 |   /**
 48 |    * Prevent importing modules in `node_modules` folder by relative or absolute path
 49 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/no-import-node-modules-by-path.test.ts
 50 |    */
 51 |   'antfu/no-import-node-modules-by-path'?: Linter.RuleEntry<[]>
 52 |   /**
 53 |    * Prevent using top-level await
 54 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/no-top-level-await.test.ts
 55 |    */
 56 |   'antfu/no-top-level-await'?: Linter.RuleEntry<[]>
 57 |   /**
 58 |    * Do not use `exports =`
 59 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/no-ts-export-equal.test.ts
 60 |    */
 61 |   'antfu/no-ts-export-equal'?: Linter.RuleEntry<[]>
 62 |   /**
 63 |    * Enforce top-level functions to be declared with function keyword
 64 |    * @see https://github.com/antfu/eslint-plugin-antfu/blob/main/src/rules/top-level-function.md
 65 |    */
 66 |   'antfu/top-level-function'?: Linter.RuleEntry<[]>
 67 |   /**
 68 |    * Enforce or ban the use of inline type-only markers for named imports.
 69 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/consistent-type-specifier-style.md
 70 |    */
 71 |   'import/consistent-type-specifier-style'?: Linter.RuleEntry<ImportConsistentTypeSpecifierStyle>
 72 |   /**
 73 |    * Ensure a default export is present, given a default import.
 74 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/default.md
 75 |    */
 76 |   'import/default'?: Linter.RuleEntry<[]>
 77 |   /**
 78 |    * Enforce a leading comment with the webpackChunkName for dynamic imports.
 79 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/dynamic-import-chunkname.md
 80 |    */
 81 |   'import/dynamic-import-chunkname'?: Linter.RuleEntry<ImportDynamicImportChunkname>
 82 |   /**
 83 |    * Forbid any invalid exports, i.e. re-export of the same name.
 84 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/export.md
 85 |    */
 86 |   'import/export'?: Linter.RuleEntry<[]>
 87 |   /**
 88 |    * Ensure all exports appear after other statements.
 89 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/exports-last.md
 90 |    */
 91 |   'import/exports-last'?: Linter.RuleEntry<[]>
 92 |   /**
 93 |    * Ensure consistent use of file extension within the import path.
 94 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/extensions.md
 95 |    */
 96 |   'import/extensions'?: Linter.RuleEntry<ImportExtensions>
 97 |   /**
 98 |    * Ensure all imports appear before other statements.
 99 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/first.md
100 |    */
101 |   'import/first'?: Linter.RuleEntry<ImportFirst>
102 |   /**
103 |    * Prefer named exports to be grouped together in a single export declaration.
104 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/group-exports.md
105 |    */
106 |   'import/group-exports'?: Linter.RuleEntry<[]>
107 |   /**
108 |    * Replaced by `import-x/first`.
109 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/imports-first.md
110 |    * @deprecated
111 |    */
112 |   'import/imports-first'?: Linter.RuleEntry<ImportImportsFirst>
113 |   /**
114 |    * Enforce the maximum number of dependencies a module can have.
115 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/max-dependencies.md
116 |    */
117 |   'import/max-dependencies'?: Linter.RuleEntry<ImportMaxDependencies>
118 |   /**
119 |    * Ensure named imports correspond to a named export in the remote file.
120 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/named.md
121 |    */
122 |   'import/named'?: Linter.RuleEntry<ImportNamed>
123 |   /**
124 |    * Ensure imported namespaces contain dereferenced properties as they are dereferenced.
125 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/namespace.md
126 |    */
127 |   'import/namespace'?: Linter.RuleEntry<ImportNamespace>
128 |   /**
129 |    * Enforce a newline after import statements.
130 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/newline-after-import.md
131 |    */
132 |   'import/newline-after-import'?: Linter.RuleEntry<ImportNewlineAfterImport>
133 |   /**
134 |    * Forbid import of modules using absolute paths.
135 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-absolute-path.md
136 |    */
137 |   'import/no-absolute-path'?: Linter.RuleEntry<ImportNoAbsolutePath>
138 |   /**
139 |    * Forbid AMD `require` and `define` calls.
140 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-amd.md
141 |    */
142 |   'import/no-amd'?: Linter.RuleEntry<[]>
143 |   /**
144 |    * Forbid anonymous values as default exports.
145 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-anonymous-default-export.md
146 |    */
147 |   'import/no-anonymous-default-export'?: Linter.RuleEntry<ImportNoAnonymousDefaultExport>
148 |   /**
149 |    * Forbid CommonJS `require` calls and `module.exports` or `exports.*`.
150 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-commonjs.md
151 |    */
152 |   'import/no-commonjs'?: Linter.RuleEntry<ImportNoCommonjs>
153 |   /**
154 |    * Forbid a module from importing a module with a dependency path back to itself.
155 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-cycle.md
156 |    */
157 |   'import/no-cycle'?: Linter.RuleEntry<ImportNoCycle>
158 |   /**
159 |    * Forbid default exports.
160 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-default-export.md
161 |    */
162 |   'import/no-default-export'?: Linter.RuleEntry<[]>
163 |   /**
164 |    * Forbid imported names marked with `@deprecated` documentation tag.
165 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-deprecated.md
166 |    */
167 |   'import/no-deprecated'?: Linter.RuleEntry<[]>
168 |   /**
169 |    * Forbid repeated import of the same module in multiple places.
170 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-duplicates.md
171 |    */
172 |   'import/no-duplicates'?: Linter.RuleEntry<ImportNoDuplicates>
173 |   /**
174 |    * Forbid `require()` calls with expressions.
175 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-dynamic-require.md
176 |    */
177 |   'import/no-dynamic-require'?: Linter.RuleEntry<ImportNoDynamicRequire>
178 |   /**
179 |    * Forbid empty named import blocks.
180 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-empty-named-blocks.md
181 |    */
182 |   'import/no-empty-named-blocks'?: Linter.RuleEntry<[]>
183 |   /**
184 |    * Forbid the use of extraneous packages.
185 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-extraneous-dependencies.md
186 |    */
187 |   'import/no-extraneous-dependencies'?: Linter.RuleEntry<ImportNoExtraneousDependencies>
188 |   /**
189 |    * Forbid import statements with CommonJS module.exports.
190 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-import-module-exports.md
191 |    */
192 |   'import/no-import-module-exports'?: Linter.RuleEntry<ImportNoImportModuleExports>
193 |   /**
194 |    * Forbid importing the submodules of other modules.
195 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-internal-modules.md
196 |    */
197 |   'import/no-internal-modules'?: Linter.RuleEntry<ImportNoInternalModules>
198 |   /**
199 |    * Forbid the use of mutable exports with `var` or `let`.
200 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-mutable-exports.md
201 |    */
202 |   'import/no-mutable-exports'?: Linter.RuleEntry<[]>
203 |   /**
204 |    * Forbid use of exported name as identifier of default export.
205 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-named-as-default.md
206 |    */
207 |   'import/no-named-as-default'?: Linter.RuleEntry<[]>
208 |   /**
209 |    * Forbid use of exported name as property of default export.
210 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-named-as-default-member.md
211 |    */
212 |   'import/no-named-as-default-member'?: Linter.RuleEntry<[]>
213 |   /**
214 |    * Forbid named default exports.
215 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-named-default.md
216 |    */
217 |   'import/no-named-default'?: Linter.RuleEntry<[]>
218 |   /**
219 |    * Forbid named exports.
220 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-named-export.md
221 |    */
222 |   'import/no-named-export'?: Linter.RuleEntry<[]>
223 |   /**
224 |    * Forbid namespace (a.k.a. "wildcard" `*`) imports.
225 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-namespace.md
226 |    */
227 |   'import/no-namespace'?: Linter.RuleEntry<ImportNoNamespace>
228 |   /**
229 |    * Forbid Node.js builtin modules.
230 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-nodejs-modules.md
231 |    */
232 |   'import/no-nodejs-modules'?: Linter.RuleEntry<ImportNoNodejsModules>
233 |   /**
234 |    * Forbid importing packages through relative paths.
235 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-relative-packages.md
236 |    */
237 |   'import/no-relative-packages'?: Linter.RuleEntry<ImportNoRelativePackages>
238 |   /**
239 |    * Forbid importing modules from parent directories.
240 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-relative-parent-imports.md
241 |    */
242 |   'import/no-relative-parent-imports'?: Linter.RuleEntry<ImportNoRelativeParentImports>
243 |   /**
244 |    * Forbid importing a default export by a different name.
245 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-rename-default.md
246 |    */
247 |   'import/no-rename-default'?: Linter.RuleEntry<ImportNoRenameDefault>
248 |   /**
249 |    * Enforce which files can be imported in a given folder.
250 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-restricted-paths.md
251 |    */
252 |   'import/no-restricted-paths'?: Linter.RuleEntry<ImportNoRestrictedPaths>
253 |   /**
254 |    * Forbid a module from importing itself.
255 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-self-import.md
256 |    */
257 |   'import/no-self-import'?: Linter.RuleEntry<[]>
258 |   /**
259 |    * Forbid unassigned imports.
260 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-unassigned-import.md
261 |    */
262 |   'import/no-unassigned-import'?: Linter.RuleEntry<ImportNoUnassignedImport>
263 |   /**
264 |    * Ensure imports point to a file/module that can be resolved.
265 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-unresolved.md
266 |    */
267 |   'import/no-unresolved'?: Linter.RuleEntry<ImportNoUnresolved>
268 |   /**
269 |    * Forbid modules without exports, or exports without matching import in another module.
270 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-unused-modules.md
271 |    */
272 |   'import/no-unused-modules'?: Linter.RuleEntry<ImportNoUnusedModules>
273 |   /**
274 |    * Forbid unnecessary path segments in import and require statements.
275 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-useless-path-segments.md
276 |    */
277 |   'import/no-useless-path-segments'?: Linter.RuleEntry<ImportNoUselessPathSegments>
278 |   /**
279 |    * Forbid webpack loader syntax in imports.
280 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/no-webpack-loader-syntax.md
281 |    */
282 |   'import/no-webpack-loader-syntax'?: Linter.RuleEntry<[]>
283 |   /**
284 |    * Enforce a convention in module import order.
285 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/order.md
286 |    */
287 |   'import/order'?: Linter.RuleEntry<ImportOrder>
288 |   /**
289 |    * Prefer a default export if module exports a single name or multiple names.
290 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/prefer-default-export.md
291 |    */
292 |   'import/prefer-default-export'?: Linter.RuleEntry<ImportPreferDefaultExport>
293 |   /**
294 |    * Enforce using namespace imports for specific modules, like `react`/`react-dom`, etc.
295 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/prefer-namespace-import.md
296 |    */
297 |   'import/prefer-namespace-import'?: Linter.RuleEntry<ImportPreferNamespaceImport>
298 |   /**
299 |    * Forbid potentially ambiguous parse goal (`script` vs. `module`).
300 |    * @see https://github.com/un-ts/eslint-plugin-import-x/blob/v4.16.1/docs/rules/unambiguous.md
301 |    */
302 |   'import/unambiguous'?: Linter.RuleEntry<[]>
303 | }
304 | 
305 | /* ======= Declarations ======= */
306 | // ----- antfu/consistent-chaining -----
307 | type AntfuConsistentChaining = []|[{
308 |   
309 |   allowLeadingPropertyAccess?: boolean
310 | }]
311 | // ----- antfu/consistent-list-newline -----
312 | type AntfuConsistentListNewline = []|[{
313 |   ArrayExpression?: boolean
314 |   ArrayPattern?: boolean
315 |   ArrowFunctionExpression?: boolean
316 |   CallExpression?: boolean
317 |   ExportNamedDeclaration?: boolean
318 |   FunctionDeclaration?: boolean
319 |   FunctionExpression?: boolean
320 |   ImportDeclaration?: boolean
321 |   JSONArrayExpression?: boolean
322 |   JSONObjectExpression?: boolean
323 |   JSXOpeningElement?: boolean
324 |   NewExpression?: boolean
325 |   ObjectExpression?: boolean
326 |   ObjectPattern?: boolean
327 |   TSFunctionType?: boolean
328 |   TSInterfaceDeclaration?: boolean
329 |   TSTupleType?: boolean
330 |   TSTypeLiteral?: boolean
331 |   TSTypeParameterDeclaration?: boolean
332 |   TSTypeParameterInstantiation?: boolean
333 | }]
334 | // ----- antfu/indent-unindent -----
335 | type AntfuIndentUnindent = []|[{
336 |   indent?: number
337 |   tags?: string[]
338 | }]
339 | // ----- import/consistent-type-specifier-style -----
340 | type ImportConsistentTypeSpecifierStyle = []|[("prefer-top-level" | "prefer-inline")]
341 | // ----- import/dynamic-import-chunkname -----
342 | type ImportDynamicImportChunkname = []|[{
343 |   importFunctions?: string[]
344 |   allowEmpty?: boolean
345 |   webpackChunknameFormat?: string
346 |   [k: string]: unknown | undefined
347 | }]
348 | // ----- import/extensions -----
349 | type ImportExtensions = ([]|[("always" | "ignorePackages" | "never")] | []|[("always" | "ignorePackages" | "never")]|[("always" | "ignorePackages" | "never"), {
350 |   pattern?: {
351 |     [k: string]: ("always" | "ignorePackages" | "never")
352 |   }
353 |   ignorePackages?: boolean
354 |   checkTypeImports?: boolean
355 |   pathGroupOverrides?: {
356 |     pattern: string
357 |     patternOptions?: {
358 |       [k: string]: unknown | undefined
359 |     }
360 |     action: ("enforce" | "ignore")
361 |   }[]
362 |   fix?: boolean
363 |   [k: string]: unknown | undefined
364 | }] | []|[{
365 |   pattern?: {
366 |     [k: string]: ("always" | "ignorePackages" | "never")
367 |   }
368 |   ignorePackages?: boolean
369 |   checkTypeImports?: boolean
370 |   pathGroupOverrides?: {
371 |     pattern: string
372 |     patternOptions?: {
373 |       [k: string]: unknown | undefined
374 |     }
375 |     action: ("enforce" | "ignore")
376 |   }[]
377 |   fix?: boolean
378 |   [k: string]: unknown | undefined
379 | }] | []|[("always" | "ignorePackages" | "never")]|[("always" | "ignorePackages" | "never"), {
380 |   [k: string]: ("always" | "ignorePackages" | "never")
381 | }] | []|[{
382 |   [k: string]: ("always" | "ignorePackages" | "never")
383 | }])
384 | // ----- import/first -----
385 | type ImportFirst = []|[("absolute-first" | "disable-absolute-first")]
386 | // ----- import/imports-first -----
387 | type ImportImportsFirst = []|[("absolute-first" | "disable-absolute-first")]
388 | // ----- import/max-dependencies -----
389 | type ImportMaxDependencies = []|[{
390 |   max?: number
391 |   ignoreTypeImports?: boolean
392 | }]
393 | // ----- import/named -----
394 | type ImportNamed = []|[{
395 |   commonjs?: boolean
396 | }]
397 | // ----- import/namespace -----
398 | type ImportNamespace = []|[{
399 |   
400 |   allowComputed?: boolean
401 | }]
402 | // ----- import/newline-after-import -----
403 | type ImportNewlineAfterImport = []|[{
404 |   count?: number
405 |   exactCount?: boolean
406 |   considerComments?: boolean
407 | }]
408 | // ----- import/no-absolute-path -----
409 | type ImportNoAbsolutePath = []|[{
410 |   commonjs?: boolean
411 |   amd?: boolean
412 |   esmodule?: boolean
413 |   
414 |   ignore?: [string, ...(string)[]]
415 | }]
416 | // ----- import/no-anonymous-default-export -----
417 | type ImportNoAnonymousDefaultExport = []|[{
418 |   
419 |   allowArray?: boolean
420 |   
421 |   allowArrowFunction?: boolean
422 |   
423 |   allowCallExpression?: boolean
424 |   
425 |   allowAnonymousClass?: boolean
426 |   
427 |   allowAnonymousFunction?: boolean
428 |   
429 |   allowLiteral?: boolean
430 |   
431 |   allowObject?: boolean
432 |   
433 |   allowNew?: boolean
434 | }]
435 | // ----- import/no-commonjs -----
436 | type ImportNoCommonjs = ([]|["allow-primitive-modules"] | []|[{
437 |   allowPrimitiveModules?: boolean
438 |   allowRequire?: boolean
439 |   allowConditionalRequire?: boolean
440 | }])
441 | // ----- import/no-cycle -----
442 | type ImportNoCycle = []|[{
443 |   commonjs?: boolean
444 |   amd?: boolean
445 |   esmodule?: boolean
446 |   
447 |   ignore?: [string, ...(string)[]]
448 |   maxDepth?: (number | "∞")
449 |   
450 |   ignoreExternal?: boolean
451 |   
452 |   allowUnsafeDynamicCyclicDependency?: boolean
453 | }]
454 | // ----- import/no-duplicates -----
455 | type ImportNoDuplicates = []|[{
456 |   considerQueryString?: boolean
457 |   "prefer-inline"?: boolean
458 | }]
459 | // ----- import/no-dynamic-require -----
460 | type ImportNoDynamicRequire = []|[{
461 |   esmodule?: boolean
462 | }]
463 | // ----- import/no-extraneous-dependencies -----
464 | type ImportNoExtraneousDependencies = []|[{
465 |   devDependencies?: (boolean | unknown[])
466 |   optionalDependencies?: (boolean | unknown[])
467 |   peerDependencies?: (boolean | unknown[])
468 |   bundledDependencies?: (boolean | unknown[])
469 |   packageDir?: (string | unknown[])
470 |   includeInternal?: boolean
471 |   includeTypes?: boolean
472 |   whitelist?: unknown[]
473 | }]
474 | // ----- import/no-import-module-exports -----
475 | type ImportNoImportModuleExports = []|[{
476 |   exceptions?: unknown[]
477 | }]
478 | // ----- import/no-internal-modules -----
479 | type ImportNoInternalModules = []|[({
480 |   allow?: string[]
481 | } | {
482 |   forbid?: string[]
483 | })]
484 | // ----- import/no-namespace -----
485 | type ImportNoNamespace = []|[{
486 |   ignore?: string[]
487 |   [k: string]: unknown | undefined
488 | }]
489 | // ----- import/no-nodejs-modules -----
490 | type ImportNoNodejsModules = []|[{
491 |   allow?: string[]
492 | }]
493 | // ----- import/no-relative-packages -----
494 | type ImportNoRelativePackages = []|[{
495 |   commonjs?: boolean
496 |   amd?: boolean
497 |   esmodule?: boolean
498 |   
499 |   ignore?: [string, ...(string)[]]
500 | }]
501 | // ----- import/no-relative-parent-imports -----
502 | type ImportNoRelativeParentImports = []|[{
503 |   commonjs?: boolean
504 |   amd?: boolean
505 |   esmodule?: boolean
506 |   
507 |   ignore?: [string, ...(string)[]]
508 | }]
509 | // ----- import/no-rename-default -----
510 | type ImportNoRenameDefault = []|[{
511 |   commonjs?: boolean
512 |   preventRenamingBindings?: boolean
513 | }]
514 | // ----- import/no-restricted-paths -----
515 | type ImportNoRestrictedPaths = []|[{
516 |   
517 |   zones?: [{
518 |     target?: (string | [string, ...(string)[]])
519 |     from?: (string | [string, ...(string)[]])
520 |     except?: string[]
521 |     message?: string
522 |   }, ...({
523 |     target?: (string | [string, ...(string)[]])
524 |     from?: (string | [string, ...(string)[]])
525 |     except?: string[]
526 |     message?: string
527 |   })[]]
528 |   basePath?: string
529 | }]
530 | // ----- import/no-unassigned-import -----
531 | type ImportNoUnassignedImport = []|[{
532 |   devDependencies?: (boolean | unknown[])
533 |   optionalDependencies?: (boolean | unknown[])
534 |   peerDependencies?: (boolean | unknown[])
535 |   allow?: string[]
536 | }]
537 | // ----- import/no-unresolved -----
538 | type ImportNoUnresolved = []|[{
539 |   commonjs?: boolean
540 |   amd?: boolean
541 |   esmodule?: boolean
542 |   
543 |   ignore?: [string, ...(string)[]]
544 |   caseSensitive?: boolean
545 |   caseSensitiveStrict?: boolean
546 | }]
547 | // ----- import/no-unused-modules -----
548 | type ImportNoUnusedModules = []|[({
549 |   unusedExports: true
550 |   
551 |   src?: [unknown, ...(unknown)[]]
552 |   [k: string]: unknown | undefined
553 | } | {
554 |   missingExports: true
555 |   [k: string]: unknown | undefined
556 | })]
557 | // ----- import/no-useless-path-segments -----
558 | type ImportNoUselessPathSegments = []|[{
559 |   commonjs?: boolean
560 |   noUselessIndex?: boolean
561 | }]
562 | // ----- import/order -----
563 | type ImportOrder = []|[{
564 |   groups?: unknown[]
565 |   pathGroupsExcludedImportTypes?: unknown[]
566 |   distinctGroup?: boolean
567 |   pathGroups?: {
568 |     pattern: string
569 |     patternOptions?: {
570 |       [k: string]: unknown | undefined
571 |     }
572 |     group: ("builtin" | "external" | "internal" | "unknown" | "parent" | "sibling" | "index" | "object" | "type")
573 |     position?: ("after" | "before")
574 |   }[]
575 |   "newlines-between"?: ("ignore" | "always" | "always-and-inside-groups" | "never")
576 |   "newlines-between-types"?: ("ignore" | "always" | "always-and-inside-groups" | "never")
577 |   consolidateIslands?: ("inside-groups" | "never")
578 |   sortTypesGroup?: boolean
579 |   named?: (boolean | {
580 |     enabled?: boolean
581 |     import?: boolean
582 |     export?: boolean
583 |     require?: boolean
584 |     cjsExports?: boolean
585 |     types?: ("mixed" | "types-first" | "types-last")
586 |   })
587 |   alphabetize?: {
588 |     caseInsensitive?: boolean
589 |     order?: ("ignore" | "asc" | "desc")
590 |     orderImportKind?: ("ignore" | "asc" | "desc")
591 |   }
592 |   warnOnUnassignedImports?: boolean
593 | }]
594 | // ----- import/prefer-default-export -----
595 | type ImportPreferDefaultExport = []|[{
596 |   target?: ("single" | "any")
597 | }]
598 | // ----- import/prefer-namespace-import -----
599 | type ImportPreferNamespaceImport = []|[{
600 |   patterns?: string[]
601 | }]


--------------------------------------------------------------------------------
/test/output/flat-config-vue.d.ts:
--------------------------------------------------------------------------------
   1 | /* eslint-disable */
   2 | /* prettier-ignore */
   3 | import type { Linter } from 'eslint'
   4 | 
   5 | declare module 'eslint' {
   6 |   namespace Linter {
   7 |     interface RulesRecord extends RuleOptions {}
   8 |   }
   9 | }
  10 | 
  11 | export interface RuleOptions {
  12 |   /**
  13 |    * Enforce linebreaks after opening and before closing array brackets in `<template>`
  14 |    * @see https://eslint.vuejs.org/rules/array-bracket-newline.html
  15 |    */
  16 |   'vue/array-bracket-newline'?: Linter.RuleEntry<VueArrayBracketNewline>
  17 |   /**
  18 |    * Enforce consistent spacing inside array brackets in `<template>`
  19 |    * @see https://eslint.vuejs.org/rules/array-bracket-spacing.html
  20 |    */
  21 |   'vue/array-bracket-spacing'?: Linter.RuleEntry<VueArrayBracketSpacing>
  22 |   /**
  23 |    * Enforce line breaks after each array element in `<template>`
  24 |    * @see https://eslint.vuejs.org/rules/array-element-newline.html
  25 |    */
  26 |   'vue/array-element-newline'?: Linter.RuleEntry<VueArrayElementNewline>
  27 |   /**
  28 |    * Enforce consistent spacing before and after the arrow in arrow functions in `<template>`
  29 |    * @see https://eslint.vuejs.org/rules/arrow-spacing.html
  30 |    */
  31 |   'vue/arrow-spacing'?: Linter.RuleEntry<VueArrowSpacing>
  32 |   /**
  33 |    * enforce attribute naming style on custom components in template
  34 |    * @see https://eslint.vuejs.org/rules/attribute-hyphenation.html
  35 |    */
  36 |   'vue/attribute-hyphenation'?: Linter.RuleEntry<VueAttributeHyphenation>
  37 |   /**
  38 |    * enforce order of attributes
  39 |    * @see https://eslint.vuejs.org/rules/attributes-order.html
  40 |    */
  41 |   'vue/attributes-order'?: Linter.RuleEntry<VueAttributesOrder>
  42 |   /**
  43 |    * disallow use other than available `lang`
  44 |    * @see https://eslint.vuejs.org/rules/block-lang.html
  45 |    */
  46 |   'vue/block-lang'?: Linter.RuleEntry<VueBlockLang>
  47 |   /**
  48 |    * enforce order of component top-level elements
  49 |    * @see https://eslint.vuejs.org/rules/block-order.html
  50 |    */
  51 |   'vue/block-order'?: Linter.RuleEntry<VueBlockOrder>
  52 |   /**
  53 |    * Disallow or enforce spaces inside of blocks after opening block and before closing block in `<template>`
  54 |    * @see https://eslint.vuejs.org/rules/block-spacing.html
  55 |    */
  56 |   'vue/block-spacing'?: Linter.RuleEntry<VueBlockSpacing>
  57 |   /**
  58 |    * enforce line breaks after opening and before closing block-level tags
  59 |    * @see https://eslint.vuejs.org/rules/block-tag-newline.html
  60 |    */
  61 |   'vue/block-tag-newline'?: Linter.RuleEntry<VueBlockTagNewline>
  62 |   /**
  63 |    * Enforce consistent brace style for blocks in `<template>`
  64 |    * @see https://eslint.vuejs.org/rules/brace-style.html
  65 |    */
  66 |   'vue/brace-style'?: Linter.RuleEntry<VueBraceStyle>
  67 |   /**
  68 |    * Enforce camelcase naming convention in `<template>`
  69 |    * @see https://eslint.vuejs.org/rules/camelcase.html
  70 |    */
  71 |   'vue/camelcase'?: Linter.RuleEntry<VueCamelcase>
  72 |   /**
  73 |    * Require or disallow trailing commas in `<template>`
  74 |    * @see https://eslint.vuejs.org/rules/comma-dangle.html
  75 |    */
  76 |   'vue/comma-dangle'?: Linter.RuleEntry<VueCommaDangle>
  77 |   /**
  78 |    * Enforce consistent spacing before and after commas in `<template>`
  79 |    * @see https://eslint.vuejs.org/rules/comma-spacing.html
  80 |    */
  81 |   'vue/comma-spacing'?: Linter.RuleEntry<VueCommaSpacing>
  82 |   /**
  83 |    * Enforce consistent comma style in `<template>`
  84 |    * @see https://eslint.vuejs.org/rules/comma-style.html
  85 |    */
  86 |   'vue/comma-style'?: Linter.RuleEntry<VueCommaStyle>
  87 |   /**
  88 |    * support comment-directives in `<template>`
  89 |    * @see https://eslint.vuejs.org/rules/comment-directive.html
  90 |    */
  91 |   'vue/comment-directive'?: Linter.RuleEntry<VueCommentDirective>
  92 |   /**
  93 |    * enforce component API style
  94 |    * @see https://eslint.vuejs.org/rules/component-api-style.html
  95 |    */
  96 |   'vue/component-api-style'?: Linter.RuleEntry<VueComponentApiStyle>
  97 |   /**
  98 |    * enforce specific casing for component definition name
  99 |    * @see https://eslint.vuejs.org/rules/component-definition-name-casing.html
 100 |    */
 101 |   'vue/component-definition-name-casing'?: Linter.RuleEntry<VueComponentDefinitionNameCasing>
 102 |   /**
 103 |    * enforce specific casing for the component naming style in template
 104 |    * @see https://eslint.vuejs.org/rules/component-name-in-template-casing.html
 105 |    */
 106 |   'vue/component-name-in-template-casing'?: Linter.RuleEntry<VueComponentNameInTemplateCasing>
 107 |   /**
 108 |    * enforce the casing of component name in `components` options
 109 |    * @see https://eslint.vuejs.org/rules/component-options-name-casing.html
 110 |    */
 111 |   'vue/component-options-name-casing'?: Linter.RuleEntry<VueComponentOptionsNameCasing>
 112 |   /**
 113 |    * enforce specific casing for custom event name
 114 |    * @see https://eslint.vuejs.org/rules/custom-event-name-casing.html
 115 |    */
 116 |   'vue/custom-event-name-casing'?: Linter.RuleEntry<VueCustomEventNameCasing>
 117 |   /**
 118 |    * enforce declaration style of `defineEmits`
 119 |    * @see https://eslint.vuejs.org/rules/define-emits-declaration.html
 120 |    */
 121 |   'vue/define-emits-declaration'?: Linter.RuleEntry<VueDefineEmitsDeclaration>
 122 |   /**
 123 |    * enforce order of compiler macros (`defineProps`, `defineEmits`, etc.)
 124 |    * @see https://eslint.vuejs.org/rules/define-macros-order.html
 125 |    */
 126 |   'vue/define-macros-order'?: Linter.RuleEntry<VueDefineMacrosOrder>
 127 |   /**
 128 |    * enforce declaration style of `defineProps`
 129 |    * @see https://eslint.vuejs.org/rules/define-props-declaration.html
 130 |    */
 131 |   'vue/define-props-declaration'?: Linter.RuleEntry<VueDefinePropsDeclaration>
 132 |   /**
 133 |    * enforce consistent style for props destructuring
 134 |    * @see https://eslint.vuejs.org/rules/define-props-destructuring.html
 135 |    */
 136 |   'vue/define-props-destructuring'?: Linter.RuleEntry<VueDefinePropsDestructuring>
 137 |   /**
 138 |    * Enforce consistent newlines before and after dots in `<template>`
 139 |    * @see https://eslint.vuejs.org/rules/dot-location.html
 140 |    */
 141 |   'vue/dot-location'?: Linter.RuleEntry<VueDotLocation>
 142 |   /**
 143 |    * Enforce dot notation whenever possible in `<template>`
 144 |    * @see https://eslint.vuejs.org/rules/dot-notation.html
 145 |    */
 146 |   'vue/dot-notation'?: Linter.RuleEntry<VueDotNotation>
 147 |   /**
 148 |    * enforce or forbid the use of the `scoped` and `module` attributes in SFC top level style tags
 149 |    * @see https://eslint.vuejs.org/rules/enforce-style-attribute.html
 150 |    */
 151 |   'vue/enforce-style-attribute'?: Linter.RuleEntry<VueEnforceStyleAttribute>
 152 |   /**
 153 |    * Require the use of `===` and `!==` in `<template>`
 154 |    * @see https://eslint.vuejs.org/rules/eqeqeq.html
 155 |    */
 156 |   'vue/eqeqeq'?: Linter.RuleEntry<VueEqeqeq>
 157 |   /**
 158 |    * enforce the location of first attribute
 159 |    * @see https://eslint.vuejs.org/rules/first-attribute-linebreak.html
 160 |    */
 161 |   'vue/first-attribute-linebreak'?: Linter.RuleEntry<VueFirstAttributeLinebreak>
 162 |   /**
 163 |    * Require or disallow spacing between function identifiers and their invocations in `<template>`
 164 |    * @see https://eslint.vuejs.org/rules/func-call-spacing.html
 165 |    */
 166 |   'vue/func-call-spacing'?: Linter.RuleEntry<VueFuncCallSpacing>
 167 |   /**
 168 |    * disallow usage of button without an explicit type attribute
 169 |    * @see https://eslint.vuejs.org/rules/html-button-has-type.html
 170 |    */
 171 |   'vue/html-button-has-type'?: Linter.RuleEntry<VueHtmlButtonHasType>
 172 |   /**
 173 |    * require or disallow a line break before tag's closing brackets
 174 |    * @see https://eslint.vuejs.org/rules/html-closing-bracket-newline.html
 175 |    */
 176 |   'vue/html-closing-bracket-newline'?: Linter.RuleEntry<VueHtmlClosingBracketNewline>
 177 |   /**
 178 |    * require or disallow a space before tag's closing brackets
 179 |    * @see https://eslint.vuejs.org/rules/html-closing-bracket-spacing.html
 180 |    */
 181 |   'vue/html-closing-bracket-spacing'?: Linter.RuleEntry<VueHtmlClosingBracketSpacing>
 182 |   /**
 183 |    * enforce unified line break in HTML comments
 184 |    * @see https://eslint.vuejs.org/rules/html-comment-content-newline.html
 185 |    */
 186 |   'vue/html-comment-content-newline'?: Linter.RuleEntry<VueHtmlCommentContentNewline>
 187 |   /**
 188 |    * enforce unified spacing in HTML comments
 189 |    * @see https://eslint.vuejs.org/rules/html-comment-content-spacing.html
 190 |    */
 191 |   'vue/html-comment-content-spacing'?: Linter.RuleEntry<VueHtmlCommentContentSpacing>
 192 |   /**
 193 |    * enforce consistent indentation in HTML comments
 194 |    * @see https://eslint.vuejs.org/rules/html-comment-indent.html
 195 |    */
 196 |   'vue/html-comment-indent'?: Linter.RuleEntry<VueHtmlCommentIndent>
 197 |   /**
 198 |    * enforce end tag style
 199 |    * @see https://eslint.vuejs.org/rules/html-end-tags.html
 200 |    */
 201 |   'vue/html-end-tags'?: Linter.RuleEntry<[]>
 202 |   /**
 203 |    * enforce consistent indentation in `<template>`
 204 |    * @see https://eslint.vuejs.org/rules/html-indent.html
 205 |    */
 206 |   'vue/html-indent'?: Linter.RuleEntry<VueHtmlIndent>
 207 |   /**
 208 |    * enforce quotes style of HTML attributes
 209 |    * @see https://eslint.vuejs.org/rules/html-quotes.html
 210 |    */
 211 |   'vue/html-quotes'?: Linter.RuleEntry<VueHtmlQuotes>
 212 |   /**
 213 |    * enforce self-closing style
 214 |    * @see https://eslint.vuejs.org/rules/html-self-closing.html
 215 |    */
 216 |   'vue/html-self-closing'?: Linter.RuleEntry<VueHtmlSelfClosing>
 217 |   /**
 218 |    * prevent variables used in JSX to be marked as unused
 219 |    * @see https://eslint.vuejs.org/rules/jsx-uses-vars.html
 220 |    */
 221 |   'vue/jsx-uses-vars'?: Linter.RuleEntry<[]>
 222 |   /**
 223 |    * Enforce consistent spacing between property names and type annotations in types and interfaces in `<template>`
 224 |    * @see https://eslint.vuejs.org/rules/key-spacing.html
 225 |    */
 226 |   'vue/key-spacing'?: Linter.RuleEntry<VueKeySpacing>
 227 |   /**
 228 |    * Enforce consistent spacing before and after keywords in `<template>`
 229 |    * @see https://eslint.vuejs.org/rules/keyword-spacing.html
 230 |    */
 231 |   'vue/keyword-spacing'?: Linter.RuleEntry<VueKeywordSpacing>
 232 |   /**
 233 |    * require component name property to match its file name
 234 |    * @see https://eslint.vuejs.org/rules/match-component-file-name.html
 235 |    */
 236 |   'vue/match-component-file-name'?: Linter.RuleEntry<VueMatchComponentFileName>
 237 |   /**
 238 |    * require the registered component name to match the imported component name
 239 |    * @see https://eslint.vuejs.org/rules/match-component-import-name.html
 240 |    */
 241 |   'vue/match-component-import-name'?: Linter.RuleEntry<[]>
 242 |   /**
 243 |    * enforce the maximum number of attributes per line
 244 |    * @see https://eslint.vuejs.org/rules/max-attributes-per-line.html
 245 |    */
 246 |   'vue/max-attributes-per-line'?: Linter.RuleEntry<VueMaxAttributesPerLine>
 247 |   /**
 248 |    * enforce a maximum line length in `.vue` files
 249 |    * @see https://eslint.vuejs.org/rules/max-len.html
 250 |    */
 251 |   'vue/max-len'?: Linter.RuleEntry<VueMaxLen>
 252 |   /**
 253 |    * enforce maximum number of lines in Vue SFC blocks
 254 |    * @see https://eslint.vuejs.org/rules/max-lines-per-block.html
 255 |    */
 256 |   'vue/max-lines-per-block'?: Linter.RuleEntry<VueMaxLinesPerBlock>
 257 |   /**
 258 |    * enforce maximum number of props in Vue component
 259 |    * @see https://eslint.vuejs.org/rules/max-props.html
 260 |    */
 261 |   'vue/max-props'?: Linter.RuleEntry<VueMaxProps>
 262 |   /**
 263 |    * enforce maximum depth of template
 264 |    * @see https://eslint.vuejs.org/rules/max-template-depth.html
 265 |    */
 266 |   'vue/max-template-depth'?: Linter.RuleEntry<VueMaxTemplateDepth>
 267 |   /**
 268 |    * require component names to be always multi-word
 269 |    * @see https://eslint.vuejs.org/rules/multi-word-component-names.html
 270 |    */
 271 |   'vue/multi-word-component-names'?: Linter.RuleEntry<VueMultiWordComponentNames>
 272 |   /**
 273 |    * require a line break before and after the contents of a multiline element
 274 |    * @see https://eslint.vuejs.org/rules/multiline-html-element-content-newline.html
 275 |    */
 276 |   'vue/multiline-html-element-content-newline'?: Linter.RuleEntry<VueMultilineHtmlElementContentNewline>
 277 |   /**
 278 |    * Enforce newlines between operands of ternary expressions in `<template>`
 279 |    * @see https://eslint.vuejs.org/rules/multiline-ternary.html
 280 |    */
 281 |   'vue/multiline-ternary'?: Linter.RuleEntry<VueMultilineTernary>
 282 |   /**
 283 |    * enforce unified spacing in mustache interpolations
 284 |    * @see https://eslint.vuejs.org/rules/mustache-interpolation-spacing.html
 285 |    */
 286 |   'vue/mustache-interpolation-spacing'?: Linter.RuleEntry<VueMustacheInterpolationSpacing>
 287 |   /**
 288 |    * enforce new lines between multi-line properties in Vue components
 289 |    * @see https://eslint.vuejs.org/rules/new-line-between-multi-line-property.html
 290 |    */
 291 |   'vue/new-line-between-multi-line-property'?: Linter.RuleEntry<VueNewLineBetweenMultiLineProperty>
 292 |   /**
 293 |    * enforce Promise or callback style in `nextTick`
 294 |    * @see https://eslint.vuejs.org/rules/next-tick-style.html
 295 |    */
 296 |   'vue/next-tick-style'?: Linter.RuleEntry<VueNextTickStyle>
 297 |   /**
 298 |    * disallow using arrow functions to define watcher
 299 |    * @see https://eslint.vuejs.org/rules/no-arrow-functions-in-watch.html
 300 |    */
 301 |   'vue/no-arrow-functions-in-watch'?: Linter.RuleEntry<[]>
 302 |   /**
 303 |    * disallow asynchronous actions in computed properties
 304 |    * @see https://eslint.vuejs.org/rules/no-async-in-computed-properties.html
 305 |    */
 306 |   'vue/no-async-in-computed-properties'?: Linter.RuleEntry<[]>
 307 |   /**
 308 |    * disallow the use of bare strings in `<template>`
 309 |    * @see https://eslint.vuejs.org/rules/no-bare-strings-in-template.html
 310 |    */
 311 |   'vue/no-bare-strings-in-template'?: Linter.RuleEntry<VueNoBareStringsInTemplate>
 312 |   /**
 313 |    * disallow boolean defaults
 314 |    * @see https://eslint.vuejs.org/rules/no-boolean-default.html
 315 |    */
 316 |   'vue/no-boolean-default'?: Linter.RuleEntry<VueNoBooleanDefault>
 317 |   /**
 318 |    * disallow element's child contents which would be overwritten by a directive like `v-html` or `v-text`
 319 |    * @see https://eslint.vuejs.org/rules/no-child-content.html
 320 |    */
 321 |   'vue/no-child-content'?: Linter.RuleEntry<VueNoChildContent>
 322 |   /**
 323 |    * disallow accessing computed properties in `data`
 324 |    * @see https://eslint.vuejs.org/rules/no-computed-properties-in-data.html
 325 |    */
 326 |   'vue/no-computed-properties-in-data'?: Linter.RuleEntry<[]>
 327 |   /**
 328 |    * Disallow the use of `console` in `<template>`
 329 |    * @see https://eslint.vuejs.org/rules/no-console.html
 330 |    */
 331 |   'vue/no-console'?: Linter.RuleEntry<VueNoConsole>
 332 |   /**
 333 |    * Disallow constant expressions in conditions in `<template>`
 334 |    * @see https://eslint.vuejs.org/rules/no-constant-condition.html
 335 |    */
 336 |   'vue/no-constant-condition'?: Linter.RuleEntry<VueNoConstantCondition>
 337 |   /**
 338 |    * disallow custom modifiers on v-model used on the component
 339 |    * @see https://eslint.vuejs.org/rules/no-custom-modifiers-on-v-model.html
 340 |    */
 341 |   'vue/no-custom-modifiers-on-v-model'?: Linter.RuleEntry<[]>
 342 |   /**
 343 |    * disallow using deprecated object declaration on data (in Vue.js 3.0.0+)
 344 |    * @see https://eslint.vuejs.org/rules/no-deprecated-data-object-declaration.html
 345 |    */
 346 |   'vue/no-deprecated-data-object-declaration'?: Linter.RuleEntry<[]>
 347 |   /**
 348 |    * disallow using deprecated `$delete` and `$set` (in Vue.js 3.0.0+)
 349 |    * @see https://eslint.vuejs.org/rules/no-deprecated-delete-set.html
 350 |    */
 351 |   'vue/no-deprecated-delete-set'?: Linter.RuleEntry<[]>
 352 |   /**
 353 |    * disallow using deprecated `destroyed` and `beforeDestroy` lifecycle hooks (in Vue.js 3.0.0+)
 354 |    * @see https://eslint.vuejs.org/rules/no-deprecated-destroyed-lifecycle.html
 355 |    */
 356 |   'vue/no-deprecated-destroyed-lifecycle'?: Linter.RuleEntry<[]>
 357 |   /**
 358 |    * disallow using deprecated `$listeners` (in Vue.js 3.0.0+)
 359 |    * @see https://eslint.vuejs.org/rules/no-deprecated-dollar-listeners-api.html
 360 |    */
 361 |   'vue/no-deprecated-dollar-listeners-api'?: Linter.RuleEntry<[]>
 362 |   /**
 363 |    * disallow using deprecated `$scopedSlots` (in Vue.js 3.0.0+)
 364 |    * @see https://eslint.vuejs.org/rules/no-deprecated-dollar-scopedslots-api.html
 365 |    */
 366 |   'vue/no-deprecated-dollar-scopedslots-api'?: Linter.RuleEntry<[]>
 367 |   /**
 368 |    * disallow using deprecated events api (in Vue.js 3.0.0+)
 369 |    * @see https://eslint.vuejs.org/rules/no-deprecated-events-api.html
 370 |    */
 371 |   'vue/no-deprecated-events-api'?: Linter.RuleEntry<[]>
 372 |   /**
 373 |    * disallow using deprecated filters syntax (in Vue.js 3.0.0+)
 374 |    * @see https://eslint.vuejs.org/rules/no-deprecated-filter.html
 375 |    */
 376 |   'vue/no-deprecated-filter'?: Linter.RuleEntry<[]>
 377 |   /**
 378 |    * disallow using deprecated the `functional` template (in Vue.js 3.0.0+)
 379 |    * @see https://eslint.vuejs.org/rules/no-deprecated-functional-template.html
 380 |    */
 381 |   'vue/no-deprecated-functional-template'?: Linter.RuleEntry<[]>
 382 |   /**
 383 |    * disallow using deprecated the `is` attribute on HTML elements (in Vue.js 3.0.0+)
 384 |    * @see https://eslint.vuejs.org/rules/no-deprecated-html-element-is.html
 385 |    */
 386 |   'vue/no-deprecated-html-element-is'?: Linter.RuleEntry<[]>
 387 |   /**
 388 |    * disallow using deprecated `inline-template` attribute (in Vue.js 3.0.0+)
 389 |    * @see https://eslint.vuejs.org/rules/no-deprecated-inline-template.html
 390 |    */
 391 |   'vue/no-deprecated-inline-template'?: Linter.RuleEntry<[]>
 392 |   /**
 393 |    * disallow deprecated `model` definition (in Vue.js 3.0.0+)
 394 |    * @see https://eslint.vuejs.org/rules/no-deprecated-model-definition.html
 395 |    */
 396 |   'vue/no-deprecated-model-definition'?: Linter.RuleEntry<VueNoDeprecatedModelDefinition>
 397 |   /**
 398 |    * disallow deprecated `this` access in props default function (in Vue.js 3.0.0+)
 399 |    * @see https://eslint.vuejs.org/rules/no-deprecated-props-default-this.html
 400 |    */
 401 |   'vue/no-deprecated-props-default-this'?: Linter.RuleEntry<[]>
 402 |   /**
 403 |    * disallow using deprecated `tag` property on `RouterLink` (in Vue.js 3.0.0+)
 404 |    * @see https://eslint.vuejs.org/rules/no-deprecated-router-link-tag-prop.html
 405 |    */
 406 |   'vue/no-deprecated-router-link-tag-prop'?: Linter.RuleEntry<VueNoDeprecatedRouterLinkTagProp>
 407 |   /**
 408 |    * disallow deprecated `scope` attribute (in Vue.js 2.5.0+)
 409 |    * @see https://eslint.vuejs.org/rules/no-deprecated-scope-attribute.html
 410 |    */
 411 |   'vue/no-deprecated-scope-attribute'?: Linter.RuleEntry<[]>
 412 |   /**
 413 |    * disallow deprecated `slot` attribute (in Vue.js 2.6.0+)
 414 |    * @see https://eslint.vuejs.org/rules/no-deprecated-slot-attribute.html
 415 |    */
 416 |   'vue/no-deprecated-slot-attribute'?: Linter.RuleEntry<VueNoDeprecatedSlotAttribute>
 417 |   /**
 418 |    * disallow deprecated `slot-scope` attribute (in Vue.js 2.6.0+)
 419 |    * @see https://eslint.vuejs.org/rules/no-deprecated-slot-scope-attribute.html
 420 |    */
 421 |   'vue/no-deprecated-slot-scope-attribute'?: Linter.RuleEntry<[]>
 422 |   /**
 423 |    * disallow use of deprecated `.sync` modifier on `v-bind` directive (in Vue.js 3.0.0+)
 424 |    * @see https://eslint.vuejs.org/rules/no-deprecated-v-bind-sync.html
 425 |    */
 426 |   'vue/no-deprecated-v-bind-sync'?: Linter.RuleEntry<[]>
 427 |   /**
 428 |    * disallow deprecated `v-is` directive (in Vue.js 3.1.0+)
 429 |    * @see https://eslint.vuejs.org/rules/no-deprecated-v-is.html
 430 |    */
 431 |   'vue/no-deprecated-v-is'?: Linter.RuleEntry<[]>
 432 |   /**
 433 |    * disallow using deprecated `.native` modifiers (in Vue.js 3.0.0+)
 434 |    * @see https://eslint.vuejs.org/rules/no-deprecated-v-on-native-modifier.html
 435 |    */
 436 |   'vue/no-deprecated-v-on-native-modifier'?: Linter.RuleEntry<[]>
 437 |   /**
 438 |    * disallow using deprecated number (keycode) modifiers (in Vue.js 3.0.0+)
 439 |    * @see https://eslint.vuejs.org/rules/no-deprecated-v-on-number-modifiers.html
 440 |    */
 441 |   'vue/no-deprecated-v-on-number-modifiers'?: Linter.RuleEntry<[]>
 442 |   /**
 443 |    * disallow using deprecated `Vue.config.keyCodes` (in Vue.js 3.0.0+)
 444 |    * @see https://eslint.vuejs.org/rules/no-deprecated-vue-config-keycodes.html
 445 |    */
 446 |   'vue/no-deprecated-vue-config-keycodes'?: Linter.RuleEntry<[]>
 447 |   /**
 448 |    * disallow duplication of field names
 449 |    * @see https://eslint.vuejs.org/rules/no-dupe-keys.html
 450 |    */
 451 |   'vue/no-dupe-keys'?: Linter.RuleEntry<VueNoDupeKeys>
 452 |   /**
 453 |    * disallow duplicate conditions in `v-if` / `v-else-if` chains
 454 |    * @see https://eslint.vuejs.org/rules/no-dupe-v-else-if.html
 455 |    */
 456 |   'vue/no-dupe-v-else-if'?: Linter.RuleEntry<[]>
 457 |   /**
 458 |    * enforce `inheritAttrs` to be set to `false` when using `v-bind="$attrs"`
 459 |    * @see https://eslint.vuejs.org/rules/no-duplicate-attr-inheritance.html
 460 |    */
 461 |   'vue/no-duplicate-attr-inheritance'?: Linter.RuleEntry<VueNoDuplicateAttrInheritance>
 462 |   /**
 463 |    * disallow duplication of attributes
 464 |    * @see https://eslint.vuejs.org/rules/no-duplicate-attributes.html
 465 |    */
 466 |   'vue/no-duplicate-attributes'?: Linter.RuleEntry<VueNoDuplicateAttributes>
 467 |   /**
 468 |    * disallow the `<template>` `<script>` `<style>` block to be empty
 469 |    * @see https://eslint.vuejs.org/rules/no-empty-component-block.html
 470 |    */
 471 |   'vue/no-empty-component-block'?: Linter.RuleEntry<[]>
 472 |   /**
 473 |    * Disallow empty destructuring patterns in `<template>`
 474 |    * @see https://eslint.vuejs.org/rules/no-empty-pattern.html
 475 |    */
 476 |   'vue/no-empty-pattern'?: Linter.RuleEntry<VueNoEmptyPattern>
 477 |   /**
 478 |    * disallow `export` in `<script setup>`
 479 |    * @see https://eslint.vuejs.org/rules/no-export-in-script-setup.html
 480 |    */
 481 |   'vue/no-export-in-script-setup'?: Linter.RuleEntry<[]>
 482 |   /**
 483 |    * disallow asynchronously registered `expose`
 484 |    * @see https://eslint.vuejs.org/rules/no-expose-after-await.html
 485 |    */
 486 |   'vue/no-expose-after-await'?: Linter.RuleEntry<[]>
 487 |   /**
 488 |    * Disallow unnecessary parentheses in `<template>`
 489 |    * @see https://eslint.vuejs.org/rules/no-extra-parens.html
 490 |    */
 491 |   'vue/no-extra-parens'?: Linter.RuleEntry<VueNoExtraParens>
 492 |   /**
 493 |    * Disallow shorthand type conversions in `<template>`
 494 |    * @see https://eslint.vuejs.org/rules/no-implicit-coercion.html
 495 |    */
 496 |   'vue/no-implicit-coercion'?: Linter.RuleEntry<VueNoImplicitCoercion>
 497 |   /**
 498 |    * disallow importing Vue compiler macros
 499 |    * @see https://eslint.vuejs.org/rules/no-import-compiler-macros.html
 500 |    */
 501 |   'vue/no-import-compiler-macros'?: Linter.RuleEntry<[]>
 502 |   /**
 503 |    * disallow irregular whitespace in `.vue` files
 504 |    * @see https://eslint.vuejs.org/rules/no-irregular-whitespace.html
 505 |    */
 506 |   'vue/no-irregular-whitespace'?: Linter.RuleEntry<VueNoIrregularWhitespace>
 507 |   /**
 508 |    * disallow asynchronously registered lifecycle hooks
 509 |    * @see https://eslint.vuejs.org/rules/no-lifecycle-after-await.html
 510 |    */
 511 |   'vue/no-lifecycle-after-await'?: Linter.RuleEntry<[]>
 512 |   /**
 513 |    * disallow unnecessary `<template>`
 514 |    * @see https://eslint.vuejs.org/rules/no-lone-template.html
 515 |    */
 516 |   'vue/no-lone-template'?: Linter.RuleEntry<VueNoLoneTemplate>
 517 |   /**
 518 |    * Disallow literal numbers that lose precision in `<template>`
 519 |    * @see https://eslint.vuejs.org/rules/no-loss-of-precision.html
 520 |    */
 521 |   'vue/no-loss-of-precision'?: Linter.RuleEntry<[]>
 522 |   /**
 523 |    * disallow multiple spaces
 524 |    * @see https://eslint.vuejs.org/rules/no-multi-spaces.html
 525 |    */
 526 |   'vue/no-multi-spaces'?: Linter.RuleEntry<VueNoMultiSpaces>
 527 |   /**
 528 |    * disallow passing multiple objects in an array to class
 529 |    * @see https://eslint.vuejs.org/rules/no-multiple-objects-in-class.html
 530 |    */
 531 |   'vue/no-multiple-objects-in-class'?: Linter.RuleEntry<[]>
 532 |   /**
 533 |    * disallow passing multiple arguments to scoped slots
 534 |    * @see https://eslint.vuejs.org/rules/no-multiple-slot-args.html
 535 |    */
 536 |   'vue/no-multiple-slot-args'?: Linter.RuleEntry<[]>
 537 |   /**
 538 |    * disallow adding multiple root nodes to the template
 539 |    * @see https://eslint.vuejs.org/rules/no-multiple-template-root.html
 540 |    */
 541 |   'vue/no-multiple-template-root'?: Linter.RuleEntry<VueNoMultipleTemplateRoot>
 542 |   /**
 543 |    * disallow mutation of component props
 544 |    * @see https://eslint.vuejs.org/rules/no-mutating-props.html
 545 |    */
 546 |   'vue/no-mutating-props'?: Linter.RuleEntry<VueNoMutatingProps>
 547 |   /**
 548 |    * disallow parsing errors in `<template>`
 549 |    * @see https://eslint.vuejs.org/rules/no-parsing-error.html
 550 |    */
 551 |   'vue/no-parsing-error'?: Linter.RuleEntry<VueNoParsingError>
 552 |   /**
 553 |    * disallow a potential typo in your component property
 554 |    * @see https://eslint.vuejs.org/rules/no-potential-component-option-typo.html
 555 |    */
 556 |   'vue/no-potential-component-option-typo'?: Linter.RuleEntry<VueNoPotentialComponentOptionTypo>
 557 |   /**
 558 |    * disallow use of value wrapped by `ref()` (Composition API) as an operand
 559 |    * @see https://eslint.vuejs.org/rules/no-ref-as-operand.html
 560 |    */
 561 |   'vue/no-ref-as-operand'?: Linter.RuleEntry<[]>
 562 |   /**
 563 |    * disallow usages of ref objects that can lead to loss of reactivity
 564 |    * @see https://eslint.vuejs.org/rules/no-ref-object-reactivity-loss.html
 565 |    */
 566 |   'vue/no-ref-object-reactivity-loss'?: Linter.RuleEntry<[]>
 567 |   /**
 568 |    * enforce props with default values to be optional
 569 |    * @see https://eslint.vuejs.org/rules/no-required-prop-with-default.html
 570 |    */
 571 |   'vue/no-required-prop-with-default'?: Linter.RuleEntry<VueNoRequiredPropWithDefault>
 572 |   /**
 573 |    * disallow the use of reserved names in component definitions
 574 |    * @see https://eslint.vuejs.org/rules/no-reserved-component-names.html
 575 |    */
 576 |   'vue/no-reserved-component-names'?: Linter.RuleEntry<VueNoReservedComponentNames>
 577 |   /**
 578 |    * disallow overwriting reserved keys
 579 |    * @see https://eslint.vuejs.org/rules/no-reserved-keys.html
 580 |    */
 581 |   'vue/no-reserved-keys'?: Linter.RuleEntry<VueNoReservedKeys>
 582 |   /**
 583 |    * disallow reserved names in props
 584 |    * @see https://eslint.vuejs.org/rules/no-reserved-props.html
 585 |    */
 586 |   'vue/no-reserved-props'?: Linter.RuleEntry<VueNoReservedProps>
 587 |   /**
 588 |    * disallow specific block
 589 |    * @see https://eslint.vuejs.org/rules/no-restricted-block.html
 590 |    */
 591 |   'vue/no-restricted-block'?: Linter.RuleEntry<VueNoRestrictedBlock>
 592 |   /**
 593 |    * disallow asynchronously called restricted methods
 594 |    * @see https://eslint.vuejs.org/rules/no-restricted-call-after-await.html
 595 |    */
 596 |   'vue/no-restricted-call-after-await'?: Linter.RuleEntry<VueNoRestrictedCallAfterAwait>
 597 |   /**
 598 |    * disallow specific classes in Vue components
 599 |    * @see https://eslint.vuejs.org/rules/no-restricted-class.html
 600 |    */
 601 |   'vue/no-restricted-class'?: Linter.RuleEntry<VueNoRestrictedClass>
 602 |   /**
 603 |    * disallow specific component names
 604 |    * @see https://eslint.vuejs.org/rules/no-restricted-component-names.html
 605 |    */
 606 |   'vue/no-restricted-component-names'?: Linter.RuleEntry<VueNoRestrictedComponentNames>
 607 |   /**
 608 |    * disallow specific component option
 609 |    * @see https://eslint.vuejs.org/rules/no-restricted-component-options.html
 610 |    */
 611 |   'vue/no-restricted-component-options'?: Linter.RuleEntry<VueNoRestrictedComponentOptions>
 612 |   /**
 613 |    * disallow specific custom event
 614 |    * @see https://eslint.vuejs.org/rules/no-restricted-custom-event.html
 615 |    */
 616 |   'vue/no-restricted-custom-event'?: Linter.RuleEntry<VueNoRestrictedCustomEvent>
 617 |   /**
 618 |    * disallow specific elements
 619 |    * @see https://eslint.vuejs.org/rules/no-restricted-html-elements.html
 620 |    */
 621 |   'vue/no-restricted-html-elements'?: Linter.RuleEntry<VueNoRestrictedHtmlElements>
 622 |   /**
 623 |    * disallow specific props
 624 |    * @see https://eslint.vuejs.org/rules/no-restricted-props.html
 625 |    */
 626 |   'vue/no-restricted-props'?: Linter.RuleEntry<VueNoRestrictedProps>
 627 |   /**
 628 |    * disallow specific attribute
 629 |    * @see https://eslint.vuejs.org/rules/no-restricted-static-attribute.html
 630 |    */
 631 |   'vue/no-restricted-static-attribute'?: Linter.RuleEntry<VueNoRestrictedStaticAttribute>
 632 |   /**
 633 |    * Disallow specified syntax in `<template>`
 634 |    * @see https://eslint.vuejs.org/rules/no-restricted-syntax.html
 635 |    */
 636 |   'vue/no-restricted-syntax'?: Linter.RuleEntry<VueNoRestrictedSyntax>
 637 |   /**
 638 |    * disallow specific argument in `v-bind`
 639 |    * @see https://eslint.vuejs.org/rules/no-restricted-v-bind.html
 640 |    */
 641 |   'vue/no-restricted-v-bind'?: Linter.RuleEntry<VueNoRestrictedVBind>
 642 |   /**
 643 |    * disallow specific argument in `v-on`
 644 |    * @see https://eslint.vuejs.org/rules/no-restricted-v-on.html
 645 |    */
 646 |   'vue/no-restricted-v-on'?: Linter.RuleEntry<VueNoRestrictedVOn>
 647 |   /**
 648 |    * disallow `v-if` directives on root element
 649 |    * @see https://eslint.vuejs.org/rules/no-root-v-if.html
 650 |    */
 651 |   'vue/no-root-v-if'?: Linter.RuleEntry<[]>
 652 |   /**
 653 |    * disallow usages that lose the reactivity of `props` passed to `setup`
 654 |    * @see https://eslint.vuejs.org/rules/no-setup-props-reactivity-loss.html
 655 |    */
 656 |   'vue/no-setup-props-reactivity-loss'?: Linter.RuleEntry<[]>
 657 |   /**
 658 |    * enforce component's data property to be a function
 659 |    * @see https://eslint.vuejs.org/rules/no-shared-component-data.html
 660 |    */
 661 |   'vue/no-shared-component-data'?: Linter.RuleEntry<[]>
 662 |   /**
 663 |    * disallow side effects in computed properties
 664 |    * @see https://eslint.vuejs.org/rules/no-side-effects-in-computed-properties.html
 665 |    */
 666 |   'vue/no-side-effects-in-computed-properties'?: Linter.RuleEntry<[]>
 667 |   /**
 668 |    * disallow spaces around equal signs in attribute
 669 |    * @see https://eslint.vuejs.org/rules/no-spaces-around-equal-signs-in-attribute.html
 670 |    */
 671 |   'vue/no-spaces-around-equal-signs-in-attribute'?: Linter.RuleEntry<[]>
 672 |   /**
 673 |    * Disallow sparse arrays in `<template>`
 674 |    * @see https://eslint.vuejs.org/rules/no-sparse-arrays.html
 675 |    */
 676 |   'vue/no-sparse-arrays'?: Linter.RuleEntry<[]>
 677 |   /**
 678 |    * disallow static inline `style` attributes
 679 |    * @see https://eslint.vuejs.org/rules/no-static-inline-styles.html
 680 |    */
 681 |   'vue/no-static-inline-styles'?: Linter.RuleEntry<VueNoStaticInlineStyles>
 682 |   /**
 683 |    * disallow `key` attribute on `<template>`
 684 |    * @see https://eslint.vuejs.org/rules/no-template-key.html
 685 |    */
 686 |   'vue/no-template-key'?: Linter.RuleEntry<[]>
 687 |   /**
 688 |    * disallow variable declarations from shadowing variables declared in the outer scope
 689 |    * @see https://eslint.vuejs.org/rules/no-template-shadow.html
 690 |    */
 691 |   'vue/no-template-shadow'?: Linter.RuleEntry<VueNoTemplateShadow>
 692 |   /**
 693 |    * disallow target="_blank" attribute without rel="noopener noreferrer"
 694 |    * @see https://eslint.vuejs.org/rules/no-template-target-blank.html
 695 |    */
 696 |   'vue/no-template-target-blank'?: Linter.RuleEntry<VueNoTemplateTargetBlank>
 697 |   /**
 698 |    * disallow mustaches in `<textarea>`
 699 |    * @see https://eslint.vuejs.org/rules/no-textarea-mustache.html
 700 |    */
 701 |   'vue/no-textarea-mustache'?: Linter.RuleEntry<[]>
 702 |   /**
 703 |    * disallow `this` usage in a `beforeRouteEnter` method
 704 |    * @see https://eslint.vuejs.org/rules/no-this-in-before-route-enter.html
 705 |    */
 706 |   'vue/no-this-in-before-route-enter'?: Linter.RuleEntry<[]>
 707 |   /**
 708 |    * disallow use of undefined components in `<template>`
 709 |    * @see https://eslint.vuejs.org/rules/no-undef-components.html
 710 |    */
 711 |   'vue/no-undef-components'?: Linter.RuleEntry<VueNoUndefComponents>
 712 |   /**
 713 |    * disallow undefined properties
 714 |    * @see https://eslint.vuejs.org/rules/no-undef-properties.html
 715 |    */
 716 |   'vue/no-undef-properties'?: Linter.RuleEntry<VueNoUndefProperties>
 717 |   /**
 718 |    * disallow unsupported Vue.js syntax on the specified version
 719 |    * @see https://eslint.vuejs.org/rules/no-unsupported-features.html
 720 |    */
 721 |   'vue/no-unsupported-features'?: Linter.RuleEntry<VueNoUnsupportedFeatures>
 722 |   /**
 723 |    * disallow registering components that are not used inside templates
 724 |    * @see https://eslint.vuejs.org/rules/no-unused-components.html
 725 |    */
 726 |   'vue/no-unused-components'?: Linter.RuleEntry<VueNoUnusedComponents>
 727 |   /**
 728 |    * disallow unused emit declarations
 729 |    * @see https://eslint.vuejs.org/rules/no-unused-emit-declarations.html
 730 |    */
 731 |   'vue/no-unused-emit-declarations'?: Linter.RuleEntry<[]>
 732 |   /**
 733 |    * disallow unused properties
 734 |    * @see https://eslint.vuejs.org/rules/no-unused-properties.html
 735 |    */
 736 |   'vue/no-unused-properties'?: Linter.RuleEntry<VueNoUnusedProperties>
 737 |   /**
 738 |    * disallow unused refs
 739 |    * @see https://eslint.vuejs.org/rules/no-unused-refs.html
 740 |    */
 741 |   'vue/no-unused-refs'?: Linter.RuleEntry<[]>
 742 |   /**
 743 |    * disallow unused variable definitions of v-for directives or scope attributes
 744 |    * @see https://eslint.vuejs.org/rules/no-unused-vars.html
 745 |    */
 746 |   'vue/no-unused-vars'?: Linter.RuleEntry<VueNoUnusedVars>
 747 |   /**
 748 |    * disallow use computed property like method
 749 |    * @see https://eslint.vuejs.org/rules/no-use-computed-property-like-method.html
 750 |    */
 751 |   'vue/no-use-computed-property-like-method'?: Linter.RuleEntry<[]>
 752 |   /**
 753 |    * disallow using `v-else-if`/`v-else` on the same element as `v-for`
 754 |    * @see https://eslint.vuejs.org/rules/no-use-v-else-with-v-for.html
 755 |    */
 756 |   'vue/no-use-v-else-with-v-for'?: Linter.RuleEntry<[]>
 757 |   /**
 758 |    * disallow using `v-if` on the same element as `v-for`
 759 |    * @see https://eslint.vuejs.org/rules/no-use-v-if-with-v-for.html
 760 |    */
 761 |   'vue/no-use-v-if-with-v-for'?: Linter.RuleEntry<VueNoUseVIfWithVFor>
 762 |   /**
 763 |    * Disallow unnecessary concatenation of literals or template literals in `<template>`
 764 |    * @see https://eslint.vuejs.org/rules/no-useless-concat.html
 765 |    */
 766 |   'vue/no-useless-concat'?: Linter.RuleEntry<[]>
 767 |   /**
 768 |    * disallow unnecessary mustache interpolations
 769 |    * @see https://eslint.vuejs.org/rules/no-useless-mustaches.html
 770 |    */
 771 |   'vue/no-useless-mustaches'?: Linter.RuleEntry<VueNoUselessMustaches>
 772 |   /**
 773 |    * disallow useless attribute on `<template>`
 774 |    * @see https://eslint.vuejs.org/rules/no-useless-template-attributes.html
 775 |    */
 776 |   'vue/no-useless-template-attributes'?: Linter.RuleEntry<[]>
 777 |   /**
 778 |    * disallow unnecessary `v-bind` directives
 779 |    * @see https://eslint.vuejs.org/rules/no-useless-v-bind.html
 780 |    */
 781 |   'vue/no-useless-v-bind'?: Linter.RuleEntry<VueNoUselessVBind>
 782 |   /**
 783 |    * disallow `key` attribute on `<template v-for>`
 784 |    * @see https://eslint.vuejs.org/rules/no-v-for-template-key.html
 785 |    * @deprecated
 786 |    */
 787 |   'vue/no-v-for-template-key'?: Linter.RuleEntry<[]>
 788 |   /**
 789 |    * disallow key of `<template v-for>` placed on child elements
 790 |    * @see https://eslint.vuejs.org/rules/no-v-for-template-key-on-child.html
 791 |    */
 792 |   'vue/no-v-for-template-key-on-child'?: Linter.RuleEntry<[]>
 793 |   /**
 794 |    * disallow use of v-html to prevent XSS attack
 795 |    * @see https://eslint.vuejs.org/rules/no-v-html.html
 796 |    */
 797 |   'vue/no-v-html'?: Linter.RuleEntry<[]>
 798 |   /**
 799 |    * disallow adding an argument to `v-model` used in custom component
 800 |    * @see https://eslint.vuejs.org/rules/no-v-model-argument.html
 801 |    * @deprecated
 802 |    */
 803 |   'vue/no-v-model-argument'?: Linter.RuleEntry<[]>
 804 |   /**
 805 |    * disallow use of v-text
 806 |    * @see https://eslint.vuejs.org/rules/no-v-text.html
 807 |    */
 808 |   'vue/no-v-text'?: Linter.RuleEntry<[]>
 809 |   /**
 810 |    * disallow v-text / v-html on component
 811 |    * @see https://eslint.vuejs.org/rules/no-v-text-v-html-on-component.html
 812 |    */
 813 |   'vue/no-v-text-v-html-on-component'?: Linter.RuleEntry<VueNoVTextVHtmlOnComponent>
 814 |   /**
 815 |    * disallow asynchronously registered `watch`
 816 |    * @see https://eslint.vuejs.org/rules/no-watch-after-await.html
 817 |    */
 818 |   'vue/no-watch-after-await'?: Linter.RuleEntry<[]>
 819 |   /**
 820 |    * Enforce consistent line breaks after opening and before closing braces in `<template>`
 821 |    * @see https://eslint.vuejs.org/rules/object-curly-newline.html
 822 |    */
 823 |   'vue/object-curly-newline'?: Linter.RuleEntry<VueObjectCurlyNewline>
 824 |   /**
 825 |    * Enforce consistent spacing inside braces in `<template>`
 826 |    * @see https://eslint.vuejs.org/rules/object-curly-spacing.html
 827 |    */
 828 |   'vue/object-curly-spacing'?: Linter.RuleEntry<VueObjectCurlySpacing>
 829 |   /**
 830 |    * Enforce placing object properties on separate lines in `<template>`
 831 |    * @see https://eslint.vuejs.org/rules/object-property-newline.html
 832 |    */
 833 |   'vue/object-property-newline'?: Linter.RuleEntry<VueObjectPropertyNewline>
 834 |   /**
 835 |    * Require or disallow method and property shorthand syntax for object literals in `<template>`
 836 |    * @see https://eslint.vuejs.org/rules/object-shorthand.html
 837 |    */
 838 |   'vue/object-shorthand'?: Linter.RuleEntry<VueObjectShorthand>
 839 |   /**
 840 |    * enforce that each component should be in its own file
 841 |    * @see https://eslint.vuejs.org/rules/one-component-per-file.html
 842 |    */
 843 |   'vue/one-component-per-file'?: Linter.RuleEntry<[]>
 844 |   /**
 845 |    * Enforce consistent linebreak style for operators in `<template>`
 846 |    * @see https://eslint.vuejs.org/rules/operator-linebreak.html
 847 |    */
 848 |   'vue/operator-linebreak'?: Linter.RuleEntry<VueOperatorLinebreak>
 849 |   /**
 850 |    * enforce order of properties in components
 851 |    * @see https://eslint.vuejs.org/rules/order-in-components.html
 852 |    */
 853 |   'vue/order-in-components'?: Linter.RuleEntry<VueOrderInComponents>
 854 |   /**
 855 |    * require or disallow padding lines between blocks
 856 |    * @see https://eslint.vuejs.org/rules/padding-line-between-blocks.html
 857 |    */
 858 |   'vue/padding-line-between-blocks'?: Linter.RuleEntry<VuePaddingLineBetweenBlocks>
 859 |   /**
 860 |    * require or disallow newlines between sibling tags in template
 861 |    * @see https://eslint.vuejs.org/rules/padding-line-between-tags.html
 862 |    */
 863 |   'vue/padding-line-between-tags'?: Linter.RuleEntry<VuePaddingLineBetweenTags>
 864 |   /**
 865 |    * require or disallow padding lines in component definition
 866 |    * @see https://eslint.vuejs.org/rules/padding-lines-in-component-definition.html
 867 |    */
 868 |   'vue/padding-lines-in-component-definition'?: Linter.RuleEntry<VuePaddingLinesInComponentDefinition>
 869 |   /**
 870 |    * enforce use of `defineOptions` instead of default export
 871 |    * @see https://eslint.vuejs.org/rules/prefer-define-options.html
 872 |    */
 873 |   'vue/prefer-define-options'?: Linter.RuleEntry<[]>
 874 |   /**
 875 |    * enforce import from 'vue' instead of import from '@vue/*'
 876 |    * @see https://eslint.vuejs.org/rules/prefer-import-from-vue.html
 877 |    */
 878 |   'vue/prefer-import-from-vue'?: Linter.RuleEntry<[]>
 879 |   /**
 880 |    * enforce `Boolean` comes first in component prop types
 881 |    * @see https://eslint.vuejs.org/rules/prefer-prop-type-boolean-first.html
 882 |    */
 883 |   'vue/prefer-prop-type-boolean-first'?: Linter.RuleEntry<[]>
 884 |   /**
 885 |    * require static class names in template to be in a separate `class` attribute
 886 |    * @see https://eslint.vuejs.org/rules/prefer-separate-static-class.html
 887 |    */
 888 |   'vue/prefer-separate-static-class'?: Linter.RuleEntry<[]>
 889 |   /**
 890 |    * Require template literals instead of string concatenation in `<template>`
 891 |    * @see https://eslint.vuejs.org/rules/prefer-template.html
 892 |    */
 893 |   'vue/prefer-template'?: Linter.RuleEntry<[]>
 894 |   /**
 895 |    * require shorthand form attribute when `v-bind` value is `true`
 896 |    * @see https://eslint.vuejs.org/rules/prefer-true-attribute-shorthand.html
 897 |    */
 898 |   'vue/prefer-true-attribute-shorthand'?: Linter.RuleEntry<VuePreferTrueAttributeShorthand>
 899 |   /**
 900 |    * require using `useTemplateRef` instead of `ref`/`shallowRef` for template refs
 901 |    * @see https://eslint.vuejs.org/rules/prefer-use-template-ref.html
 902 |    */
 903 |   'vue/prefer-use-template-ref'?: Linter.RuleEntry<[]>
 904 |   /**
 905 |    * enforce specific casing for the Prop name in Vue components
 906 |    * @see https://eslint.vuejs.org/rules/prop-name-casing.html
 907 |    */
 908 |   'vue/prop-name-casing'?: Linter.RuleEntry<VuePropNameCasing>
 909 |   /**
 910 |    * Require quotes around object literal, type literal, interfaces and enums property names in `<template>`
 911 |    * @see https://eslint.vuejs.org/rules/quote-props.html
 912 |    */
 913 |   'vue/quote-props'?: Linter.RuleEntry<VueQuoteProps>
 914 |   /**
 915 |    * require `v-bind:is` of `<component>` elements
 916 |    * @see https://eslint.vuejs.org/rules/require-component-is.html
 917 |    */
 918 |   'vue/require-component-is'?: Linter.RuleEntry<[]>
 919 |   /**
 920 |    * require components to be the default export
 921 |    * @see https://eslint.vuejs.org/rules/require-default-export.html
 922 |    */
 923 |   'vue/require-default-export'?: Linter.RuleEntry<[]>
 924 |   /**
 925 |    * require default value for props
 926 |    * @see https://eslint.vuejs.org/rules/require-default-prop.html
 927 |    */
 928 |   'vue/require-default-prop'?: Linter.RuleEntry<[]>
 929 |   /**
 930 |    * require the component to be directly exported
 931 |    * @see https://eslint.vuejs.org/rules/require-direct-export.html
 932 |    */
 933 |   'vue/require-direct-export'?: Linter.RuleEntry<VueRequireDirectExport>
 934 |   /**
 935 |    * require type definitions in emits
 936 |    * @see https://eslint.vuejs.org/rules/require-emit-validator.html
 937 |    */
 938 |   'vue/require-emit-validator'?: Linter.RuleEntry<[]>
 939 |   /**
 940 |    * require `emits` option with name triggered by `$emit()`
 941 |    * @see https://eslint.vuejs.org/rules/require-explicit-emits.html
 942 |    */
 943 |   'vue/require-explicit-emits'?: Linter.RuleEntry<VueRequireExplicitEmits>
 944 |   /**
 945 |    * require slots to be explicitly defined
 946 |    * @see https://eslint.vuejs.org/rules/require-explicit-slots.html
 947 |    */
 948 |   'vue/require-explicit-slots'?: Linter.RuleEntry<[]>
 949 |   /**
 950 |    * require declare public properties using `expose`
 951 |    * @see https://eslint.vuejs.org/rules/require-expose.html
 952 |    */
 953 |   'vue/require-expose'?: Linter.RuleEntry<[]>
 954 |   /**
 955 |    * require a certain macro variable name
 956 |    * @see https://eslint.vuejs.org/rules/require-macro-variable-name.html
 957 |    */
 958 |   'vue/require-macro-variable-name'?: Linter.RuleEntry<VueRequireMacroVariableName>
 959 |   /**
 960 |    * require a name property in Vue components
 961 |    * @see https://eslint.vuejs.org/rules/require-name-property.html
 962 |    */
 963 |   'vue/require-name-property'?: Linter.RuleEntry<[]>
 964 |   /**
 965 |    * require props to have a comment
 966 |    * @see https://eslint.vuejs.org/rules/require-prop-comment.html
 967 |    */
 968 |   'vue/require-prop-comment'?: Linter.RuleEntry<VueRequirePropComment>
 969 |   /**
 970 |    * require prop type to be a constructor
 971 |    * @see https://eslint.vuejs.org/rules/require-prop-type-constructor.html
 972 |    */
 973 |   'vue/require-prop-type-constructor'?: Linter.RuleEntry<[]>
 974 |   /**
 975 |    * require type definitions in props
 976 |    * @see https://eslint.vuejs.org/rules/require-prop-types.html
 977 |    */
 978 |   'vue/require-prop-types'?: Linter.RuleEntry<[]>
 979 |   /**
 980 |    * enforce render function to always return value
 981 |    * @see https://eslint.vuejs.org/rules/require-render-return.html
 982 |    */
 983 |   'vue/require-render-return'?: Linter.RuleEntry<[]>
 984 |   /**
 985 |    * enforce properties of `$slots` to be used as a function
 986 |    * @see https://eslint.vuejs.org/rules/require-slots-as-functions.html
 987 |    */
 988 |   'vue/require-slots-as-functions'?: Linter.RuleEntry<[]>
 989 |   /**
 990 |    * require control the display of the content inside `<transition>`
 991 |    * @see https://eslint.vuejs.org/rules/require-toggle-inside-transition.html
 992 |    */
 993 |   'vue/require-toggle-inside-transition'?: Linter.RuleEntry<VueRequireToggleInsideTransition>
 994 |   /**
 995 |    * enforce adding type declarations to object props
 996 |    * @see https://eslint.vuejs.org/rules/require-typed-object-prop.html
 997 |    */
 998 |   'vue/require-typed-object-prop'?: Linter.RuleEntry<[]>
 999 |   /**
1000 |    * require `ref` and `shallowRef` functions to be strongly typed
1001 |    * @see https://eslint.vuejs.org/rules/require-typed-ref.html
1002 |    */
1003 |   'vue/require-typed-ref'?: Linter.RuleEntry<[]>
1004 |   /**
1005 |    * require `v-bind:key` with `v-for` directives
1006 |    * @see https://eslint.vuejs.org/rules/require-v-for-key.html
1007 |    */
1008 |   'vue/require-v-for-key'?: Linter.RuleEntry<[]>
1009 |   /**
1010 |    * enforce props default values to be valid
1011 |    * @see https://eslint.vuejs.org/rules/require-valid-default-prop.html
1012 |    */
1013 |   'vue/require-valid-default-prop'?: Linter.RuleEntry<[]>
1014 |   /**
1015 |    * enforce using only specific component names
1016 |    * @see https://eslint.vuejs.org/rules/restricted-component-names.html
1017 |    */
1018 |   'vue/restricted-component-names'?: Linter.RuleEntry<VueRestrictedComponentNames>
1019 |   /**
1020 |    * enforce that a return statement is present in computed property
1021 |    * @see https://eslint.vuejs.org/rules/return-in-computed-property.html
1022 |    */
1023 |   'vue/return-in-computed-property'?: Linter.RuleEntry<VueReturnInComputedProperty>
1024 |   /**
1025 |    * enforce that a return statement is present in emits validator
1026 |    * @see https://eslint.vuejs.org/rules/return-in-emits-validator.html
1027 |    */
1028 |   'vue/return-in-emits-validator'?: Linter.RuleEntry<[]>
1029 |   /**
1030 |    * enforce consistent indentation in `<script>`
1031 |    * @see https://eslint.vuejs.org/rules/script-indent.html
1032 |    */
1033 |   'vue/script-indent'?: Linter.RuleEntry<VueScriptIndent>
1034 |   /**
1035 |    * require a line break before and after the contents of a singleline element
1036 |    * @see https://eslint.vuejs.org/rules/singleline-html-element-content-newline.html
1037 |    */
1038 |   'vue/singleline-html-element-content-newline'?: Linter.RuleEntry<VueSinglelineHtmlElementContentNewline>
1039 |   /**
1040 |    * enforce specific casing for slot names
1041 |    * @see https://eslint.vuejs.org/rules/slot-name-casing.html
1042 |    */
1043 |   'vue/slot-name-casing'?: Linter.RuleEntry<VueSlotNameCasing>
1044 |   /**
1045 |    * enforce sort-keys in a manner that is compatible with order-in-components
1046 |    * @see https://eslint.vuejs.org/rules/sort-keys.html
1047 |    */
1048 |   'vue/sort-keys'?: Linter.RuleEntry<VueSortKeys>
1049 |   /**
1050 |    * Enforce consistent spacing inside parentheses in `<template>`
1051 |    * @see https://eslint.vuejs.org/rules/space-in-parens.html
1052 |    */
1053 |   'vue/space-in-parens'?: Linter.RuleEntry<VueSpaceInParens>
1054 |   /**
1055 |    * Require spacing around infix operators in `<template>`
1056 |    * @see https://eslint.vuejs.org/rules/space-infix-ops.html
1057 |    */
1058 |   'vue/space-infix-ops'?: Linter.RuleEntry<VueSpaceInfixOps>
1059 |   /**
1060 |    * Enforce consistent spacing before or after unary operators in `<template>`
1061 |    * @see https://eslint.vuejs.org/rules/space-unary-ops.html
1062 |    */
1063 |   'vue/space-unary-ops'?: Linter.RuleEntry<VueSpaceUnaryOps>
1064 |   /**
1065 |    * enforce static class names order
1066 |    * @see https://eslint.vuejs.org/rules/static-class-names-order.html
1067 |    */
1068 |   'vue/static-class-names-order'?: Linter.RuleEntry<[]>
1069 |   /**
1070 |    * Require or disallow spacing around embedded expressions of template strings in `<template>`
1071 |    * @see https://eslint.vuejs.org/rules/template-curly-spacing.html
1072 |    */
1073 |   'vue/template-curly-spacing'?: Linter.RuleEntry<VueTemplateCurlySpacing>
1074 |   /**
1075 |    * disallow usage of `this` in template
1076 |    * @see https://eslint.vuejs.org/rules/this-in-template.html
1077 |    */
1078 |   'vue/this-in-template'?: Linter.RuleEntry<VueThisInTemplate>
1079 |   /**
1080 |    * enforce usage of `exact` modifier on `v-on`
1081 |    * @see https://eslint.vuejs.org/rules/use-v-on-exact.html
1082 |    */
1083 |   'vue/use-v-on-exact'?: Linter.RuleEntry<[]>
1084 |   /**
1085 |    * enforce `v-bind` directive style
1086 |    * @see https://eslint.vuejs.org/rules/v-bind-style.html
1087 |    */
1088 |   'vue/v-bind-style'?: Linter.RuleEntry<VueVBindStyle>
1089 |   /**
1090 |    * enforce `v-for` directive's delimiter style
1091 |    * @see https://eslint.vuejs.org/rules/v-for-delimiter-style.html
1092 |    */
1093 |   'vue/v-for-delimiter-style'?: Linter.RuleEntry<VueVForDelimiterStyle>
1094 |   /**
1095 |    * require key attribute for conditionally rendered repeated components
1096 |    * @see https://eslint.vuejs.org/rules/v-if-else-key.html
1097 |    */
1098 |   'vue/v-if-else-key'?: Linter.RuleEntry<[]>
1099 |   /**
1100 |    * enforce v-on event naming style on custom components in template
1101 |    * @see https://eslint.vuejs.org/rules/v-on-event-hyphenation.html
1102 |    */
1103 |   'vue/v-on-event-hyphenation'?: Linter.RuleEntry<VueVOnEventHyphenation>
1104 |   /**
1105 |    * enforce writing style for handlers in `v-on` directives
1106 |    * @see https://eslint.vuejs.org/rules/v-on-handler-style.html
1107 |    */
1108 |   'vue/v-on-handler-style'?: Linter.RuleEntry<VueVOnHandlerStyle>
1109 |   /**
1110 |    * enforce `v-on` directive style
1111 |    * @see https://eslint.vuejs.org/rules/v-on-style.html
1112 |    */
1113 |   'vue/v-on-style'?: Linter.RuleEntry<VueVOnStyle>
1114 |   /**
1115 |    * enforce `v-slot` directive style
1116 |    * @see https://eslint.vuejs.org/rules/v-slot-style.html
1117 |    */
1118 |   'vue/v-slot-style'?: Linter.RuleEntry<VueVSlotStyle>
1119 |   /**
1120 |    * require valid attribute names
1121 |    * @see https://eslint.vuejs.org/rules/valid-attribute-name.html
1122 |    */
1123 |   'vue/valid-attribute-name'?: Linter.RuleEntry<[]>
1124 |   /**
1125 |    * enforce valid `defineEmits` compiler macro
1126 |    * @see https://eslint.vuejs.org/rules/valid-define-emits.html
1127 |    */
1128 |   'vue/valid-define-emits'?: Linter.RuleEntry<[]>
1129 |   /**
1130 |    * enforce valid `defineOptions` compiler macro
1131 |    * @see https://eslint.vuejs.org/rules/valid-define-options.html
1132 |    */
1133 |   'vue/valid-define-options'?: Linter.RuleEntry<[]>
1134 |   /**
1135 |    * enforce valid `defineProps` compiler macro
1136 |    * @see https://eslint.vuejs.org/rules/valid-define-props.html
1137 |    */
1138 |   'vue/valid-define-props'?: Linter.RuleEntry<[]>
1139 |   /**
1140 |    * require valid keys in model option
1141 |    * @see https://eslint.vuejs.org/rules/valid-model-definition.html
1142 |    * @deprecated
1143 |    */
1144 |   'vue/valid-model-definition'?: Linter.RuleEntry<[]>
1145 |   /**
1146 |    * enforce valid `nextTick` function calls
1147 |    * @see https://eslint.vuejs.org/rules/valid-next-tick.html
1148 |    */
1149 |   'vue/valid-next-tick'?: Linter.RuleEntry<[]>
1150 |   /**
1151 |    * enforce valid template root
1152 |    * @see https://eslint.vuejs.org/rules/valid-template-root.html
1153 |    */
1154 |   'vue/valid-template-root'?: Linter.RuleEntry<[]>
1155 |   /**
1156 |    * enforce valid `v-bind` directives
1157 |    * @see https://eslint.vuejs.org/rules/valid-v-bind.html
1158 |    */
1159 |   'vue/valid-v-bind'?: Linter.RuleEntry<[]>
1160 |   /**
1161 |    * enforce valid `.sync` modifier on `v-bind` directives
1162 |    * @see https://eslint.vuejs.org/rules/valid-v-bind-sync.html
1163 |    * @deprecated
1164 |    */
1165 |   'vue/valid-v-bind-sync'?: Linter.RuleEntry<[]>
1166 |   /**
1167 |    * enforce valid `v-cloak` directives
1168 |    * @see https://eslint.vuejs.org/rules/valid-v-cloak.html
1169 |    */
1170 |   'vue/valid-v-cloak'?: Linter.RuleEntry<[]>
1171 |   /**
1172 |    * enforce valid `v-else` directives
1173 |    * @see https://eslint.vuejs.org/rules/valid-v-else.html
1174 |    */
1175 |   'vue/valid-v-else'?: Linter.RuleEntry<[]>
1176 |   /**
1177 |    * enforce valid `v-else-if` directives
1178 |    * @see https://eslint.vuejs.org/rules/valid-v-else-if.html
1179 |    */
1180 |   'vue/valid-v-else-if'?: Linter.RuleEntry<[]>
1181 |   /**
1182 |    * enforce valid `v-for` directives
1183 |    * @see https://eslint.vuejs.org/rules/valid-v-for.html
1184 |    */
1185 |   'vue/valid-v-for'?: Linter.RuleEntry<[]>
1186 |   /**
1187 |    * enforce valid `v-html` directives
1188 |    * @see https://eslint.vuejs.org/rules/valid-v-html.html
1189 |    */
1190 |   'vue/valid-v-html'?: Linter.RuleEntry<[]>
1191 |   /**
1192 |    * enforce valid `v-if` directives
1193 |    * @see https://eslint.vuejs.org/rules/valid-v-if.html
1194 |    */
1195 |   'vue/valid-v-if'?: Linter.RuleEntry<[]>
1196 |   /**
1197 |    * enforce valid `v-is` directives
1198 |    * @see https://eslint.vuejs.org/rules/valid-v-is.html
1199 |    */
1200 |   'vue/valid-v-is'?: Linter.RuleEntry<[]>
1201 |   /**
1202 |    * enforce valid `v-memo` directives
1203 |    * @see https://eslint.vuejs.org/rules/valid-v-memo.html
1204 |    */
1205 |   'vue/valid-v-memo'?: Linter.RuleEntry<[]>
1206 |   /**
1207 |    * enforce valid `v-model` directives
1208 |    * @see https://eslint.vuejs.org/rules/valid-v-model.html
1209 |    */
1210 |   'vue/valid-v-model'?: Linter.RuleEntry<[]>
1211 |   /**
1212 |    * enforce valid `v-on` directives
1213 |    * @see https://eslint.vuejs.org/rules/valid-v-on.html
1214 |    */
1215 |   'vue/valid-v-on'?: Linter.RuleEntry<VueValidVOn>
1216 |   /**
1217 |    * enforce valid `v-once` directives
1218 |    * @see https://eslint.vuejs.org/rules/valid-v-once.html
1219 |    */
1220 |   'vue/valid-v-once'?: Linter.RuleEntry<[]>
1221 |   /**
1222 |    * enforce valid `v-pre` directives
1223 |    * @see https://eslint.vuejs.org/rules/valid-v-pre.html
1224 |    */
1225 |   'vue/valid-v-pre'?: Linter.RuleEntry<[]>
1226 |   /**
1227 |    * enforce valid `v-show` directives
1228 |    * @see https://eslint.vuejs.org/rules/valid-v-show.html
1229 |    */
1230 |   'vue/valid-v-show'?: Linter.RuleEntry<[]>
1231 |   /**
1232 |    * enforce valid `v-slot` directives
1233 |    * @see https://eslint.vuejs.org/rules/valid-v-slot.html
1234 |    */
1235 |   'vue/valid-v-slot'?: Linter.RuleEntry<VueValidVSlot>
1236 |   /**
1237 |    * enforce valid `v-text` directives
1238 |    * @see https://eslint.vuejs.org/rules/valid-v-text.html
1239 |    */
1240 |   'vue/valid-v-text'?: Linter.RuleEntry<[]>
1241 | }
1242 | 
1243 | /* ======= Declarations ======= */
1244 | // ----- vue/array-bracket-newline -----
1245 | type VueArrayBracketNewline = []|[(("always" | "never" | "consistent") | {
1246 |   multiline?: boolean
1247 |   minItems?: (number | null)
1248 | })]
1249 | // ----- vue/array-bracket-spacing -----
1250 | type VueArrayBracketSpacing = []|[("always" | "never")]|[("always" | "never"), {
1251 |   singleValue?: boolean
1252 |   objectsInArrays?: boolean
1253 |   arraysInArrays?: boolean
1254 | }]
1255 | // ----- vue/array-element-newline -----
1256 | type VueArrayElementNewline = []|[(_VueArrayElementNewlineBasicConfig | {
1257 |   ArrayExpression?: _VueArrayElementNewlineBasicConfig
1258 |   ArrayPattern?: _VueArrayElementNewlineBasicConfig
1259 | })]
1260 | type _VueArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
1261 |   consistent?: boolean
1262 |   multiline?: boolean
1263 |   minItems?: (number | null)
1264 | })
1265 | // ----- vue/arrow-spacing -----
1266 | type VueArrowSpacing = []|[{
1267 |   before?: boolean
1268 |   after?: boolean
1269 | }]
1270 | // ----- vue/attribute-hyphenation -----
1271 | type VueAttributeHyphenation = []|[("always" | "never")]|[("always" | "never"), {
1272 |   ignore?: (string & {
1273 |     [k: string]: unknown | undefined
1274 |   } & {
1275 |     [k: string]: unknown | undefined
1276 |   })[]
1277 |   ignoreTags?: string[]
1278 | }]
1279 | // ----- vue/attributes-order -----
1280 | type VueAttributesOrder = []|[{
1281 |   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")[])[]
1282 |   alphabetical?: boolean
1283 | }]
1284 | // ----- vue/block-lang -----
1285 | type VueBlockLang = []|[{
1286 |   [k: string]: {
1287 |     lang?: (string | string[])
1288 |     allowNoLang?: boolean
1289 |   }
1290 | }]
1291 | // ----- vue/block-order -----
1292 | type VueBlockOrder = []|[{
1293 |   order?: (string | string[])[]
1294 | }]
1295 | // ----- vue/block-spacing -----
1296 | type VueBlockSpacing = []|[("always" | "never")]
1297 | // ----- vue/block-tag-newline -----
1298 | type VueBlockTagNewline = []|[{
1299 |   singleline?: ("always" | "never" | "consistent" | "ignore")
1300 |   multiline?: ("always" | "never" | "consistent" | "ignore")
1301 |   maxEmptyLines?: number
1302 |   blocks?: {
1303 |     [k: string]: {
1304 |       singleline?: ("always" | "never" | "consistent" | "ignore")
1305 |       multiline?: ("always" | "never" | "consistent" | "ignore")
1306 |       maxEmptyLines?: number
1307 |     }
1308 |   }
1309 | }]
1310 | // ----- vue/brace-style -----
1311 | type VueBraceStyle = []|[("1tbs" | "stroustrup" | "allman")]|[("1tbs" | "stroustrup" | "allman"), {
1312 |   allowSingleLine?: boolean
1313 | }]
1314 | // ----- vue/camelcase -----
1315 | type VueCamelcase = []|[{
1316 |   ignoreDestructuring?: boolean
1317 |   ignoreImports?: boolean
1318 |   ignoreGlobals?: boolean
1319 |   properties?: ("always" | "never")
1320 |   
1321 |   allow?: string[]
1322 | }]
1323 | // ----- vue/comma-dangle -----
1324 | type VueCommaDangle = []|[(_VueCommaDangleValue | {
1325 |   arrays?: _VueCommaDangleValueWithIgnore
1326 |   objects?: _VueCommaDangleValueWithIgnore
1327 |   imports?: _VueCommaDangleValueWithIgnore
1328 |   exports?: _VueCommaDangleValueWithIgnore
1329 |   functions?: _VueCommaDangleValueWithIgnore
1330 |   importAttributes?: _VueCommaDangleValueWithIgnore
1331 |   dynamicImports?: _VueCommaDangleValueWithIgnore
1332 |   enums?: _VueCommaDangleValueWithIgnore
1333 |   generics?: _VueCommaDangleValueWithIgnore
1334 |   tuples?: _VueCommaDangleValueWithIgnore
1335 | })]
1336 | type _VueCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline")
1337 | type _VueCommaDangleValueWithIgnore = ("always-multiline" | "always" | "never" | "only-multiline" | "ignore")
1338 | // ----- vue/comma-spacing -----
1339 | type VueCommaSpacing = []|[{
1340 |   before?: boolean
1341 |   after?: boolean
1342 | }]
1343 | // ----- vue/comma-style -----
1344 | type VueCommaStyle = []|[("first" | "last")]|[("first" | "last"), {
1345 |   exceptions?: {
1346 |     [k: string]: boolean | undefined
1347 |   }
1348 | }]
1349 | // ----- vue/comment-directive -----
1350 | type VueCommentDirective = []|[{
1351 |   reportUnusedDisableDirectives?: boolean
1352 | }]
1353 | // ----- vue/component-api-style -----
1354 | type VueComponentApiStyle = []|[[("script-setup" | "composition" | "composition-vue2" | "options"), ...(("script-setup" | "composition" | "composition-vue2" | "options"))[]]]
1355 | // ----- vue/component-definition-name-casing -----
1356 | type VueComponentDefinitionNameCasing = []|[("PascalCase" | "kebab-case")]
1357 | // ----- vue/component-name-in-template-casing -----
1358 | type VueComponentNameInTemplateCasing = []|[("PascalCase" | "kebab-case")]|[("PascalCase" | "kebab-case"), {
1359 |   globals?: string[]
1360 |   ignores?: string[]
1361 |   registeredComponentsOnly?: boolean
1362 | }]
1363 | // ----- vue/component-options-name-casing -----
1364 | type VueComponentOptionsNameCasing = []|[("camelCase" | "kebab-case" | "PascalCase")]
1365 | // ----- vue/custom-event-name-casing -----
1366 | type VueCustomEventNameCasing = []|[("kebab-case" | "camelCase")]|[("kebab-case" | "camelCase"), {
1367 |   ignores?: string[]
1368 | }]
1369 | // ----- vue/define-emits-declaration -----
1370 | type VueDefineEmitsDeclaration = []|[("type-based" | "type-literal" | "runtime")]
1371 | // ----- vue/define-macros-order -----
1372 | type VueDefineMacrosOrder = []|[{
1373 |   order?: string[]
1374 |   defineExposeLast?: boolean
1375 | }]
1376 | // ----- vue/define-props-declaration -----
1377 | type VueDefinePropsDeclaration = []|[("type-based" | "runtime")]
1378 | // ----- vue/define-props-destructuring -----
1379 | type VueDefinePropsDestructuring = []|[{
1380 |   destructure?: ("always" | "never")
1381 | }]
1382 | // ----- vue/dot-location -----
1383 | type VueDotLocation = []|[("object" | "property")]
1384 | // ----- vue/dot-notation -----
1385 | type VueDotNotation = []|[{
1386 |   allowKeywords?: boolean
1387 |   allowPattern?: string
1388 | }]
1389 | // ----- vue/enforce-style-attribute -----
1390 | type VueEnforceStyleAttribute = []|[{
1391 |   
1392 |   allow?: [("plain" | "scoped" | "module"), ...(("plain" | "scoped" | "module"))[]]
1393 | }]
1394 | // ----- vue/eqeqeq -----
1395 | type VueEqeqeq = ([]|["always"]|["always", {
1396 |   null?: ("always" | "never" | "ignore")
1397 | }] | []|[("smart" | "allow-null")])
1398 | // ----- vue/first-attribute-linebreak -----
1399 | type VueFirstAttributeLinebreak = []|[{
1400 |   multiline?: ("below" | "beside" | "ignore")
1401 |   singleline?: ("below" | "beside" | "ignore")
1402 | }]
1403 | // ----- vue/func-call-spacing -----
1404 | type VueFuncCallSpacing = ([]|["never"] | []|["always"]|["always", {
1405 |   allowNewlines?: boolean
1406 |   optionalChain?: {
1407 |     before?: boolean
1408 |     after?: boolean
1409 |   }
1410 | }])
1411 | // ----- vue/html-button-has-type -----
1412 | type VueHtmlButtonHasType = []|[{
1413 |   button?: boolean
1414 |   submit?: boolean
1415 |   reset?: boolean
1416 | }]
1417 | // ----- vue/html-closing-bracket-newline -----
1418 | type VueHtmlClosingBracketNewline = []|[{
1419 |   singleline?: ("always" | "never")
1420 |   multiline?: ("always" | "never")
1421 |   selfClosingTag?: {
1422 |     singleline?: ("always" | "never")
1423 |     multiline?: ("always" | "never")
1424 |   }
1425 | }]
1426 | // ----- vue/html-closing-bracket-spacing -----
1427 | type VueHtmlClosingBracketSpacing = []|[{
1428 |   startTag?: ("always" | "never")
1429 |   endTag?: ("always" | "never")
1430 |   selfClosingTag?: ("always" | "never")
1431 | }]
1432 | // ----- vue/html-comment-content-newline -----
1433 | type VueHtmlCommentContentNewline = []|[(("always" | "never") | {
1434 |   singleline?: ("always" | "never" | "ignore")
1435 |   multiline?: ("always" | "never" | "ignore")
1436 | })]|[(("always" | "never") | {
1437 |   singleline?: ("always" | "never" | "ignore")
1438 |   multiline?: ("always" | "never" | "ignore")
1439 | }), {
1440 |   exceptions?: string[]
1441 | }]
1442 | // ----- vue/html-comment-content-spacing -----
1443 | type VueHtmlCommentContentSpacing = []|[("always" | "never")]|[("always" | "never"), {
1444 |   exceptions?: string[]
1445 | }]
1446 | // ----- vue/html-comment-indent -----
1447 | type VueHtmlCommentIndent = []|[(number | "tab")]
1448 | // ----- vue/html-indent -----
1449 | type VueHtmlIndent = []|[(number | "tab")]|[(number | "tab"), {
1450 |   attribute?: number
1451 |   baseIndent?: number
1452 |   closeBracket?: (number | {
1453 |     startTag?: number
1454 |     endTag?: number
1455 |     selfClosingTag?: number
1456 |   })
1457 |   switchCase?: number
1458 |   alignAttributesVertically?: boolean
1459 |   ignores?: (string & {
1460 |     [k: string]: unknown | undefined
1461 |   } & {
1462 |     [k: string]: unknown | undefined
1463 |   })[]
1464 | }]
1465 | // ----- vue/html-quotes -----
1466 | type VueHtmlQuotes = []|[("double" | "single")]|[("double" | "single"), {
1467 |   avoidEscape?: boolean
1468 | }]
1469 | // ----- vue/html-self-closing -----
1470 | type VueHtmlSelfClosing = []|[{
1471 |   html?: {
1472 |     normal?: _VueHtmlSelfClosingOptionValue
1473 |     void?: _VueHtmlSelfClosingOptionValue
1474 |     component?: _VueHtmlSelfClosingOptionValue
1475 |   }
1476 |   svg?: _VueHtmlSelfClosingOptionValue
1477 |   math?: _VueHtmlSelfClosingOptionValue
1478 | }]
1479 | type _VueHtmlSelfClosingOptionValue = ("always" | "never" | "any")
1480 | // ----- vue/key-spacing -----
1481 | type VueKeySpacing = []|[({
1482 |   align?: (("colon" | "value") | {
1483 |     mode?: ("strict" | "minimum")
1484 |     on?: ("colon" | "value")
1485 |     beforeColon?: boolean
1486 |     afterColon?: boolean
1487 |   })
1488 |   mode?: ("strict" | "minimum")
1489 |   beforeColon?: boolean
1490 |   afterColon?: boolean
1491 |   ignoredNodes?: ("ObjectExpression" | "ObjectPattern" | "ImportDeclaration" | "ExportNamedDeclaration" | "ExportAllDeclaration" | "TSTypeLiteral" | "TSInterfaceBody" | "ClassBody")[]
1492 | } | {
1493 |   singleLine?: {
1494 |     mode?: ("strict" | "minimum")
1495 |     beforeColon?: boolean
1496 |     afterColon?: boolean
1497 |   }
1498 |   multiLine?: {
1499 |     align?: (("colon" | "value") | {
1500 |       mode?: ("strict" | "minimum")
1501 |       on?: ("colon" | "value")
1502 |       beforeColon?: boolean
1503 |       afterColon?: boolean
1504 |     })
1505 |     mode?: ("strict" | "minimum")
1506 |     beforeColon?: boolean
1507 |     afterColon?: boolean
1508 |   }
1509 | } | {
1510 |   singleLine?: {
1511 |     mode?: ("strict" | "minimum")
1512 |     beforeColon?: boolean
1513 |     afterColon?: boolean
1514 |   }
1515 |   multiLine?: {
1516 |     mode?: ("strict" | "minimum")
1517 |     beforeColon?: boolean
1518 |     afterColon?: boolean
1519 |   }
1520 |   align?: {
1521 |     mode?: ("strict" | "minimum")
1522 |     on?: ("colon" | "value")
1523 |     beforeColon?: boolean
1524 |     afterColon?: boolean
1525 |   }
1526 | })]
1527 | // ----- vue/keyword-spacing -----
1528 | type VueKeywordSpacing = []|[{
1529 |   before?: boolean
1530 |   after?: boolean
1531 |   overrides?: {
1532 |     abstract?: {
1533 |       before?: boolean
1534 |       after?: boolean
1535 |     }
1536 |     boolean?: {
1537 |       before?: boolean
1538 |       after?: boolean
1539 |     }
1540 |     break?: {
1541 |       before?: boolean
1542 |       after?: boolean
1543 |     }
1544 |     byte?: {
1545 |       before?: boolean
1546 |       after?: boolean
1547 |     }
1548 |     case?: {
1549 |       before?: boolean
1550 |       after?: boolean
1551 |     }
1552 |     catch?: {
1553 |       before?: boolean
1554 |       after?: boolean
1555 |     }
1556 |     char?: {
1557 |       before?: boolean
1558 |       after?: boolean
1559 |     }
1560 |     class?: {
1561 |       before?: boolean
1562 |       after?: boolean
1563 |     }
1564 |     const?: {
1565 |       before?: boolean
1566 |       after?: boolean
1567 |     }
1568 |     continue?: {
1569 |       before?: boolean
1570 |       after?: boolean
1571 |     }
1572 |     debugger?: {
1573 |       before?: boolean
1574 |       after?: boolean
1575 |     }
1576 |     default?: {
1577 |       before?: boolean
1578 |       after?: boolean
1579 |     }
1580 |     delete?: {
1581 |       before?: boolean
1582 |       after?: boolean
1583 |     }
1584 |     do?: {
1585 |       before?: boolean
1586 |       after?: boolean
1587 |     }
1588 |     double?: {
1589 |       before?: boolean
1590 |       after?: boolean
1591 |     }
1592 |     else?: {
1593 |       before?: boolean
1594 |       after?: boolean
1595 |     }
1596 |     enum?: {
1597 |       before?: boolean
1598 |       after?: boolean
1599 |     }
1600 |     export?: {
1601 |       before?: boolean
1602 |       after?: boolean
1603 |     }
1604 |     extends?: {
1605 |       before?: boolean
1606 |       after?: boolean
1607 |     }
1608 |     false?: {
1609 |       before?: boolean
1610 |       after?: boolean
1611 |     }
1612 |     final?: {
1613 |       before?: boolean
1614 |       after?: boolean
1615 |     }
1616 |     finally?: {
1617 |       before?: boolean
1618 |       after?: boolean
1619 |     }
1620 |     float?: {
1621 |       before?: boolean
1622 |       after?: boolean
1623 |     }
1624 |     for?: {
1625 |       before?: boolean
1626 |       after?: boolean
1627 |     }
1628 |     function?: {
1629 |       before?: boolean
1630 |       after?: boolean
1631 |     }
1632 |     goto?: {
1633 |       before?: boolean
1634 |       after?: boolean
1635 |     }
1636 |     if?: {
1637 |       before?: boolean
1638 |       after?: boolean
1639 |     }
1640 |     implements?: {
1641 |       before?: boolean
1642 |       after?: boolean
1643 |     }
1644 |     import?: {
1645 |       before?: boolean
1646 |       after?: boolean
1647 |     }
1648 |     in?: {
1649 |       before?: boolean
1650 |       after?: boolean
1651 |     }
1652 |     instanceof?: {
1653 |       before?: boolean
1654 |       after?: boolean
1655 |     }
1656 |     int?: {
1657 |       before?: boolean
1658 |       after?: boolean
1659 |     }
1660 |     interface?: {
1661 |       before?: boolean
1662 |       after?: boolean
1663 |     }
1664 |     long?: {
1665 |       before?: boolean
1666 |       after?: boolean
1667 |     }
1668 |     native?: {
1669 |       before?: boolean
1670 |       after?: boolean
1671 |     }
1672 |     new?: {
1673 |       before?: boolean
1674 |       after?: boolean
1675 |     }
1676 |     null?: {
1677 |       before?: boolean
1678 |       after?: boolean
1679 |     }
1680 |     package?: {
1681 |       before?: boolean
1682 |       after?: boolean
1683 |     }
1684 |     private?: {
1685 |       before?: boolean
1686 |       after?: boolean
1687 |     }
1688 |     protected?: {
1689 |       before?: boolean
1690 |       after?: boolean
1691 |     }
1692 |     public?: {
1693 |       before?: boolean
1694 |       after?: boolean
1695 |     }
1696 |     return?: {
1697 |       before?: boolean
1698 |       after?: boolean
1699 |     }
1700 |     short?: {
1701 |       before?: boolean
1702 |       after?: boolean
1703 |     }
1704 |     static?: {
1705 |       before?: boolean
1706 |       after?: boolean
1707 |     }
1708 |     super?: {
1709 |       before?: boolean
1710 |       after?: boolean
1711 |     }
1712 |     switch?: {
1713 |       before?: boolean
1714 |       after?: boolean
1715 |     }
1716 |     synchronized?: {
1717 |       before?: boolean
1718 |       after?: boolean
1719 |     }
1720 |     this?: {
1721 |       before?: boolean
1722 |       after?: boolean
1723 |     }
1724 |     throw?: {
1725 |       before?: boolean
1726 |       after?: boolean
1727 |     }
1728 |     throws?: {
1729 |       before?: boolean
1730 |       after?: boolean
1731 |     }
1732 |     transient?: {
1733 |       before?: boolean
1734 |       after?: boolean
1735 |     }
1736 |     true?: {
1737 |       before?: boolean
1738 |       after?: boolean
1739 |     }
1740 |     try?: {
1741 |       before?: boolean
1742 |       after?: boolean
1743 |     }
1744 |     typeof?: {
1745 |       before?: boolean
1746 |       after?: boolean
1747 |     }
1748 |     var?: {
1749 |       before?: boolean
1750 |       after?: boolean
1751 |     }
1752 |     void?: {
1753 |       before?: boolean
1754 |       after?: boolean
1755 |     }
1756 |     volatile?: {
1757 |       before?: boolean
1758 |       after?: boolean
1759 |     }
1760 |     while?: {
1761 |       before?: boolean
1762 |       after?: boolean
1763 |     }
1764 |     with?: {
1765 |       before?: boolean
1766 |       after?: boolean
1767 |     }
1768 |     accessor?: {
1769 |       before?: boolean
1770 |       after?: boolean
1771 |     }
1772 |     as?: {
1773 |       before?: boolean
1774 |       after?: boolean
1775 |     }
1776 |     async?: {
1777 |       before?: boolean
1778 |       after?: boolean
1779 |     }
1780 |     await?: {
1781 |       before?: boolean
1782 |       after?: boolean
1783 |     }
1784 |     from?: {
1785 |       before?: boolean
1786 |       after?: boolean
1787 |     }
1788 |     get?: {
1789 |       before?: boolean
1790 |       after?: boolean
1791 |     }
1792 |     let?: {
1793 |       before?: boolean
1794 |       after?: boolean
1795 |     }
1796 |     of?: {
1797 |       before?: boolean
1798 |       after?: boolean
1799 |     }
1800 |     satisfies?: {
1801 |       before?: boolean
1802 |       after?: boolean
1803 |     }
1804 |     set?: {
1805 |       before?: boolean
1806 |       after?: boolean
1807 |     }
1808 |     using?: {
1809 |       before?: boolean
1810 |       after?: boolean
1811 |     }
1812 |     yield?: {
1813 |       before?: boolean
1814 |       after?: boolean
1815 |     }
1816 |     type?: {
1817 |       before?: boolean
1818 |       after?: boolean
1819 |     }
1820 |   }
1821 | }]
1822 | // ----- vue/match-component-file-name -----
1823 | type VueMatchComponentFileName = []|[{
1824 |   extensions?: string[]
1825 |   shouldMatchCase?: boolean
1826 | }]
1827 | // ----- vue/max-attributes-per-line -----
1828 | type VueMaxAttributesPerLine = []|[{
1829 |   singleline?: (number | {
1830 |     max?: number
1831 |   })
1832 |   multiline?: (number | {
1833 |     max?: number
1834 |   })
1835 | }]
1836 | // ----- vue/max-len -----
1837 | type VueMaxLen = []|[({
1838 |   code?: number
1839 |   template?: number
1840 |   comments?: number
1841 |   tabWidth?: number
1842 |   ignorePattern?: string
1843 |   ignoreComments?: boolean
1844 |   ignoreTrailingComments?: boolean
1845 |   ignoreUrls?: boolean
1846 |   ignoreStrings?: boolean
1847 |   ignoreTemplateLiterals?: boolean
1848 |   ignoreRegExpLiterals?: boolean
1849 |   ignoreHTMLAttributeValues?: boolean
1850 |   ignoreHTMLTextContents?: boolean
1851 | } | number)]|[({
1852 |   code?: number
1853 |   template?: number
1854 |   comments?: number
1855 |   tabWidth?: number
1856 |   ignorePattern?: string
1857 |   ignoreComments?: boolean
1858 |   ignoreTrailingComments?: boolean
1859 |   ignoreUrls?: boolean
1860 |   ignoreStrings?: boolean
1861 |   ignoreTemplateLiterals?: boolean
1862 |   ignoreRegExpLiterals?: boolean
1863 |   ignoreHTMLAttributeValues?: boolean
1864 |   ignoreHTMLTextContents?: boolean
1865 | } | number), ({
1866 |   code?: number
1867 |   template?: number
1868 |   comments?: number
1869 |   tabWidth?: number
1870 |   ignorePattern?: string
1871 |   ignoreComments?: boolean
1872 |   ignoreTrailingComments?: boolean
1873 |   ignoreUrls?: boolean
1874 |   ignoreStrings?: boolean
1875 |   ignoreTemplateLiterals?: boolean
1876 |   ignoreRegExpLiterals?: boolean
1877 |   ignoreHTMLAttributeValues?: boolean
1878 |   ignoreHTMLTextContents?: boolean
1879 | } | number)]|[({
1880 |   code?: number
1881 |   template?: number
1882 |   comments?: number
1883 |   tabWidth?: number
1884 |   ignorePattern?: string
1885 |   ignoreComments?: boolean
1886 |   ignoreTrailingComments?: boolean
1887 |   ignoreUrls?: boolean
1888 |   ignoreStrings?: boolean
1889 |   ignoreTemplateLiterals?: boolean
1890 |   ignoreRegExpLiterals?: boolean
1891 |   ignoreHTMLAttributeValues?: boolean
1892 |   ignoreHTMLTextContents?: boolean
1893 | } | number), ({
1894 |   code?: number
1895 |   template?: number
1896 |   comments?: number
1897 |   tabWidth?: number
1898 |   ignorePattern?: string
1899 |   ignoreComments?: boolean
1900 |   ignoreTrailingComments?: boolean
1901 |   ignoreUrls?: boolean
1902 |   ignoreStrings?: boolean
1903 |   ignoreTemplateLiterals?: boolean
1904 |   ignoreRegExpLiterals?: boolean
1905 |   ignoreHTMLAttributeValues?: boolean
1906 |   ignoreHTMLTextContents?: boolean
1907 | } | number), {
1908 |   code?: number
1909 |   template?: number
1910 |   comments?: number
1911 |   tabWidth?: number
1912 |   ignorePattern?: string
1913 |   ignoreComments?: boolean
1914 |   ignoreTrailingComments?: boolean
1915 |   ignoreUrls?: boolean
1916 |   ignoreStrings?: boolean
1917 |   ignoreTemplateLiterals?: boolean
1918 |   ignoreRegExpLiterals?: boolean
1919 |   ignoreHTMLAttributeValues?: boolean
1920 |   ignoreHTMLTextContents?: boolean
1921 | }]
1922 | // ----- vue/max-lines-per-block -----
1923 | type VueMaxLinesPerBlock = []|[{
1924 |   style?: number
1925 |   template?: number
1926 |   script?: number
1927 |   skipBlankLines?: boolean
1928 | }]
1929 | // ----- vue/max-props -----
1930 | type VueMaxProps = []|[{
1931 |   maxProps?: number
1932 | }]
1933 | // ----- vue/max-template-depth -----
1934 | type VueMaxTemplateDepth = []|[{
1935 |   maxDepth?: number
1936 | }]
1937 | // ----- vue/multi-word-component-names -----
1938 | type VueMultiWordComponentNames = []|[{
1939 |   ignores?: string[]
1940 | }]
1941 | // ----- vue/multiline-html-element-content-newline -----
1942 | type VueMultilineHtmlElementContentNewline = []|[{
1943 |   ignoreWhenEmpty?: boolean
1944 |   ignores?: string[]
1945 |   allowEmptyLines?: boolean
1946 | }]
1947 | // ----- vue/multiline-ternary -----
1948 | type VueMultilineTernary = []|[("always" | "always-multiline" | "never")]|[("always" | "always-multiline" | "never"), {
1949 |   ignoreJSX?: boolean
1950 | }]
1951 | // ----- vue/mustache-interpolation-spacing -----
1952 | type VueMustacheInterpolationSpacing = []|[("always" | "never")]
1953 | // ----- vue/new-line-between-multi-line-property -----
1954 | type VueNewLineBetweenMultiLineProperty = []|[{
1955 |   minLineOfMultilineProperty?: number
1956 | }]
1957 | // ----- vue/next-tick-style -----
1958 | type VueNextTickStyle = []|[("promise" | "callback")]
1959 | // ----- vue/no-bare-strings-in-template -----
1960 | type VueNoBareStringsInTemplate = []|[{
1961 |   allowlist?: string[]
1962 |   attributes?: {
1963 |     [k: string]: string[]
1964 |   }
1965 |   directives?: string[]
1966 | }]
1967 | // ----- vue/no-boolean-default -----
1968 | type VueNoBooleanDefault = []|[("default-false" | "no-default")]
1969 | // ----- vue/no-child-content -----
1970 | type VueNoChildContent = []|[{
1971 |   
1972 |   additionalDirectives: [string, ...(string)[]]
1973 | }]
1974 | // ----- vue/no-console -----
1975 | type VueNoConsole = []|[{
1976 |   
1977 |   allow?: [string, ...(string)[]]
1978 | }]
1979 | // ----- vue/no-constant-condition -----
1980 | type VueNoConstantCondition = []|[{
1981 |   checkLoops?: ("all" | "allExceptWhileTrue" | "none" | true | false)
1982 | }]
1983 | // ----- vue/no-deprecated-model-definition -----
1984 | type VueNoDeprecatedModelDefinition = []|[{
1985 |   allowVue3Compat?: boolean
1986 | }]
1987 | // ----- vue/no-deprecated-router-link-tag-prop -----
1988 | type VueNoDeprecatedRouterLinkTagProp = []|[{
1989 |   
1990 |   components?: [string, ...(string)[]]
1991 | }]
1992 | // ----- vue/no-deprecated-slot-attribute -----
1993 | type VueNoDeprecatedSlotAttribute = []|[{
1994 |   ignore?: string[]
1995 | }]
1996 | // ----- vue/no-dupe-keys -----
1997 | type VueNoDupeKeys = []|[{
1998 |   groups?: unknown[]
1999 | }]
2000 | // ----- vue/no-duplicate-attr-inheritance -----
2001 | type VueNoDuplicateAttrInheritance = []|[{
2002 |   checkMultiRootNodes?: boolean
2003 | }]
2004 | // ----- vue/no-duplicate-attributes -----
2005 | type VueNoDuplicateAttributes = []|[{
2006 |   allowCoexistClass?: boolean
2007 |   allowCoexistStyle?: boolean
2008 | }]
2009 | // ----- vue/no-empty-pattern -----
2010 | type VueNoEmptyPattern = []|[{
2011 |   allowObjectPatternsAsParameters?: boolean
2012 | }]
2013 | // ----- vue/no-extra-parens -----
2014 | type VueNoExtraParens = ([]|["functions"] | []|["all"]|["all", {
2015 |   conditionalAssign?: boolean
2016 |   ternaryOperandBinaryExpressions?: boolean
2017 |   nestedBinaryExpressions?: boolean
2018 |   returnAssign?: boolean
2019 |   ignoreJSX?: ("none" | "all" | "single-line" | "multi-line")
2020 |   enforceForArrowConditionals?: boolean
2021 |   enforceForSequenceExpressions?: boolean
2022 |   enforceForNewInMemberExpressions?: boolean
2023 |   enforceForFunctionPrototypeMethods?: boolean
2024 |   allowParensAfterCommentPattern?: string
2025 |   nestedConditionalExpressions?: boolean
2026 |   allowNodesInSpreadElement?: {
2027 |     ConditionalExpression?: boolean
2028 |     LogicalExpression?: boolean
2029 |     AwaitExpression?: boolean
2030 |   }
2031 | }])
2032 | // ----- vue/no-implicit-coercion -----
2033 | type VueNoImplicitCoercion = []|[{
2034 |   boolean?: boolean
2035 |   number?: boolean
2036 |   string?: boolean
2037 |   disallowTemplateShorthand?: boolean
2038 |   allow?: ("~" | "!!" | "+" | "- -" | "-" | "*")[]
2039 | }]
2040 | // ----- vue/no-irregular-whitespace -----
2041 | type VueNoIrregularWhitespace = []|[{
2042 |   skipComments?: boolean
2043 |   skipStrings?: boolean
2044 |   skipTemplates?: boolean
2045 |   skipRegExps?: boolean
2046 |   skipHTMLAttributeValues?: boolean
2047 |   skipHTMLTextContents?: boolean
2048 | }]
2049 | // ----- vue/no-lone-template -----
2050 | type VueNoLoneTemplate = []|[{
2051 |   ignoreAccessible?: boolean
2052 | }]
2053 | // ----- vue/no-multi-spaces -----
2054 | type VueNoMultiSpaces = []|[{
2055 |   ignoreProperties?: boolean
2056 | }]
2057 | // ----- vue/no-multiple-template-root -----
2058 | type VueNoMultipleTemplateRoot = []|[{
2059 |   disallowComments?: boolean
2060 | }]
2061 | // ----- vue/no-mutating-props -----
2062 | type VueNoMutatingProps = []|[{
2063 |   shallowOnly?: boolean
2064 | }]
2065 | // ----- vue/no-parsing-error -----
2066 | type VueNoParsingError = []|[{
2067 |   "abrupt-closing-of-empty-comment"?: boolean
2068 |   "absence-of-digits-in-numeric-character-reference"?: boolean
2069 |   "cdata-in-html-content"?: boolean
2070 |   "character-reference-outside-unicode-range"?: boolean
2071 |   "control-character-in-input-stream"?: boolean
2072 |   "control-character-reference"?: boolean
2073 |   "eof-before-tag-name"?: boolean
2074 |   "eof-in-cdata"?: boolean
2075 |   "eof-in-comment"?: boolean
2076 |   "eof-in-tag"?: boolean
2077 |   "incorrectly-closed-comment"?: boolean
2078 |   "incorrectly-opened-comment"?: boolean
2079 |   "invalid-first-character-of-tag-name"?: boolean
2080 |   "missing-attribute-value"?: boolean
2081 |   "missing-end-tag-name"?: boolean
2082 |   "missing-semicolon-after-character-reference"?: boolean
2083 |   "missing-whitespace-between-attributes"?: boolean
2084 |   "nested-comment"?: boolean
2085 |   "noncharacter-character-reference"?: boolean
2086 |   "noncharacter-in-input-stream"?: boolean
2087 |   "null-character-reference"?: boolean
2088 |   "surrogate-character-reference"?: boolean
2089 |   "surrogate-in-input-stream"?: boolean
2090 |   "unexpected-character-in-attribute-name"?: boolean
2091 |   "unexpected-character-in-unquoted-attribute-value"?: boolean
2092 |   "unexpected-equals-sign-before-attribute-name"?: boolean
2093 |   "unexpected-null-character"?: boolean
2094 |   "unexpected-question-mark-instead-of-tag-name"?: boolean
2095 |   "unexpected-solidus-in-tag"?: boolean
2096 |   "unknown-named-character-reference"?: boolean
2097 |   "end-tag-with-attributes"?: boolean
2098 |   "duplicate-attribute"?: boolean
2099 |   "end-tag-with-trailing-solidus"?: boolean
2100 |   "non-void-html-element-start-tag-with-trailing-solidus"?: boolean
2101 |   "x-invalid-end-tag"?: boolean
2102 |   "x-invalid-namespace"?: boolean
2103 | }]
2104 | // ----- vue/no-potential-component-option-typo -----
2105 | type VueNoPotentialComponentOptionTypo = []|[{
2106 |   
2107 |   presets?: ("all" | "vue" | "vue-router" | "nuxt")[]
2108 |   
2109 |   custom?: string[]
2110 |   threshold?: number
2111 | }]
2112 | // ----- vue/no-required-prop-with-default -----
2113 | type VueNoRequiredPropWithDefault = []|[{
2114 |   autofix?: boolean
2115 | }]
2116 | // ----- vue/no-reserved-component-names -----
2117 | type VueNoReservedComponentNames = []|[{
2118 |   disallowVueBuiltInComponents?: boolean
2119 |   disallowVue3BuiltInComponents?: boolean
2120 |   htmlElementCaseSensitive?: boolean
2121 | }]
2122 | // ----- vue/no-reserved-keys -----
2123 | type VueNoReservedKeys = []|[{
2124 |   reserved?: unknown[]
2125 |   groups?: unknown[]
2126 | }]
2127 | // ----- vue/no-reserved-props -----
2128 | type VueNoReservedProps = []|[{
2129 |   vueVersion?: (2 | 3)
2130 | }]
2131 | // ----- vue/no-restricted-block -----
2132 | type VueNoRestrictedBlock = (string | {
2133 |   element: string
2134 |   message?: string
2135 | })[]
2136 | // ----- vue/no-restricted-call-after-await -----
2137 | type VueNoRestrictedCallAfterAwait = {
2138 |   module: string
2139 |   path?: (string | string[])
2140 |   message?: string
2141 | }[]
2142 | // ----- vue/no-restricted-class -----
2143 | type VueNoRestrictedClass = string[]
2144 | // ----- vue/no-restricted-component-names -----
2145 | type VueNoRestrictedComponentNames = (string | {
2146 |   name: string
2147 |   message?: string
2148 |   suggest?: string
2149 | })[]
2150 | // ----- vue/no-restricted-component-options -----
2151 | type VueNoRestrictedComponentOptions = (string | string[] | {
2152 |   name: (string | string[])
2153 |   message?: string
2154 | })[]
2155 | // ----- vue/no-restricted-custom-event -----
2156 | type VueNoRestrictedCustomEvent = (string | {
2157 |   event: string
2158 |   message?: string
2159 |   suggest?: string
2160 | })[]
2161 | // ----- vue/no-restricted-html-elements -----
2162 | type VueNoRestrictedHtmlElements = (string | {
2163 |   element: (string | string[])
2164 |   message?: string
2165 | })[]
2166 | // ----- vue/no-restricted-props -----
2167 | type VueNoRestrictedProps = (string | {
2168 |   name: string
2169 |   message?: string
2170 |   suggest?: string
2171 | })[]
2172 | // ----- vue/no-restricted-static-attribute -----
2173 | type VueNoRestrictedStaticAttribute = (string | {
2174 |   key: string
2175 |   value?: (string | true)
2176 |   element?: string
2177 |   message?: string
2178 | })[]
2179 | // ----- vue/no-restricted-syntax -----
2180 | type VueNoRestrictedSyntax = (string | {
2181 |   selector: string
2182 |   message?: string
2183 | })[]
2184 | // ----- vue/no-restricted-v-bind -----
2185 | type VueNoRestrictedVBind = ((string | null) | {
2186 |   argument: (string | null)
2187 |   modifiers?: ("prop" | "camel" | "sync" | "attr")[]
2188 |   element?: string
2189 |   message?: string
2190 | })[]
2191 | // ----- vue/no-restricted-v-on -----
2192 | type VueNoRestrictedVOn = ((string | null) | {
2193 |   argument: (string | null)
2194 |   element?: string
2195 |   message?: string
2196 |   
2197 |   modifiers?: [("prevent" | "stop" | "capture" | "self" | "once" | "passive"), ...(("prevent" | "stop" | "capture" | "self" | "once" | "passive"))[]]
2198 | })[]
2199 | // ----- vue/no-static-inline-styles -----
2200 | type VueNoStaticInlineStyles = []|[{
2201 |   allowBinding?: boolean
2202 | }]
2203 | // ----- vue/no-template-shadow -----
2204 | type VueNoTemplateShadow = []|[{
2205 |   allow?: string[]
2206 | }]
2207 | // ----- vue/no-template-target-blank -----
2208 | type VueNoTemplateTargetBlank = []|[{
2209 |   allowReferrer?: boolean
2210 |   enforceDynamicLinks?: ("always" | "never")
2211 | }]
2212 | // ----- vue/no-undef-components -----
2213 | type VueNoUndefComponents = []|[{
2214 |   ignorePatterns?: unknown[]
2215 | }]
2216 | // ----- vue/no-undef-properties -----
2217 | type VueNoUndefProperties = []|[{
2218 |   ignores?: string[]
2219 | }]
2220 | // ----- vue/no-unsupported-features -----
2221 | type VueNoUnsupportedFeatures = []|[{
2222 |   version?: string
2223 |   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")[]
2224 | }]
2225 | // ----- vue/no-unused-components -----
2226 | type VueNoUnusedComponents = []|[{
2227 |   ignoreWhenBindingPresent?: boolean
2228 | }]
2229 | // ----- vue/no-unused-properties -----
2230 | type VueNoUnusedProperties = []|[{
2231 |   groups?: ("props" | "data" | "asyncData" | "computed" | "methods" | "setup")[]
2232 |   deepData?: boolean
2233 |   ignorePublicMembers?: boolean
2234 |   unreferencedOptions?: ("unknownMemberAsUnreferenced" | "returnAsUnreferenced")[]
2235 | }]
2236 | // ----- vue/no-unused-vars -----
2237 | type VueNoUnusedVars = []|[{
2238 |   ignorePattern?: string
2239 | }]
2240 | // ----- vue/no-use-v-if-with-v-for -----
2241 | type VueNoUseVIfWithVFor = []|[{
2242 |   allowUsingIterationVar?: boolean
2243 | }]
2244 | // ----- vue/no-useless-mustaches -----
2245 | type VueNoUselessMustaches = []|[{
2246 |   ignoreIncludesComment?: boolean
2247 |   ignoreStringEscape?: boolean
2248 | }]
2249 | // ----- vue/no-useless-v-bind -----
2250 | type VueNoUselessVBind = []|[{
2251 |   ignoreIncludesComment?: boolean
2252 |   ignoreStringEscape?: boolean
2253 | }]
2254 | // ----- vue/no-v-text-v-html-on-component -----
2255 | type VueNoVTextVHtmlOnComponent = []|[{
2256 |   allow?: string[]
2257 |   ignoreElementNamespaces?: boolean
2258 | }]
2259 | // ----- vue/object-curly-newline -----
2260 | type VueObjectCurlyNewline = []|[((("always" | "never") | {
2261 |   multiline?: boolean
2262 |   minProperties?: number
2263 |   consistent?: boolean
2264 | }) | {
2265 |   ObjectExpression?: (("always" | "never") | {
2266 |     multiline?: boolean
2267 |     minProperties?: number
2268 |     consistent?: boolean
2269 |   })
2270 |   ObjectPattern?: (("always" | "never") | {
2271 |     multiline?: boolean
2272 |     minProperties?: number
2273 |     consistent?: boolean
2274 |   })
2275 |   ImportDeclaration?: (("always" | "never") | {
2276 |     multiline?: boolean
2277 |     minProperties?: number
2278 |     consistent?: boolean
2279 |   })
2280 |   ExportDeclaration?: (("always" | "never") | {
2281 |     multiline?: boolean
2282 |     minProperties?: number
2283 |     consistent?: boolean
2284 |   })
2285 |   TSTypeLiteral?: (("always" | "never") | {
2286 |     multiline?: boolean
2287 |     minProperties?: number
2288 |     consistent?: boolean
2289 |   })
2290 |   TSInterfaceBody?: (("always" | "never") | {
2291 |     multiline?: boolean
2292 |     minProperties?: number
2293 |     consistent?: boolean
2294 |   })
2295 |   TSEnumBody?: (("always" | "never") | {
2296 |     multiline?: boolean
2297 |     minProperties?: number
2298 |     consistent?: boolean
2299 |   })
2300 | })]
2301 | // ----- vue/object-curly-spacing -----
2302 | type VueObjectCurlySpacing = []|[("always" | "never")]|[("always" | "never"), {
2303 |   arraysInObjects?: boolean
2304 |   objectsInObjects?: boolean
2305 | }]
2306 | // ----- vue/object-property-newline -----
2307 | type VueObjectPropertyNewline = []|[{
2308 |   allowAllPropertiesOnSameLine?: boolean
2309 | }]
2310 | // ----- vue/object-shorthand -----
2311 | type VueObjectShorthand = ([]|[("always" | "methods" | "properties" | "never" | "consistent" | "consistent-as-needed")] | []|[("always" | "methods" | "properties")]|[("always" | "methods" | "properties"), {
2312 |   avoidQuotes?: boolean
2313 | }] | []|[("always" | "methods")]|[("always" | "methods"), {
2314 |   ignoreConstructors?: boolean
2315 |   methodsIgnorePattern?: string
2316 |   avoidQuotes?: boolean
2317 |   avoidExplicitReturnArrows?: boolean
2318 | }])
2319 | // ----- vue/operator-linebreak -----
2320 | type VueOperatorLinebreak = []|[(("after" | "before" | "none") | null)]|[(("after" | "before" | "none") | null), {
2321 |   overrides?: {
2322 |     [k: string]: ("after" | "before" | "none" | "ignore") | undefined
2323 |   }
2324 | }]
2325 | // ----- vue/order-in-components -----
2326 | type VueOrderInComponents = []|[{
2327 |   order?: unknown[]
2328 | }]
2329 | // ----- vue/padding-line-between-blocks -----
2330 | type VuePaddingLineBetweenBlocks = []|[("never" | "always")]
2331 | // ----- vue/padding-line-between-tags -----
2332 | type VuePaddingLineBetweenTags = []|[{
2333 |   blankLine: ("always" | "never" | "consistent")
2334 |   prev: string
2335 |   next: string
2336 | }[]]
2337 | // ----- vue/padding-lines-in-component-definition -----
2338 | type VuePaddingLinesInComponentDefinition = []|[(("always" | "never") | {
2339 |   betweenOptions?: ("never" | "always" | "ignore")
2340 |   withinOption?: (("never" | "always" | "ignore") | {
2341 |     [k: string]: (("never" | "always" | "ignore") | {
2342 |       betweenItems?: ("never" | "always" | "ignore")
2343 |       withinEach?: ("never" | "always" | "ignore")
2344 |     })
2345 |   })
2346 |   groupSingleLineProperties?: boolean
2347 | })]
2348 | // ----- vue/prefer-true-attribute-shorthand -----
2349 | type VuePreferTrueAttributeShorthand = []|[("always" | "never")]|[("always" | "never"), {
2350 |   except?: string[]
2351 | }]
2352 | // ----- vue/prop-name-casing -----
2353 | type VuePropNameCasing = []|[("camelCase" | "snake_case")]|[("camelCase" | "snake_case"), {
2354 |   ignoreProps?: string[]
2355 | }]
2356 | // ----- vue/quote-props -----
2357 | type VueQuoteProps = ([]|[("always" | "as-needed" | "consistent" | "consistent-as-needed")] | []|[("always" | "as-needed" | "consistent" | "consistent-as-needed")]|[("always" | "as-needed" | "consistent" | "consistent-as-needed"), {
2358 |   keywords?: boolean
2359 |   unnecessary?: boolean
2360 |   numbers?: boolean
2361 | }])
2362 | // ----- vue/require-direct-export -----
2363 | type VueRequireDirectExport = []|[{
2364 |   disallowFunctionalComponentFunction?: boolean
2365 | }]
2366 | // ----- vue/require-explicit-emits -----
2367 | type VueRequireExplicitEmits = []|[{
2368 |   allowProps?: boolean
2369 | }]
2370 | // ----- vue/require-macro-variable-name -----
2371 | type VueRequireMacroVariableName = []|[{
2372 |   defineProps?: string
2373 |   defineEmits?: string
2374 |   defineSlots?: string
2375 |   useSlots?: string
2376 |   useAttrs?: string
2377 | }]
2378 | // ----- vue/require-prop-comment -----
2379 | type VueRequirePropComment = []|[{
2380 |   type?: ("JSDoc" | "line" | "block" | "any")
2381 | }]
2382 | // ----- vue/require-toggle-inside-transition -----
2383 | type VueRequireToggleInsideTransition = []|[{
2384 |   additionalDirectives?: string[]
2385 | }]
2386 | // ----- vue/restricted-component-names -----
2387 | type VueRestrictedComponentNames = []|[{
2388 |   allow?: string[]
2389 | }]
2390 | // ----- vue/return-in-computed-property -----
2391 | type VueReturnInComputedProperty = []|[{
2392 |   treatUndefinedAsUnspecified?: boolean
2393 | }]
2394 | // ----- vue/script-indent -----
2395 | type VueScriptIndent = []|[(number | "tab")]|[(number | "tab"), {
2396 |   baseIndent?: number
2397 |   switchCase?: number
2398 |   ignores?: (string & {
2399 |     [k: string]: unknown | undefined
2400 |   } & {
2401 |     [k: string]: unknown | undefined
2402 |   })[]
2403 | }]
2404 | // ----- vue/singleline-html-element-content-newline -----
2405 | type VueSinglelineHtmlElementContentNewline = []|[{
2406 |   ignoreWhenNoAttributes?: boolean
2407 |   ignoreWhenEmpty?: boolean
2408 |   ignores?: string[]
2409 |   externalIgnores?: string[]
2410 | }]
2411 | // ----- vue/slot-name-casing -----
2412 | type VueSlotNameCasing = []|[("camelCase" | "kebab-case" | "singleword")]
2413 | // ----- vue/sort-keys -----
2414 | type VueSortKeys = []|[("asc" | "desc")]|[("asc" | "desc"), {
2415 |   caseSensitive?: boolean
2416 |   ignoreChildrenOf?: unknown[]
2417 |   ignoreGrandchildrenOf?: unknown[]
2418 |   minKeys?: number
2419 |   natural?: boolean
2420 | }]
2421 | // ----- vue/space-in-parens -----
2422 | type VueSpaceInParens = []|[("always" | "never")]|[("always" | "never"), {
2423 |   exceptions?: ("{}" | "[]" | "()" | "empty")[]
2424 | }]
2425 | // ----- vue/space-infix-ops -----
2426 | type VueSpaceInfixOps = []|[{
2427 |   int32Hint?: boolean
2428 |   ignoreTypes?: boolean
2429 | }]
2430 | // ----- vue/space-unary-ops -----
2431 | type VueSpaceUnaryOps = []|[{
2432 |   words?: boolean
2433 |   nonwords?: boolean
2434 |   overrides?: {
2435 |     [k: string]: boolean | undefined
2436 |   }
2437 | }]
2438 | // ----- vue/template-curly-spacing -----
2439 | type VueTemplateCurlySpacing = []|[("always" | "never")]
2440 | // ----- vue/this-in-template -----
2441 | type VueThisInTemplate = []|[("always" | "never")]
2442 | // ----- vue/v-bind-style -----
2443 | type VueVBindStyle = []|[("shorthand" | "longform")]|[("shorthand" | "longform"), {
2444 |   sameNameShorthand?: ("always" | "never" | "ignore")
2445 | }]
2446 | // ----- vue/v-for-delimiter-style -----
2447 | type VueVForDelimiterStyle = []|[("in" | "of")]
2448 | // ----- vue/v-on-event-hyphenation -----
2449 | type VueVOnEventHyphenation = []|[("always" | "never")]|[("always" | "never"), {
2450 |   autofix?: boolean
2451 |   ignore?: (string & {
2452 |     [k: string]: unknown | undefined
2453 |   } & {
2454 |     [k: string]: unknown | undefined
2455 |   })[]
2456 |   ignoreTags?: string[]
2457 | }]
2458 | // ----- vue/v-on-handler-style -----
2459 | type VueVOnHandlerStyle = []|[(("inline" | "inline-function") | ["method", ("inline" | "inline-function")])]|[(("inline" | "inline-function") | ["method", ("inline" | "inline-function")]), {
2460 |   ignoreIncludesComment?: boolean
2461 | }]
2462 | // ----- vue/v-on-style -----
2463 | type VueVOnStyle = []|[("shorthand" | "longform")]
2464 | // ----- vue/v-slot-style -----
2465 | type VueVSlotStyle = []|[(("shorthand" | "longform") | {
2466 |   atComponent?: ("shorthand" | "longform" | "v-slot")
2467 |   default?: ("shorthand" | "longform" | "v-slot")
2468 |   named?: ("shorthand" | "longform")
2469 | })]
2470 | // ----- vue/valid-v-on -----
2471 | type VueValidVOn = []|[{
2472 |   modifiers?: unknown[]
2473 | }]
2474 | // ----- vue/valid-v-slot -----
2475 | type VueValidVSlot = []|[{
2476 |   allowModifiers?: boolean
2477 | }]


--------------------------------------------------------------------------------