diff --git a/.eslintrc.js b/.eslintrc.js
index 7bc7d0960..f8f46d5fa 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -37,24 +37,6 @@ module.exports = {
     'dot-notation': 'error'
   },
   overrides: [
-    // Introduce prettier. but ignore files to avoid conflicts with PR.
-    {
-      files: [
-        // https://github.com/vuejs/eslint-plugin-vue/pull/819
-        'lib/rules/attributes-order.js',
-        'tests/lib/rules/attributes-order.js'
-      ],
-      extends: [
-        'plugin:eslint-plugin/recommended',
-        'plugin:vue-libs/recommended'
-      ],
-      rules: {
-        'prettier/prettier': 'off',
-
-        'rest-spread-spacing': 'error',
-        'no-mixed-operators': 'error'
-      }
-    },
     {
       files: ['lib/rules/*.js'],
       rules: {
diff --git a/.gitignore b/.gitignore
index 688618a31..e1401b951 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,4 @@
 yarn.lock
 yarn-error.log
 docs/.vuepress/dist
+typings/eslint/lib/rules
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 7bd96f8d9..841a29074 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -6,6 +6,7 @@
     "eslint.validate": [
         "javascript",
         "javascriptreact",
-        { "language": "vue", "autoFix": true }
-    ]
+        "vue"
+    ],
+    "typescript.tsdk": "node_modules/typescript/lib"
 }
diff --git a/docs/developer-guide/README.md b/docs/developer-guide/README.md
index bdc148105..658a4bf66 100644
--- a/docs/developer-guide/README.md
+++ b/docs/developer-guide/README.md
@@ -47,3 +47,10 @@ Check out an [example rule](https://github.com/vuejs/eslint-plugin-vue/blob/mast
 Please be aware that regarding what kind of code examples you'll write in tests, you'll have to accordingly setup the parser in `RuleTester` (you can do it on per test case basis though). [See an example here](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/attribute-hyphenation.js#L19)
 
 If you'll stuck, remember there are plenty of rules you can learn from already, and if you can't find the right solution - don't hesitate to reach out in issues. We're happy to help!
+
+## :white_check_mark: JSDoc type checking with TypeScript
+
+We have type checking enabled via TypeScript and JSDoc.  
+The command to perform type checking is: `npm run tsc`
+
+This is just to help you write the rules, not to do strict type checking. If you find it difficult to resolve type checking warnings, feel free to suppress warnings using the `// @ts-nocheck` and `// @ts-ignore` comment.
diff --git a/lib/processor.js b/lib/processor.js
index b018e0bb8..81ab94784 100644
--- a/lib/processor.js
+++ b/lib/processor.js
@@ -13,6 +13,7 @@
  */
 
 module.exports = {
+  /** @param {string} code */
   preprocess(code) {
     return [code]
   },
@@ -34,6 +35,7 @@ module.exports = {
         disableRuleKeys: new Map()
       }
     }
+    /** @type {string[]} */
     const usedDisableDirectiveKeys = []
     /** @type {Map<string,LintMessage>} */
     const unusedDisableDirectiveReports = new Map()
@@ -88,15 +90,15 @@ module.exports = {
         if (state.line.disableAllKeys.size) {
           disableDirectiveKeys.push(...state.line.disableAllKeys)
         }
-        if (state.block.disableRuleKeys.has(message.ruleId)) {
-          disableDirectiveKeys.push(
-            ...state.block.disableRuleKeys.get(message.ruleId)
-          )
-        }
-        if (state.line.disableRuleKeys.has(message.ruleId)) {
-          disableDirectiveKeys.push(
-            ...state.line.disableRuleKeys.get(message.ruleId)
-          )
+        if (message.ruleId) {
+          const block = state.block.disableRuleKeys.get(message.ruleId)
+          if (block) {
+            disableDirectiveKeys.push(...block)
+          }
+          const line = state.line.disableRuleKeys.get(message.ruleId)
+          if (line) {
+            disableDirectiveKeys.push(...line)
+          }
         }
 
         if (disableDirectiveKeys.length) {
@@ -153,8 +155,8 @@ function messageToKey(message) {
 
 /**
  * Compares the locations of two objects in a source file
- * @param {{line: number, column: number}} itemA The first object
- * @param {{line: number, column: number}} itemB The second object
+ * @param {Position} itemA The first object
+ * @param {Position} itemB The second object
  * @returns {number} A value less than 1 if itemA appears before itemB in the source file, greater than 1 if
  * itemA appears after itemB in the source file, or 0 if itemA and itemB have the same location.
  */
diff --git a/lib/rules/arrow-spacing.js b/lib/rules/arrow-spacing.js
index 6586e8389..3d626c614 100644
--- a/lib/rules/arrow-spacing.js
+++ b/lib/rules/arrow-spacing.js
@@ -5,5 +5,5 @@
 
 const { wrapCoreRule } = require('../utils')
 
-// eslint-disable-next-line
+// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
 module.exports = wrapCoreRule(require('eslint/lib/rules/arrow-spacing'))
diff --git a/lib/rules/attribute-hyphenation.js b/lib/rules/attribute-hyphenation.js
index ed5ab1904..1fd7b5e9b 100644
--- a/lib/rules/attribute-hyphenation.js
+++ b/lib/rules/attribute-hyphenation.js
@@ -45,7 +45,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
     const option = context.options[0]
@@ -61,6 +61,10 @@ module.exports = {
       useHyphenated ? 'kebab-case' : 'camelCase'
     )
 
+    /**
+     * @param {VDirective | VAttribute} node
+     * @param {string} name
+     */
     function reportIssue(node, name) {
       const text = sourceCode.getText(node.key)
 
@@ -78,6 +82,9 @@ module.exports = {
       })
     }
 
+    /**
+     * @param {string} value
+     */
     function isIgnoredAttribute(value) {
       const isIgnored = ignoredAttributes.some((attr) => {
         return value.indexOf(attr) !== -1
@@ -101,7 +108,9 @@ module.exports = {
         const name = !node.directive
           ? node.key.rawName
           : node.key.name.name === 'bind'
-          ? node.key.argument && node.key.argument.rawName
+          ? node.key.argument &&
+            node.key.argument.type === 'VIdentifier' &&
+            node.key.argument.rawName
           : /* otherwise */ false
         if (!name || isIgnoredAttribute(name)) return
 
diff --git a/lib/rules/attributes-order.js b/lib/rules/attributes-order.js
index 2f3d54f09..794628a5c 100644
--- a/lib/rules/attributes-order.js
+++ b/lib/rules/attributes-order.js
@@ -22,14 +22,29 @@ const ATTRS = {
   CONTENT: 'CONTENT'
 }
 
-function getAttributeName (attribute, sourceCode) {
-  const isBind = attribute.directive && attribute.key.name.name === 'bind'
-  return isBind
-    ? (attribute.key.argument ? sourceCode.getText(attribute.key.argument) : '')
-    : (attribute.directive ? getDirectiveKeyName(attribute.key, sourceCode) : attribute.key.name)
+/**
+ * @param {VAttribute | VDirective} attribute
+ * @param {SourceCode} sourceCode
+ */
+function getAttributeName(attribute, sourceCode) {
+  if (attribute.directive) {
+    if (attribute.key.name.name === 'bind') {
+      return attribute.key.argument
+        ? sourceCode.getText(attribute.key.argument)
+        : ''
+    } else {
+      return getDirectiveKeyName(attribute.key, sourceCode)
+    }
+  } else {
+    return attribute.key.name
+  }
 }
 
-function getDirectiveKeyName (directiveKey, sourceCode) {
+/**
+ * @param {VDirectiveKey} directiveKey
+ * @param {SourceCode} sourceCode
+ */
+function getDirectiveKeyName(directiveKey, sourceCode) {
   let text = `v-${directiveKey.name.name}`
   if (directiveKey.argument) {
     text += `:${sourceCode.getText(directiveKey.argument)}`
@@ -40,56 +55,92 @@ function getDirectiveKeyName (directiveKey, sourceCode) {
   return text
 }
 
-function getAttributeType (attribute, sourceCode) {
-  const isBind = attribute.directive && attribute.key.name.name === 'bind'
-  const name = isBind
-    ? (attribute.key.argument ? sourceCode.getText(attribute.key.argument) : '')
-    : (attribute.directive ? attribute.key.name.name : attribute.key.name)
-
-  if (attribute.directive && !isBind) {
-    if (name === 'for') {
-      return ATTRS.LIST_RENDERING
-    } else if (name === 'if' || name === 'else-if' || name === 'else' || name === 'show' || name === 'cloak') {
-      return ATTRS.CONDITIONALS
-    } else if (name === 'pre' || name === 'once') {
-      return ATTRS.RENDER_MODIFIERS
-    } else if (name === 'model') {
-      return ATTRS.TWO_WAY_BINDING
-    } else if (name === 'on') {
-      return ATTRS.EVENTS
-    } else if (name === 'html' || name === 'text') {
-      return ATTRS.CONTENT
-    } else if (name === 'slot') {
-      return ATTRS.UNIQUE
-    } else {
-      return ATTRS.OTHER_DIRECTIVES
+/**
+ * @param {VAttribute | VDirective} attribute
+ * @param {SourceCode} sourceCode
+ */
+function getAttributeType(attribute, sourceCode) {
+  let propName
+  if (attribute.directive) {
+    if (attribute.key.name.name !== 'bind') {
+      const name = attribute.key.name.name
+      if (name === 'for') {
+        return ATTRS.LIST_RENDERING
+      } else if (
+        name === 'if' ||
+        name === 'else-if' ||
+        name === 'else' ||
+        name === 'show' ||
+        name === 'cloak'
+      ) {
+        return ATTRS.CONDITIONALS
+      } else if (name === 'pre' || name === 'once') {
+        return ATTRS.RENDER_MODIFIERS
+      } else if (name === 'model') {
+        return ATTRS.TWO_WAY_BINDING
+      } else if (name === 'on') {
+        return ATTRS.EVENTS
+      } else if (name === 'html' || name === 'text') {
+        return ATTRS.CONTENT
+      } else if (name === 'slot') {
+        return ATTRS.UNIQUE
+      } else {
+        return ATTRS.OTHER_DIRECTIVES
+      }
     }
+    propName = attribute.key.argument
+      ? sourceCode.getText(attribute.key.argument)
+      : ''
   } else {
-    if (name === 'is') {
-      return ATTRS.DEFINITION
-    } else if (name === 'id') {
-      return ATTRS.GLOBAL
-    } else if (name === 'ref' || name === 'key' || name === 'slot' || name === 'slot-scope') {
-      return ATTRS.UNIQUE
-    } else {
-      return ATTRS.OTHER_ATTR
-    }
+    propName = attribute.key.name
+  }
+  if (propName === 'is') {
+    return ATTRS.DEFINITION
+  } else if (propName === 'id') {
+    return ATTRS.GLOBAL
+  } else if (
+    propName === 'ref' ||
+    propName === 'key' ||
+    propName === 'slot' ||
+    propName === 'slot-scope'
+  ) {
+    return ATTRS.UNIQUE
+  } else {
+    return ATTRS.OTHER_ATTR
   }
 }
 
-function getPosition (attribute, attributePosition, sourceCode) {
+/**
+ * @param {VAttribute | VDirective} attribute
+ * @param { { [key: string]: number } } attributePosition
+ * @param {SourceCode} sourceCode
+ */
+function getPosition(attribute, attributePosition, sourceCode) {
   const attributeType = getAttributeType(attribute, sourceCode)
-  return attributePosition.hasOwnProperty(attributeType) ? attributePosition[attributeType] : -1
+  return attributePosition.hasOwnProperty(attributeType)
+    ? attributePosition[attributeType]
+    : -1
 }
 
-function isAlphabetical (prevNode, currNode, sourceCode) {
-  const isSameType = getAttributeType(prevNode, sourceCode) === getAttributeType(currNode, sourceCode)
+/**
+ * @param {VAttribute | VDirective} prevNode
+ * @param {VAttribute | VDirective} currNode
+ * @param {SourceCode} sourceCode
+ */
+function isAlphabetical(prevNode, currNode, sourceCode) {
+  const isSameType =
+    getAttributeType(prevNode, sourceCode) ===
+    getAttributeType(currNode, sourceCode)
   if (isSameType) {
     const prevName = getAttributeName(prevNode, sourceCode)
     const currName = getAttributeName(currNode, sourceCode)
     if (prevName === currName) {
-      const prevIsBind = Boolean(prevNode.directive && prevNode.key.name.name === 'bind')
-      const currIsBind = Boolean(currNode.directive && currNode.key.name.name === 'bind')
+      const prevIsBind = Boolean(
+        prevNode.directive && prevNode.key.name.name === 'bind'
+      )
+      const currIsBind = Boolean(
+        currNode.directive && currNode.key.name.name === 'bind'
+      )
       return prevIsBind <= currIsBind
     }
     return prevName < currName
@@ -97,24 +148,57 @@ function isAlphabetical (prevNode, currNode, sourceCode) {
   return true
 }
 
-function create (context) {
+/**
+ * @param {RuleContext} context - The rule context.
+ * @returns {RuleListener} AST event handlers.
+ */
+function create(context) {
   const sourceCode = context.getSourceCode()
-  let attributeOrder = [ATTRS.DEFINITION, ATTRS.LIST_RENDERING, ATTRS.CONDITIONALS, ATTRS.RENDER_MODIFIERS, ATTRS.GLOBAL, ATTRS.UNIQUE, ATTRS.TWO_WAY_BINDING, ATTRS.OTHER_DIRECTIVES, ATTRS.OTHER_ATTR, ATTRS.EVENTS, ATTRS.CONTENT]
+  let attributeOrder = [
+    ATTRS.DEFINITION,
+    ATTRS.LIST_RENDERING,
+    ATTRS.CONDITIONALS,
+    ATTRS.RENDER_MODIFIERS,
+    ATTRS.GLOBAL,
+    ATTRS.UNIQUE,
+    ATTRS.TWO_WAY_BINDING,
+    ATTRS.OTHER_DIRECTIVES,
+    ATTRS.OTHER_ATTR,
+    ATTRS.EVENTS,
+    ATTRS.CONTENT
+  ]
   if (context.options[0] && context.options[0].order) {
     attributeOrder = context.options[0].order
   }
+  const alphabetical = Boolean(
+    context.options[0] && context.options[0].alphabetical
+  )
+
+  /** @type { { [key: string]: number } } */
   const attributePosition = {}
   attributeOrder.forEach((item, i) => {
-    if (item instanceof Array) {
+    if (Array.isArray(item)) {
       item.forEach((attr) => {
         attributePosition[attr] = i
       })
     } else attributePosition[item] = i
   })
-  let currentPosition
-  let previousNode
 
-  function reportIssue (node, previousNode) {
+  /**
+   * @typedef {object} State
+   * @property {number} currentPosition
+   * @property {VAttribute | VDirective} previousNode
+   */
+  /**
+   * @type {State | null}
+   */
+  let state
+
+  /**
+   * @param {VAttribute | VDirective} node
+   * @param {VAttribute | VDirective} previousNode
+   */
+  function reportIssue(node, previousNode) {
     const currentNode = sourceCode.getText(node.key)
     const prevNode = sourceCode.getText(previousNode.key)
     context.report({
@@ -125,12 +209,18 @@ function create (context) {
         currentNode
       },
 
-      fix (fixer) {
+      fix(fixer) {
         const attributes = node.parent.attributes
-        const shiftAttrs = attributes.slice(attributes.indexOf(previousNode), attributes.indexOf(node) + 1)
+        const shiftAttrs = attributes.slice(
+          attributes.indexOf(previousNode),
+          attributes.indexOf(node) + 1
+        )
 
         return shiftAttrs.map((attr, i) => {
-          const text = attr === previousNode ? sourceCode.getText(node) : sourceCode.getText(shiftAttrs[i - 1])
+          const text =
+            attr === previousNode
+              ? sourceCode.getText(node)
+              : sourceCode.getText(shiftAttrs[i - 1])
           return fixer.replaceText(attr, text)
         })
       }
@@ -138,20 +228,26 @@ function create (context) {
   }
 
   return utils.defineTemplateBodyVisitor(context, {
-    'VStartTag' () {
-      currentPosition = -1
-      previousNode = null
+    VStartTag() {
+      state = null
     },
-    'VAttribute' (node) {
+    VAttribute(node) {
       let inAlphaOrder = true
-      if (currentPosition !== -1 && (context.options[0] && context.options[0].alphabetical)) {
-        inAlphaOrder = isAlphabetical(previousNode, node, sourceCode)
+      if (state && alphabetical) {
+        inAlphaOrder = isAlphabetical(state.previousNode, node, sourceCode)
       }
-      if ((currentPosition === -1) || ((currentPosition <= getPosition(node, attributePosition, sourceCode)) && inAlphaOrder)) {
-        currentPosition = getPosition(node, attributePosition, sourceCode)
-        previousNode = node
+      if (
+        !state ||
+        (state.currentPosition <=
+          getPosition(node, attributePosition, sourceCode) &&
+          inAlphaOrder)
+      ) {
+        state = {
+          currentPosition: getPosition(node, attributePosition, sourceCode),
+          previousNode: node
+        }
       } else {
-        reportIssue(node, previousNode)
+        reportIssue(node, state.previousNode)
       }
     }
   })
diff --git a/lib/rules/camelcase.js b/lib/rules/camelcase.js
index c0ca04175..4aebfabab 100644
--- a/lib/rules/camelcase.js
+++ b/lib/rules/camelcase.js
@@ -5,5 +5,5 @@
 
 const { wrapCoreRule } = require('../utils')
 
-// eslint-disable-next-line
+// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
 module.exports = wrapCoreRule(require('eslint/lib/rules/camelcase'))
diff --git a/lib/rules/comma-dangle.js b/lib/rules/comma-dangle.js
index cfd0a4185..aa6c83c5e 100644
--- a/lib/rules/comma-dangle.js
+++ b/lib/rules/comma-dangle.js
@@ -5,5 +5,5 @@
 
 const { wrapCoreRule } = require('../utils')
 
-// eslint-disable-next-line
+// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
 module.exports = wrapCoreRule(require('eslint/lib/rules/comma-dangle'))
diff --git a/lib/rules/comma-style.js b/lib/rules/comma-style.js
index 40772dc37..e7313b8ac 100644
--- a/lib/rules/comma-style.js
+++ b/lib/rules/comma-style.js
@@ -11,6 +11,7 @@ module.exports = wrapCoreRule(require('eslint/lib/rules/comma-style'), {
     return {
       VSlotScopeExpression(node) {
         if (coreHandlers.FunctionExpression) {
+          // @ts-expect-error -- Process params of VSlotScopeExpression as FunctionExpression.
           coreHandlers.FunctionExpression(node)
         }
       }
diff --git a/lib/rules/comment-directive.js b/lib/rules/comment-directive.js
index 74d528a96..9ff9d2fdf 100644
--- a/lib/rules/comment-directive.js
+++ b/lib/rules/comment-directive.js
@@ -5,17 +5,17 @@
 
 'use strict'
 
-/**
- * @typedef {import('eslint').Rule.RuleContext} RuleContext
- * @typedef {import('vue-eslint-parser').AST.VDocumentFragment} VDocumentFragment
- * @typedef {import('vue-eslint-parser').AST.VElement} VElement
- * @typedef {import('vue-eslint-parser').AST.Token} Token
- * @typedef {import('vue-eslint-parser').AST.Location} Location
- */
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const utils = require('../utils')
+
 /**
  * @typedef {object} RuleAndLocation
  * @property {string} RuleAndLocation.ruleId
  * @property {number} RuleAndLocation.index
+ * @property {string} [RuleAndLocation.key]
  */
 // -----------------------------------------------------------------------------
 // Helpers
@@ -218,7 +218,7 @@ function reportUnused(context, comment, kind) {
  * @param {Token} comment The comment token to report.
  * @param {string} kind The comment directive kind.
  * @param {RuleAndLocation[]} rules To report rule.
- * @returns { { ruleId: string; key: string; }[] }
+ * @returns { { ruleId: string, key: string }[] }
  */
 function reportUnusedRules(context, comment, kind, rules) {
   const sourceCode = context.getSourceCode()
@@ -245,7 +245,7 @@ function reportUnusedRules(context, comment, kind, rules) {
 
 /**
  * Gets the key of location
- * @param {Location} location The location
+ * @param {Position} location The location
  * @returns {string} The key
  */
 function locToKey(location) {
@@ -258,15 +258,7 @@ function locToKey(location) {
  * @returns {VElement[]} The top-level elements
  */
 function extractTopLevelHTMLElements(documentFragment) {
-  return documentFragment.children.filter(isVElement)
-
-  /**
-   * @param {any} e
-   * @returns {e is VElement}
-   */
-  function isVElement(e) {
-    return e.type === 'VElement'
-  }
+  return documentFragment.children.filter(utils.isVElement)
 }
 /**
  * Extracts the top-level comments in document fragment.
@@ -324,7 +316,10 @@ module.exports = {
         "Unused {{kind}} directive (no problems were reported from '{{rule}}')."
     }
   },
-
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     const options = context.options[0] || {}
     /** @type {boolean} */
diff --git a/lib/rules/component-definition-name-casing.js b/lib/rules/component-definition-name-casing.js
index 453e3943e..1f2e59a85 100644
--- a/lib/rules/component-definition-name-casing.js
+++ b/lib/rules/component-definition-name-casing.js
@@ -28,7 +28,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0]
     const caseType =
@@ -38,15 +38,20 @@ module.exports = {
     // Public
     // ----------------------------------------------------------------------
 
+    /**
+     * @param {Literal | TemplateLiteral} node
+     */
     function convertName(node) {
+      /** @type {string} */
       let nodeValue
+      /** @type {Range} */
       let range
       if (node.type === 'TemplateLiteral') {
         const quasis = node.quasis[0]
         nodeValue = quasis.value.cooked
         range = quasis.range
       } else {
-        nodeValue = node.value
+        nodeValue = `${node.value}`
         range = node.range
       }
 
@@ -67,6 +72,10 @@ module.exports = {
       }
     }
 
+    /**
+     * @param {Expression | SpreadElement} node
+     * @returns {node is (Literal | TemplateLiteral)}
+     */
     function canConvert(node) {
       return (
         node.type === 'Literal' ||
@@ -88,14 +97,10 @@ module.exports = {
         }
       }),
       utils.executeOnVue(context, (obj) => {
-        const node = obj.properties.find(
-          (item) =>
-            item.type === 'Property' &&
-            item.key.name === 'name' &&
-            canConvert(item.value)
-        )
+        const node = utils.findProperty(obj, 'name')
 
         if (!node) return
+        if (!canConvert(node.value)) return
         convertName(node.value)
       })
     )
diff --git a/lib/rules/component-name-in-template-casing.js b/lib/rules/component-name-in-template-casing.js
index 90eb48d84..a4771c0bf 100644
--- a/lib/rules/component-name-in-template-casing.js
+++ b/lib/rules/component-name-in-template-casing.js
@@ -55,18 +55,20 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const caseOption = context.options[0]
     const options = context.options[1] || {}
     const caseType =
       allowedCaseOptions.indexOf(caseOption) !== -1 ? caseOption : defaultCase
+    /** @type {RegExp[]} */
     const ignores = (options.ignores || []).map(toRegExp)
     const registeredComponentsOnly = options.registeredComponentsOnly !== false
     const tokens =
       context.parserServices.getTemplateBodyTokenStore &&
       context.parserServices.getTemplateBodyTokenStore()
 
+    /** @type { string[] } */
     const registeredComponents = []
 
     /**
@@ -148,20 +150,18 @@ module.exports = {
           }
         }
       },
-      Object.assign(
-        {
-          Program(node) {
-            hasInvalidEOF = utils.hasInvalidEOF(node)
-          }
+      {
+        Program(node) {
+          hasInvalidEOF = utils.hasInvalidEOF(node)
         },
-        registeredComponentsOnly
+        ...(registeredComponentsOnly
           ? utils.executeOnVue(context, (obj) => {
               registeredComponents.push(
                 ...utils.getRegisteredComponents(obj).map((n) => n.name)
               )
             })
-          : {}
-      )
+          : {})
+      }
     )
   }
 }
diff --git a/lib/rules/component-tags-order.js b/lib/rules/component-tags-order.js
index 6fa6f211e..b2a2692a8 100644
--- a/lib/rules/component-tags-order.js
+++ b/lib/rules/component-tags-order.js
@@ -48,13 +48,17 @@ module.exports = {
         'The <{{name}}> should be above the <{{firstUnorderedName}}> on line {{line}}.'
     }
   },
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
-    /** @type {Map<string, number} */
+    /** @type {Map<string, number>} */
     const orderMap = new Map()
-    ;(
-      (context.options[0] && context.options[0].order) ||
-      DEFAULT_ORDER
-    ).forEach((nameOrNames, index) => {
+    /** @type {(string|string[])[]} */
+    const orderOptions =
+      (context.options[0] && context.options[0].order) || DEFAULT_ORDER
+    orderOptions.forEach((nameOrNames, index) => {
       if (Array.isArray(nameOrNames)) {
         for (const name of nameOrNames) {
           orderMap.set(name, index)
@@ -63,17 +67,29 @@ module.exports = {
         orderMap.set(nameOrNames, index)
       }
     })
+
+    /**
+     * @param {string} name
+     */
+    function getOrderPosition(name) {
+      const num = orderMap.get(name)
+      return num == null ? -1 : num
+    }
     const documentFragment =
       context.parserServices.getDocumentFragment &&
       context.parserServices.getDocumentFragment()
 
     function getTopLevelHTMLElements() {
       if (documentFragment) {
-        return documentFragment.children.filter((e) => e.type === 'VElement')
+        return documentFragment.children.filter(utils.isVElement)
       }
       return []
     }
 
+    /**
+     * @param {VElement} element
+     * @param {VElement} firstUnorderedElement
+     */
     function report(element, firstUnorderedElement) {
       context.report({
         node: element,
@@ -87,33 +103,29 @@ module.exports = {
       })
     }
 
-    return utils.defineTemplateBodyVisitor(
-      context,
-      {},
-      {
-        Program(node) {
-          if (utils.hasInvalidEOF(node)) {
+    return {
+      Program(node) {
+        if (utils.hasInvalidEOF(node)) {
+          return
+        }
+        const elements = getTopLevelHTMLElements()
+
+        elements.forEach((element, index) => {
+          const expectedIndex = getOrderPosition(element.name)
+          if (expectedIndex < 0) {
             return
           }
-          const elements = getTopLevelHTMLElements()
-
-          elements.forEach((element, index) => {
-            const expectedIndex = orderMap.get(element.name)
-            if (expectedIndex < 0) {
-              return
-            }
-            const firstUnordered = elements
-              .slice(0, index)
-              .filter((e) => expectedIndex < orderMap.get(e.name))
-              .sort(
-                (e1, e2) => orderMap.get(e1.name) - orderMap.get(e2.name)
-              )[0]
-            if (firstUnordered) {
-              report(element, firstUnordered)
-            }
-          })
-        }
+          const firstUnordered = elements
+            .slice(0, index)
+            .filter((e) => expectedIndex < getOrderPosition(e.name))
+            .sort(
+              (e1, e2) => getOrderPosition(e1.name) - getOrderPosition(e2.name)
+            )[0]
+          if (firstUnordered) {
+            report(element, firstUnordered)
+          }
+        })
       }
-    )
+    }
   }
 }
diff --git a/lib/rules/custom-event-name-casing.js b/lib/rules/custom-event-name-casing.js
index cec6f55d7..cd7f73443 100644
--- a/lib/rules/custom-event-name-casing.js
+++ b/lib/rules/custom-event-name-casing.js
@@ -4,11 +4,6 @@
  */
 'use strict'
 
-/**
- * @typedef {import('vue-eslint-parser').AST.ESLintLiteral} Literal
- * @typedef {import('vue-eslint-parser').AST.ESLintCallExpression} CallExpression
- */
-
 // ------------------------------------------------------------------------------
 // Requirements
 // ------------------------------------------------------------------------------
@@ -33,7 +28,7 @@ function isValidEventName(name) {
 /**
  * Get the name param node from the given CallExpression
  * @param {CallExpression} node CallExpression
- * @returns { Literal & { value: string } }
+ * @returns { Literal & { value: string } | null }
  */
 function getNameParamNode(node) {
   const nameLiteralNode = node.arguments[0]
@@ -46,7 +41,7 @@ function getNameParamNode(node) {
     return null
   }
 
-  return nameLiteralNode
+  return /** @type {Literal & { value: string }} */ (nameLiteralNode)
 }
 /**
  * Get the callee member node from the given CallExpression
@@ -82,7 +77,7 @@ module.exports = {
       unexpected: "Custom event name '{{name}}' must be kebab-case."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const setupContexts = new Map()
 
@@ -121,28 +116,26 @@ module.exports = {
       utils.compositingVisitors(
         utils.defineVueVisitor(context, {
           onSetupFunctionEnter(node, { node: vueNode }) {
-            const contextParam = node.params[1]
+            const contextParam = utils.unwrapAssignmentPattern(node.params[1])
             if (!contextParam) {
               // no arguments
               return
             }
-            if (contextParam.type === 'RestElement') {
-              // cannot check
-              return
-            }
-            if (contextParam.type === 'ArrayPattern') {
+            if (
+              contextParam.type === 'RestElement' ||
+              contextParam.type === 'ArrayPattern'
+            ) {
               // cannot check
               return
             }
             const contextReferenceIds = new Set()
             const emitReferenceIds = new Set()
             if (contextParam.type === 'ObjectPattern') {
-              const emitProperty = contextParam.properties.find(
-                (p) =>
-                  p.type === 'Property' &&
-                  utils.getStaticPropertyName(p) === 'emit'
+              const emitProperty = utils.findAssignmentProperty(
+                contextParam,
+                'emit'
               )
-              if (!emitProperty) {
+              if (!emitProperty || emitProperty.value.type !== 'Identifier') {
                 return
               }
               const emitParam = emitProperty.value
diff --git a/lib/rules/dot-location.js b/lib/rules/dot-location.js
index c8889bb63..14ab075cd 100644
--- a/lib/rules/dot-location.js
+++ b/lib/rules/dot-location.js
@@ -5,5 +5,5 @@
 
 const { wrapCoreRule } = require('../utils')
 
-// eslint-disable-next-line
+// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
 module.exports = wrapCoreRule(require('eslint/lib/rules/dot-location'))
diff --git a/lib/rules/eqeqeq.js b/lib/rules/eqeqeq.js
index 5e9d4d8b9..e749e41f7 100644
--- a/lib/rules/eqeqeq.js
+++ b/lib/rules/eqeqeq.js
@@ -5,5 +5,5 @@
 
 const { wrapCoreRule } = require('../utils')
 
-// eslint-disable-next-line
+// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
 module.exports = wrapCoreRule(require('eslint/lib/rules/eqeqeq'))
diff --git a/lib/rules/html-closing-bracket-newline.js b/lib/rules/html-closing-bracket-newline.js
index 20d7fbd20..6963de8f1 100644
--- a/lib/rules/html-closing-bracket-newline.js
+++ b/lib/rules/html-closing-bracket-newline.js
@@ -15,6 +15,9 @@ const utils = require('../utils')
 // Helpers
 // ------------------------------------------------------------------------------
 
+/**
+ * @param {number} lineBreaks
+ */
 function getPhrase(lineBreaks) {
   switch (lineBreaks) {
     case 0:
@@ -51,7 +54,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = Object.assign(
       {},
@@ -66,6 +69,7 @@ module.exports = {
       context.parserServices.getTemplateBodyTokenStore()
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VStartTag | VEndTag} node */
       'VStartTag, VEndTag'(node) {
         const closingBracketToken = template.getLastToken(node)
         if (
@@ -98,6 +102,7 @@ module.exports = {
               actual: getPhrase(actualLineBreaks)
             },
             fix(fixer) {
+              /** @type {Range} */
               const range = [prevToken.range[1], closingBracketToken.range[0]]
               const text = '\n'.repeat(expectedLineBreaks)
               return fixer.replaceTextRange(range, text)
diff --git a/lib/rules/html-closing-bracket-spacing.js b/lib/rules/html-closing-bracket-spacing.js
index 9b70dfb09..95de6d01f 100644
--- a/lib/rules/html-closing-bracket-spacing.js
+++ b/lib/rules/html-closing-bracket-spacing.js
@@ -14,40 +14,49 @@ const utils = require('../utils')
 // Helpers
 // -----------------------------------------------------------------------------
 
+/**
+ * @typedef { {startTag?:"always"|"never",endTag?:"always"|"never",selfClosingTag?:"always"|"never"} } Options
+ */
+
 /**
  * Normalize options.
- * @param {{startTag?:"always"|"never",endTag?:"always"|"never",selfClosingTag?:"always"|"never"}} options The options user configured.
- * @param {TokenStore} tokens The token store of template body.
- * @returns {{startTag:"always"|"never",endTag:"always"|"never",selfClosingTag:"always"|"never"}} The normalized options.
+ * @param {Options} options The options user configured.
+ * @param {ParserServices.TokenStore} tokens The token store of template body.
+ * @returns {Options & { detectType: (node: VStartTag | VEndTag) => 'never' | 'always' | null }} The normalized options.
  */
 function parseOptions(options, tokens) {
-  return Object.assign(
+  const opts = Object.assign(
     {
       startTag: 'never',
       endTag: 'never',
-      selfClosingTag: 'always',
-
-      detectType(node) {
-        const openType = tokens.getFirstToken(node).type
-        const closeType = tokens.getLastToken(node).type
-
-        if (openType === 'HTMLEndTagOpen' && closeType === 'HTMLTagClose') {
-          return this.endTag
-        }
-        if (openType === 'HTMLTagOpen' && closeType === 'HTMLTagClose') {
-          return this.startTag
-        }
-        if (
-          openType === 'HTMLTagOpen' &&
-          closeType === 'HTMLSelfClosingTagClose'
-        ) {
-          return this.selfClosingTag
-        }
-        return null
-      }
+      selfClosingTag: 'always'
     },
     options
   )
+  return Object.assign(opts, {
+    /**
+     * @param {VStartTag | VEndTag} node
+     * @returns {'never' | 'always' | null}
+     */
+    detectType(node) {
+      const openType = tokens.getFirstToken(node).type
+      const closeType = tokens.getLastToken(node).type
+
+      if (openType === 'HTMLEndTagOpen' && closeType === 'HTMLTagClose') {
+        return opts.endTag
+      }
+      if (openType === 'HTMLTagOpen' && closeType === 'HTMLTagClose') {
+        return opts.startTag
+      }
+      if (
+        openType === 'HTMLTagOpen' &&
+        closeType === 'HTMLSelfClosingTagClose'
+      ) {
+        return opts.selfClosingTag
+      }
+      return null
+    }
+  })
 }
 
 // -----------------------------------------------------------------------------
@@ -75,7 +84,7 @@ module.exports = {
     ],
     fixable: 'whitespace'
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
     const tokens =
@@ -84,6 +93,7 @@ module.exports = {
     const options = parseOptions(context.options[0], tokens)
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VStartTag | VEndTag} node */
       'VStartTag, VEndTag'(node) {
         const type = options.detectType(node)
         const lastToken = tokens.getLastToken(node)
diff --git a/lib/rules/html-comment-content-newline.js b/lib/rules/html-comment-content-newline.js
index e5e436490..3985f7d52 100644
--- a/lib/rules/html-comment-content-newline.js
+++ b/lib/rules/html-comment-content-newline.js
@@ -11,13 +11,16 @@
 const htmlComments = require('../utils/html-comments')
 
 /**
- * @typedef { import('../utils/html-comments').HTMLComment } HTMLComment
+ * @typedef { import('../utils/html-comments').ParsedHTMLComment } ParsedHTMLComment
  */
 
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
 
+/**
+ * @param {any} param
+ */
 function parseOption(param) {
   if (param && typeof param === 'string') {
     return {
@@ -87,22 +90,24 @@ module.exports = {
       unexpectedBeforeHTMLCommentOpen: "Unexpected line breaks before '-->'."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const option = parseOption(context.options[0])
     return htmlComments.defineVisitor(
       context,
       context.options[1],
       (comment) => {
-        if (!comment.value) {
+        const { value, openDecoration, closeDecoration } = comment
+        if (!value) {
           return
         }
-        const startLine = comment.openDecoration
-          ? comment.openDecoration.loc.end.line
-          : comment.value.loc.start.line
-        const endLine = comment.closeDecoration
-          ? comment.closeDecoration.loc.start.line
-          : comment.value.loc.end.line
+
+        const startLine = openDecoration
+          ? openDecoration.loc.end.line
+          : value.loc.start.line
+        const endLine = closeDecoration
+          ? closeDecoration.loc.start.line
+          : value.loc.end.line
         const newlineType =
           startLine === endLine ? option.singleline : option.multiline
         if (newlineType === 'ignore') {
@@ -115,92 +120,94 @@ module.exports = {
 
     /**
      * Reports the newline before the contents of a given comment if it's invalid.
-     * @param {HTMLComment} comment - comment data.
+     * @param {ParsedHTMLComment} comment - comment data.
      * @param {boolean} requireNewline - `true` if line breaks are required.
      * @returns {void}
      */
     function checkCommentOpen(comment, requireNewline) {
-      const beforeToken = comment.openDecoration || comment.open
+      const { value, openDecoration, open } = comment
+      if (!value) {
+        return
+      }
+      const beforeToken = openDecoration || open
 
       if (requireNewline) {
-        if (beforeToken.loc.end.line < comment.value.loc.start.line) {
+        if (beforeToken.loc.end.line < value.loc.start.line) {
           // Is valid
           return
         }
         context.report({
           loc: {
             start: beforeToken.loc.end,
-            end: comment.value.loc.start
+            end: value.loc.start
           },
-          messageId: comment.openDecoration
+          messageId: openDecoration
             ? 'expectedAfterExceptionBlock'
             : 'expectedAfterHTMLCommentOpen',
-          fix: comment.openDecoration
+          fix: openDecoration
             ? undefined
             : (fixer) => fixer.insertTextAfter(beforeToken, '\n')
         })
       } else {
-        if (beforeToken.loc.end.line === comment.value.loc.start.line) {
+        if (beforeToken.loc.end.line === value.loc.start.line) {
           // Is valid
           return
         }
         context.report({
           loc: {
             start: beforeToken.loc.end,
-            end: comment.value.loc.start
+            end: value.loc.start
           },
           messageId: 'unexpectedAfterHTMLCommentOpen',
           fix: (fixer) =>
-            fixer.replaceTextRange(
-              [beforeToken.range[1], comment.value.range[0]],
-              ' '
-            )
+            fixer.replaceTextRange([beforeToken.range[1], value.range[0]], ' ')
         })
       }
     }
 
     /**
      * Reports the space after the contents of a given comment if it's invalid.
-     * @param {HTMLComment} comment - comment data.
+     * @param {ParsedHTMLComment} comment - comment data.
      * @param {boolean} requireNewline - `true` if line breaks are required.
      * @returns {void}
      */
     function checkCommentClose(comment, requireNewline) {
-      const afterToken = comment.closeDecoration || comment.close
+      const { value, closeDecoration, close } = comment
+      if (!value) {
+        return
+      }
+      const afterToken = closeDecoration || close
 
       if (requireNewline) {
-        if (comment.value.loc.end.line < afterToken.loc.start.line) {
+        if (value.loc.end.line < afterToken.loc.start.line) {
           // Is valid
           return
         }
         context.report({
           loc: {
-            start: comment.value.loc.end,
+            start: value.loc.end,
             end: afterToken.loc.start
           },
-          messageId: comment.closeDecoration
+          messageId: closeDecoration
             ? 'expectedBeforeExceptionBlock'
             : 'expectedBeforeHTMLCommentOpen',
-          fix: comment.closeDecoration
+          fix: closeDecoration
             ? undefined
             : (fixer) => fixer.insertTextBefore(afterToken, '\n')
         })
       } else {
-        if (comment.value.loc.end.line === afterToken.loc.start.line) {
+        if (value.loc.end.line === afterToken.loc.start.line) {
           // Is valid
           return
         }
         context.report({
           loc: {
-            start: comment.value.loc.end,
+            start: value.loc.end,
             end: afterToken.loc.start
           },
           messageId: 'unexpectedBeforeHTMLCommentOpen',
           fix: (fixer) =>
-            fixer.replaceTextRange(
-              [comment.value.range[1], afterToken.range[0]],
-              ' '
-            )
+            fixer.replaceTextRange([value.range[1], afterToken.range[0]], ' ')
         })
       }
     }
diff --git a/lib/rules/html-comment-content-spacing.js b/lib/rules/html-comment-content-spacing.js
index 250fd7ae9..b4f31672a 100644
--- a/lib/rules/html-comment-content-spacing.js
+++ b/lib/rules/html-comment-content-spacing.js
@@ -11,7 +11,7 @@
 const htmlComments = require('../utils/html-comments')
 
 /**
- * @typedef { import('../utils/html-comments').HTMLComment } HTMLComment
+ * @typedef { import('../utils/html-comments').ParsedHTMLComment } ParsedHTMLComment
  */
 
 // ------------------------------------------------------------------------------
@@ -54,7 +54,7 @@ module.exports = {
       unexpectedBeforeHTMLCommentOpen: "Unexpected space before '-->'."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     // Unless the first option is never, require a space
     const requireSpace = context.options[0] !== 'never'
@@ -62,9 +62,6 @@ module.exports = {
       context,
       context.options[1],
       (comment) => {
-        if (!comment.value) {
-          return
-        }
         checkCommentOpen(comment)
         checkCommentClose(comment)
       },
@@ -73,100 +70,108 @@ module.exports = {
 
     /**
      * Reports the space before the contents of a given comment if it's invalid.
-     * @param {HTMLComment} comment - comment data.
+     * @param {ParsedHTMLComment} comment - comment data.
      * @returns {void}
      */
     function checkCommentOpen(comment) {
-      const beforeToken = comment.openDecoration || comment.open
-      if (beforeToken.loc.end.line !== comment.value.loc.start.line) {
+      const { value, openDecoration, open } = comment
+      if (!value) {
+        return
+      }
+      const beforeToken = openDecoration || open
+      if (beforeToken.loc.end.line !== value.loc.start.line) {
         // Ignore newline
         return
       }
 
       if (requireSpace) {
-        if (beforeToken.range[1] < comment.value.range[0]) {
+        if (beforeToken.range[1] < value.range[0]) {
           // Is valid
           return
         }
         context.report({
           loc: {
             start: beforeToken.loc.end,
-            end: comment.value.loc.start
+            end: value.loc.start
           },
-          messageId: comment.openDecoration
+          messageId: openDecoration
             ? 'expectedAfterExceptionBlock'
             : 'expectedAfterHTMLCommentOpen',
-          fix: comment.openDecoration
+          fix: openDecoration
             ? undefined
             : (fixer) => fixer.insertTextAfter(beforeToken, ' ')
         })
       } else {
-        if (comment.openDecoration) {
+        if (openDecoration) {
           // Ignore expection block
           return
         }
-        if (beforeToken.range[1] === comment.value.range[0]) {
+        if (beforeToken.range[1] === value.range[0]) {
           // Is valid
           return
         }
         context.report({
           loc: {
             start: beforeToken.loc.end,
-            end: comment.value.loc.start
+            end: value.loc.start
           },
           messageId: 'unexpectedAfterHTMLCommentOpen',
           fix: (fixer) =>
-            fixer.removeRange([beforeToken.range[1], comment.value.range[0]])
+            fixer.removeRange([beforeToken.range[1], value.range[0]])
         })
       }
     }
 
     /**
      * Reports the space after the contents of a given comment if it's invalid.
-     * @param {HTMLComment} comment - comment data.
+     * @param {ParsedHTMLComment} comment - comment data.
      * @returns {void}
      */
     function checkCommentClose(comment) {
-      const afterToken = comment.closeDecoration || comment.close
-      if (comment.value.loc.end.line !== afterToken.loc.start.line) {
+      const { value, closeDecoration, close } = comment
+      if (!value) {
+        return
+      }
+      const afterToken = closeDecoration || close
+      if (value.loc.end.line !== afterToken.loc.start.line) {
         // Ignore newline
         return
       }
 
       if (requireSpace) {
-        if (comment.value.range[1] < afterToken.range[0]) {
+        if (value.range[1] < afterToken.range[0]) {
           // Is valid
           return
         }
         context.report({
           loc: {
-            start: comment.value.loc.end,
+            start: value.loc.end,
             end: afterToken.loc.start
           },
-          messageId: comment.closeDecoration
+          messageId: closeDecoration
             ? 'expectedBeforeExceptionBlock'
             : 'expectedBeforeHTMLCommentOpen',
-          fix: comment.closeDecoration
+          fix: closeDecoration
             ? undefined
             : (fixer) => fixer.insertTextBefore(afterToken, ' ')
         })
       } else {
-        if (comment.closeDecoration) {
+        if (closeDecoration) {
           // Ignore expection block
           return
         }
-        if (comment.value.range[1] === afterToken.range[0]) {
+        if (value.range[1] === afterToken.range[0]) {
           // Is valid
           return
         }
         context.report({
           loc: {
-            start: comment.value.loc.end,
+            start: value.loc.end,
             end: afterToken.loc.start
           },
           messageId: 'unexpectedBeforeHTMLCommentOpen',
           fix: (fixer) =>
-            fixer.removeRange([comment.value.range[1], afterToken.range[0]])
+            fixer.removeRange([value.range[1], afterToken.range[0]])
         })
       }
     }
diff --git a/lib/rules/html-comment-indent.js b/lib/rules/html-comment-indent.js
index c3b60bfcc..d5992b59b 100644
--- a/lib/rules/html-comment-indent.js
+++ b/lib/rules/html-comment-indent.js
@@ -10,10 +10,6 @@
 
 const htmlComments = require('../utils/html-comments')
 
-/**
- * @typedef { import('../utils/html-comments').HTMLComment } HTMLComment
- */
-
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
@@ -21,16 +17,17 @@ const htmlComments = require('../utils/html-comments')
 /**
  * Normalize options.
  * @param {number|"tab"|undefined} type The type of indentation.
- * @returns {Object} Normalized options.
+ * @returns { { indentChar: string, indentSize: number, indentText: string } } Normalized options.
  */
 function parseOptions(type) {
   const ret = {
     indentChar: ' ',
-    indentSize: 2
+    indentSize: 2,
+    indentText: ''
   }
 
   if (Number.isSafeInteger(type)) {
-    ret.indentSize = type
+    ret.indentSize = Number(type)
   } else if (type === 'tab') {
     ret.indentChar = '\t'
     ret.indentSize = 1
@@ -40,6 +37,10 @@ function parseOptions(type) {
   return ret
 }
 
+/**
+ * @param {string} s
+ * @param {string} [unitChar]
+ */
 function toDisplay(s, unitChar) {
   if (s.length === 0 && unitChar) {
     return `0 ${toUnit(unitChar)}s`
@@ -54,6 +55,7 @@ function toDisplay(s, unitChar) {
   return JSON.stringify(s)
 }
 
+/** @param {string} char */
 function toUnit(char) {
   if (char === '\t') {
     return 'tab'
@@ -96,7 +98,7 @@ module.exports = {
         'Expected relative indentation of {{expected}} but found {{actual}}.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = parseOptions(context.options[0])
     const sourceCode = context.getSourceCode()
@@ -158,7 +160,7 @@ module.exports = {
      * @param {number} line The number of line.
      * @param {string} actualIndentText The actual indentation text.
      * @param {string} expectedIndentText The expected indentation text.
-     * @returns {function} The defined function.
+     * @returns { (fixer: RuleFixer) => Fix } The defined function.
      */
     function defineFix(line, actualIndentText, expectedIndentText) {
       return (fixer) => {
diff --git a/lib/rules/html-end-tags.js b/lib/rules/html-end-tags.js
index b40a53ce0..59d2e874f 100644
--- a/lib/rules/html-end-tags.js
+++ b/lib/rules/html-end-tags.js
@@ -26,7 +26,7 @@ module.exports = {
     fixable: 'code',
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     let hasInvalidEOF = false
 
diff --git a/lib/rules/html-indent.js b/lib/rules/html-indent.js
index 9cbea60c7..6e6149ef5 100644
--- a/lib/rules/html-indent.js
+++ b/lib/rules/html-indent.js
@@ -17,6 +17,7 @@ const utils = require('../utils')
 // ------------------------------------------------------------------------------
 
 module.exports = {
+  /** @param {RuleContext} context */
   create(context) {
     const tokenStore =
       context.parserServices.getTemplateBodyTokenStore &&
diff --git a/lib/rules/html-quotes.js b/lib/rules/html-quotes.js
index 05bb272d5..9f741b21b 100644
--- a/lib/rules/html-quotes.js
+++ b/lib/rules/html-quotes.js
@@ -37,7 +37,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
     const double = context.options[0] !== 'single'
@@ -45,6 +45,7 @@ module.exports = {
       context.options[1] && context.options[1].avoidEscape === true
     const quoteChar = double ? '"' : "'"
     const quoteName = double ? 'double quotes' : 'single quotes'
+    /** @type {boolean} */
     let hasInvalidEOF
 
     return utils.defineTemplateBodyVisitor(
diff --git a/lib/rules/html-self-closing.js b/lib/rules/html-self-closing.js
index f2fa0b277..f8841f782 100644
--- a/lib/rules/html-self-closing.js
+++ b/lib/rules/html-self-closing.js
@@ -18,54 +18,63 @@ const utils = require('../utils')
 /**
  * These strings wil be displayed in error messages.
  */
-const ELEMENT_TYPE = Object.freeze({
+const ELEMENT_TYPE_MESSAGES = Object.freeze({
   NORMAL: 'HTML elements',
   VOID: 'HTML void elements',
   COMPONENT: 'Vue.js custom components',
   SVG: 'SVG elements',
-  MATH: 'MathML elements'
+  MATH: 'MathML elements',
+  UNKNOWN: 'unknown elements'
 })
 
+/**
+ * @typedef {object} Options
+ * @property {'always' | 'never'} NORMAL
+ * @property {'always' | 'never'} VOID
+ * @property {'always' | 'never'} COMPONENT
+ * @property {'always' | 'never'} SVG
+ * @property {'always' | 'never'} MATH
+ * @property {null} UNKNOWN
+ */
+
 /**
  * Normalize the given options.
- * @param {Object|undefined} options The raw options object.
- * @returns {Object} Normalized options.
+ * @param {any} options The raw options object.
+ * @returns {Options} Normalized options.
  */
 function parseOptions(options) {
   return {
-    [ELEMENT_TYPE.NORMAL]:
-      (options && options.html && options.html.normal) || 'always',
-    [ELEMENT_TYPE.VOID]:
-      (options && options.html && options.html.void) || 'never',
-    [ELEMENT_TYPE.COMPONENT]:
-      (options && options.html && options.html.component) || 'always',
-    [ELEMENT_TYPE.SVG]: (options && options.svg) || 'always',
-    [ELEMENT_TYPE.MATH]: (options && options.math) || 'always'
+    NORMAL: (options && options.html && options.html.normal) || 'always',
+    VOID: (options && options.html && options.html.void) || 'never',
+    COMPONENT: (options && options.html && options.html.component) || 'always',
+    SVG: (options && options.svg) || 'always',
+    MATH: (options && options.math) || 'always',
+    UNKNOWN: null
   }
 }
 
 /**
  * Get the elementType of the given element.
  * @param {VElement} node The element node to get.
- * @returns {string} The elementType of the element.
+ * @returns {keyof Options} The elementType of the element.
  */
 function getElementType(node) {
   if (utils.isCustomComponent(node)) {
-    return ELEMENT_TYPE.COMPONENT
+    return 'COMPONENT'
   }
   if (utils.isHtmlElementNode(node)) {
     if (utils.isHtmlVoidElementName(node.name)) {
-      return ELEMENT_TYPE.VOID
+      return 'VOID'
     }
-    return ELEMENT_TYPE.NORMAL
+    return 'NORMAL'
   }
   if (utils.isSvgElementNode(node)) {
-    return ELEMENT_TYPE.SVG
+    return 'SVG'
   }
   if (utils.isMathMLElementNode(node)) {
-    return ELEMENT_TYPE.MATH
+    return 'MATH'
   }
-  return 'unknown elements'
+  return 'UNKNOWN'
 }
 
 /**
@@ -124,7 +133,7 @@ module.exports = {
       maxItems: 1
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
     const options = parseOptions(context.options[0])
@@ -150,7 +159,10 @@ module.exports = {
               node,
               loc: node.loc,
               message: 'Require self-closing on {{elementType}} (<{{name}}>).',
-              data: { elementType, name: node.rawName },
+              data: {
+                elementType: ELEMENT_TYPE_MESSAGES[elementType],
+                name: node.rawName
+              },
               fix: (fixer) => {
                 const tokens = context.parserServices.getTemplateBodyTokenStore()
                 const close = tokens.getLastToken(node.startTag)
@@ -171,14 +183,17 @@ module.exports = {
               loc: node.loc,
               message:
                 'Disallow self-closing on {{elementType}} (<{{name}}/>).',
-              data: { elementType, name: node.rawName },
+              data: {
+                elementType: ELEMENT_TYPE_MESSAGES[elementType],
+                name: node.rawName
+              },
               fix: (fixer) => {
                 const tokens = context.parserServices.getTemplateBodyTokenStore()
                 const close = tokens.getLastToken(node.startTag)
                 if (close.type !== 'HTMLSelfClosingTagClose') {
                   return null
                 }
-                if (elementType === ELEMENT_TYPE.VOID) {
+                if (elementType === 'VOID') {
                   return fixer.replaceText(close, '>')
                 }
                 // If only `close` is targeted for replacement, it conflicts with `component-name-in-template-casing`,
diff --git a/lib/rules/jsx-uses-vars.js b/lib/rules/jsx-uses-vars.js
index 2d335dde1..0da5e486f 100644
--- a/lib/rules/jsx-uses-vars.js
+++ b/lib/rules/jsx-uses-vars.js
@@ -44,18 +44,21 @@ module.exports = {
     },
     schema: []
   },
-
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     return {
       JSXOpeningElement(node) {
         let name
-        if (node.name.name) {
+        if (node.name.type === 'JSXIdentifier') {
           // <Foo>
           name = node.name.name
-        } else if (node.name.object) {
+        } else if (node.name.type === 'JSXMemberExpression') {
           // <Foo...Bar>
           let parent = node.name.object
-          while (parent.object) {
+          while (parent.type === 'JSXMemberExpression') {
             parent = parent.object
           }
           name = parent.name
diff --git a/lib/rules/match-component-file-name.js b/lib/rules/match-component-file-name.js
index 45d603727..8428516fb 100644
--- a/lib/rules/match-component-file-name.js
+++ b/lib/rules/match-component-file-name.js
@@ -45,7 +45,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0]
     const shouldMatchCase = (options && options.shouldMatchCase) || false
@@ -57,6 +57,7 @@ module.exports = {
     const extension = path.extname(context.getFilename())
     const filename = path.basename(context.getFilename(), extension)
 
+    /** @type {Rule.ReportDescriptor[]} */
     const errors = []
     let componentCount = 0
 
@@ -68,6 +69,10 @@ module.exports = {
     // Private
     // ----------------------------------------------------------------------
 
+    /**
+     * @param {string} name
+     * @param {string} filename
+     */
     function compareNames(name, filename) {
       if (shouldMatchCase) {
         return name === filename
@@ -79,13 +84,16 @@ module.exports = {
       )
     }
 
+    /**
+     * @param {Literal | TemplateLiteral} node
+     */
     function verifyName(node) {
       let name
       if (node.type === 'TemplateLiteral') {
         const quasis = node.quasis[0]
         name = quasis.value.cooked
       } else {
-        name = node.value
+        name = `${node.value}`
       }
 
       if (!compareNames(name, filename)) {
@@ -98,6 +106,10 @@ module.exports = {
       }
     }
 
+    /**
+     * @param {Expression | SpreadElement} node
+     * @returns {node is (Literal | TemplateLiteral)}
+     */
     function canVerify(node) {
       return (
         node.type === 'Literal' ||
@@ -119,16 +131,12 @@ module.exports = {
         }
       }),
       utils.executeOnVue(context, (object) => {
-        const node = object.properties.find(
-          (item) =>
-            item.type === 'Property' &&
-            item.key.name === 'name' &&
-            canVerify(item.value)
-        )
+        const node = utils.findProperty(object, 'name')
 
         componentCount++
 
         if (!node) return
+        if (!canVerify(node.value)) return
         verifyName(node.value)
       }),
       {
diff --git a/lib/rules/max-attributes-per-line.js b/lib/rules/max-attributes-per-line.js
index 29b6a4e6b..8cec63617 100644
--- a/lib/rules/max-attributes-per-line.js
+++ b/lib/rules/max-attributes-per-line.js
@@ -65,7 +65,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
     const configuration = parseOptions(context.options[0])
@@ -107,6 +107,9 @@ module.exports = {
     // ----------------------------------------------------------------------
     // Helpers
     // ----------------------------------------------------------------------
+    /**
+     * @param {any} options
+     */
     function parseOptions(options) {
       const defaults = {
         singleline: 1,
@@ -139,32 +142,40 @@ module.exports = {
       return defaults
     }
 
+    /**
+     * @param {(VDirective | VAttribute)[]} attributes
+     */
     function showErrors(attributes) {
       attributes.forEach((prop, i) => {
-        const fix = (fixer) => {
-          if (i !== 0) return null
-
-          // Find the closest token before the current prop
-          // that is not a white space
-          const prevToken = template.getTokenBefore(prop, {
-            filter: (token) => token.type !== 'HTMLWhitespace'
-          })
-
-          const range = [prevToken.range[1], prop.range[0]]
-
-          return fixer.replaceTextRange(range, '\n')
-        }
-
         context.report({
           node: prop,
           loc: prop.loc,
           message: "'{{name}}' should be on a new line.",
           data: { name: sourceCode.getText(prop.key) },
-          fix
+          fix(fixer) {
+            if (i !== 0) return null
+
+            // Find the closest token before the current prop
+            // that is not a white space
+            const prevToken = /** @type {Token} */ (template.getTokenBefore(
+              prop,
+              {
+                filter: (token) => token.type !== 'HTMLWhitespace'
+              }
+            ))
+
+            /** @type {Range} */
+            const range = [prevToken.range[1], prop.range[0]]
+
+            return fixer.replaceTextRange(range, '\n')
+          }
         })
       })
     }
 
+    /**
+     * @param {(VDirective | VAttribute)[]} attributes
+     */
     function groupAttrsByLine(attributes) {
       const propsPerLine = [[attributes[0]]]
 
diff --git a/lib/rules/max-len.js b/lib/rules/max-len.js
index 8f1b07b87..6de8f8953 100644
--- a/lib/rules/max-len.js
+++ b/lib/rules/max-len.js
@@ -82,20 +82,23 @@ const OPTIONS_OR_INTEGER_SCHEMA = {
  * Computes the length of a line that may contain tabs. The width of each
  * tab will be the number of spaces to the next tab stop.
  * @param {string} line The line.
- * @param {int} tabWidth The width of each tab stop in spaces.
- * @returns {int} The computed line length.
+ * @param {number} tabWidth The width of each tab stop in spaces.
+ * @returns {number} The computed line length.
  * @private
  */
 function computeLineLength(line, tabWidth) {
   let extraCharacterCount = 0
 
-  line.replace(/\t/gu, (match, offset) => {
+  const re = /\t/gu
+  let ret
+  while ((ret = re.exec(line))) {
+    const offset = ret.index
     const totalOffset = offset + extraCharacterCount
     const previousTabStopOffset = tabWidth ? totalOffset % tabWidth : 0
     const spaceCount = tabWidth - previousTabStopOffset
-
     extraCharacterCount += spaceCount - 1 // -1 for the replaced tab
-  })
+  }
+
   return Array.from(line).length + extraCharacterCount
 }
 
@@ -104,16 +107,16 @@ function computeLineLength(line, tabWidth) {
  * extends to or past the end of the current line.
  * @param {string} line The source line we want to check for a trailing comment on
  * @param {number} lineNumber The one-indexed line number for line
- * @param {ASTNode} comment The comment to inspect
- * @returns {boolean} If the comment is trailing on the given line
+ * @param {Token | null} comment The comment to inspect
+ * @returns {comment is Token} If the comment is trailing on the given line
  */
 function isTrailingComment(line, lineNumber, comment) {
-  return (
+  return Boolean(
     comment &&
-    comment.loc.start.line === lineNumber &&
-    lineNumber <= comment.loc.end.line &&
-    (comment.loc.end.line > lineNumber ||
-      comment.loc.end.column === line.length)
+      comment.loc.start.line === lineNumber &&
+      lineNumber <= comment.loc.end.line &&
+      (comment.loc.end.line > lineNumber ||
+        comment.loc.end.column === line.length)
   )
 }
 
@@ -121,10 +124,13 @@ function isTrailingComment(line, lineNumber, comment) {
  * Tells if a comment encompasses the entire line.
  * @param {string} line The source line with a trailing comment
  * @param {number} lineNumber The one-indexed line number this is on
- * @param {ASTNode} comment The comment to remove
+ * @param {Token | null} comment The comment to remove
  * @returns {boolean} If the comment covers the entire line
  */
 function isFullLineComment(line, lineNumber, comment) {
+  if (!comment) {
+    return false
+  }
   const start = comment.loc.start
   const end = comment.loc.end
   const isFirstTokenOnLine = !line.slice(0, comment.loc.start.column).trim()
@@ -142,7 +148,7 @@ function isFullLineComment(line, lineNumber, comment) {
  * Gets the line after the comment and any remaining trailing whitespace is
  * stripped.
  * @param {string} line The source line with a trailing comment
- * @param {ASTNode} comment The comment to remove
+ * @param {Token} comment The comment to remove
  * @returns {string} Line without comment and trailing whitepace
  */
 function stripTrailingComment(line, comment) {
@@ -153,9 +159,9 @@ function stripTrailingComment(line, comment) {
 /**
  * Ensure that an array exists at [key] on `object`, and add `value` to it.
  *
- * @param {Object} object the object to mutate
- * @param {string} key the object's key
- * @param {*} value the value to add
+ * @param { { [key: number]: Token[] } } object the object to mutate
+ * @param {number} key the object's key
+ * @param {Token} value the value to add
  * @returns {void}
  * @private
  */
@@ -169,9 +175,9 @@ function ensureArrayAndPush(object, key, value) {
 /**
  * A reducer to group an AST node by line number, both start and end.
  *
- * @param {Object} acc the accumulator
- * @param {ASTNode} node the AST node in question
- * @returns {Object} the modified accumulator
+ * @param { { [key: number]: Token[] } } acc the accumulator
+ * @param {Token} node the AST node in question
+ * @returns { { [key: number]: Token[] } } the modified accumulator
  * @private
  */
 function groupByLineNumber(acc, node) {
@@ -209,7 +215,10 @@ module.exports = {
         'This line has a comment length of {{lineLength}}. Maximum allowed is {{maxCommentLength}}.'
     }
   },
-
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     /*
      * Inspired by http://tools.ietf.org/html/rfc3986#appendix-B, however:
@@ -222,8 +231,11 @@ module.exports = {
     const URL_REGEXP = /[^:/?#]:\/\/[^?#]/u
 
     const sourceCode = context.getSourceCode()
+    /** @type {Token[]} */
     const tokens = []
+    /** @type {(HTMLComment | HTMLBogusComment | Comment)[]} */
     const comments = []
+    /** @type {VLiteral[]} */
     const htmlAttributeValues = []
 
     // The options object must be the last option specified…
@@ -241,9 +253,11 @@ module.exports = {
     if (typeof context.options[1] === 'number') {
       options.tabWidth = context.options[1]
     }
-
+    /** @type {number} */
     const scriptMaxLength = typeof options.code === 'number' ? options.code : 80
+    /** @type {number} */
     const tabWidth = typeof options.tabWidth === 'number' ? options.tabWidth : 2 // default value of `vue/html-indent`
+    /** @type {number} */
     const templateMaxLength =
       typeof options.template === 'number' ? options.template : scriptMaxLength
     const ignoreComments = !!options.ignoreComments
@@ -255,7 +269,9 @@ module.exports = {
     const ignoreUrls = !!options.ignoreUrls
     const ignoreHTMLAttributeValues = !!options.ignoreHTMLAttributeValues
     const ignoreHTMLTextContents = !!options.ignoreHTMLTextContents
+    /** @type {number} */
     const maxCommentLength = options.comments
+    /** @type {RegExp} */
     let ignorePattern = options.ignorePattern || null
 
     if (ignorePattern) {
@@ -269,7 +285,7 @@ module.exports = {
     /**
      * Retrieves an array containing all strings (" or ') in the source code.
      *
-     * @returns {ASTNode[]} An array of string nodes.
+     * @returns {Token[]} An array of string nodes.
      */
     function getAllStrings() {
       return tokens.filter(
@@ -284,7 +300,7 @@ module.exports = {
     /**
      * Retrieves an array containing all template literals in the source code.
      *
-     * @returns {ASTNode[]} An array of template literal nodes.
+     * @returns {Token[]} An array of template literal nodes.
      */
     function getAllTemplateLiterals() {
       return tokens.filter((token) => token.type === 'Template')
@@ -293,7 +309,7 @@ module.exports = {
     /**
      * Retrieves an array containing all RegExp literals in the source code.
      *
-     * @returns {ASTNode[]} An array of RegExp literal nodes.
+     * @returns {Token[]} An array of RegExp literal nodes.
      */
     function getAllRegExpLiterals() {
       return tokens.filter((token) => token.type === 'RegularExpression')
@@ -302,7 +318,7 @@ module.exports = {
     /**
      * Retrieves an array containing all HTML texts in the source code.
      *
-     * @returns {ASTNode[]} An array of HTML text nodes.
+     * @returns {Token[]} An array of HTML text nodes.
      */
     function getAllHTMLTextContents() {
       return tokens.filter((token) => token.type === 'HTMLText')
@@ -310,7 +326,7 @@ module.exports = {
 
     /**
      * Check the program for max length
-     * @param {ASTNode} node Node to examine
+     * @param {Program} node Node to examine
      * @returns {void}
      * @private
      */
@@ -351,6 +367,7 @@ module.exports = {
         }
       }
 
+      /** @type {Range} */
       let scriptLinesRange
       if (scriptTokens.length) {
         if (scriptComments.length) {
@@ -458,7 +475,7 @@ module.exports = {
         if (commentsByLine[lineNumber]) {
           const commentList = [...commentsByLine[lineNumber]]
 
-          let comment = commentList.pop()
+          let comment = commentList.pop() || null
 
           if (isFullLineComment(line, lineNumber, comment)) {
             lineIsComment = true
@@ -470,7 +487,7 @@ module.exports = {
             textToMeasure = stripTrailingComment(line, comment)
 
             // ignore multiple trailing comments in the same line
-            comment = commentList.pop()
+            comment = commentList.pop() || null
 
             while (isTrailingComment(textToMeasure, lineNumber, comment)) {
               textToMeasure = stripTrailingComment(textToMeasure, comment)
@@ -527,19 +544,18 @@ module.exports = {
     // Public API
     // --------------------------------------------------------------------------
 
-    const bodyVisitor = utils.defineTemplateBodyVisitor(context, {
-      'VAttribute[directive=false] > VLiteral'(node) {
-        htmlAttributeValues.push(node)
-      }
-    })
-
-    return Object.assign({}, bodyVisitor, {
-      'Program:exit'(node) {
-        if (bodyVisitor['Program:exit']) {
-          bodyVisitor['Program:exit'](node)
+    return utils.compositingVisitors(
+      utils.defineTemplateBodyVisitor(context, {
+        /** @param {VLiteral} node */
+        'VAttribute[directive=false] > VLiteral'(node) {
+          htmlAttributeValues.push(node)
+        }
+      }),
+      {
+        'Program:exit'(node) {
+          checkProgramForMaxLength(node)
         }
-        checkProgramForMaxLength(node)
       }
-    })
+    )
   }
 }
diff --git a/lib/rules/multiline-html-element-content-newline.js b/lib/rules/multiline-html-element-content-newline.js
index b2332ae5d..49a675c4b 100644
--- a/lib/rules/multiline-html-element-content-newline.js
+++ b/lib/rules/multiline-html-element-content-newline.js
@@ -16,10 +16,16 @@ const INLINE_ELEMENTS = require('../utils/inline-non-void-elements.json')
 // Helpers
 // ------------------------------------------------------------------------------
 
+/**
+ * @param {VElement & { endTag: VEndTag }} element
+ */
 function isMultilineElement(element) {
   return element.loc.start.line < element.endTag.loc.start.line
 }
 
+/**
+ * @param {any} options
+ */
 function parseOptions(options) {
   return Object.assign(
     {
@@ -31,6 +37,9 @@ function parseOptions(options) {
   )
 }
 
+/**
+ * @param {number} lineBreaks
+ */
 function getPhrase(lineBreaks) {
   switch (lineBreaks) {
     case 0:
@@ -42,7 +51,7 @@ function getPhrase(lineBreaks) {
 /**
  * Check whether the given element is empty or not.
  * This ignores whitespaces, doesn't ignore comments.
- * @param {VElement} node The element node to check.
+ * @param {VElement & { endTag: VEndTag }} node The element node to check.
  * @param {SourceCode} sourceCode The source code object of the current context.
  * @returns {boolean} `true` if the element is empty.
  */
@@ -94,7 +103,7 @@ module.exports = {
         'Expected 1 line break before closing tag (`</{{name}}>`), but {{actual}} line breaks found.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = parseOptions(context.options[0])
     const ignores = options.ignores
@@ -105,8 +114,12 @@ module.exports = {
       context.parserServices.getTemplateBodyTokenStore()
     const sourceCode = context.getSourceCode()
 
-    let inIgnoreElement
+    /** @type {VElement | null} */
+    let inIgnoreElement = null
 
+    /**
+     * @param {VElement} node
+     */
     function isIgnoredElement(node) {
       return (
         ignores.includes(node.name) ||
@@ -115,6 +128,9 @@ module.exports = {
       )
     }
 
+    /**
+     * @param {number} lineBreaks
+     */
     function isInvalidLineBreaks(lineBreaks) {
       if (allowEmptyLines) {
         return lineBreaks === 0
@@ -138,73 +154,83 @@ module.exports = {
           return
         }
 
-        if (!isMultilineElement(node)) {
+        const element = /** @type {VElement & { endTag: VEndTag }} */ (node)
+
+        if (!isMultilineElement(element)) {
           return
         }
 
+        /**
+         * @type {SourceCode.CursorWithCountOptions}
+         */
         const getTokenOption = {
           includeComments: true,
           filter: (token) => token.type !== 'HTMLWhitespace'
         }
         if (
           ignoreWhenEmpty &&
-          node.children.length === 0 &&
+          element.children.length === 0 &&
           template.getFirstTokensBetween(
-            node.startTag,
-            node.endTag,
+            element.startTag,
+            element.endTag,
             getTokenOption
           ).length === 0
         ) {
           return
         }
 
-        const contentFirst = template.getTokenAfter(
-          node.startTag,
+        const contentFirst = /** @type {Token} */ (template.getTokenAfter(
+          element.startTag,
+          getTokenOption
+        ))
+        const contentLast = /** @type {Token} */ (template.getTokenBefore(
+          element.endTag,
           getTokenOption
-        )
-        const contentLast = template.getTokenBefore(node.endTag, getTokenOption)
+        ))
 
         const beforeLineBreaks =
-          contentFirst.loc.start.line - node.startTag.loc.end.line
+          contentFirst.loc.start.line - element.startTag.loc.end.line
         const afterLineBreaks =
-          node.endTag.loc.start.line - contentLast.loc.end.line
+          element.endTag.loc.start.line - contentLast.loc.end.line
         if (isInvalidLineBreaks(beforeLineBreaks)) {
           context.report({
-            node: template.getLastToken(node.startTag),
+            node: template.getLastToken(element.startTag),
             loc: {
-              start: node.startTag.loc.end,
+              start: element.startTag.loc.end,
               end: contentFirst.loc.start
             },
             messageId: 'unexpectedAfterClosingBracket',
             data: {
-              name: node.rawName,
+              name: element.rawName,
               actual: getPhrase(beforeLineBreaks)
             },
             fix(fixer) {
-              const range = [node.startTag.range[1], contentFirst.range[0]]
+              /** @type {Range} */
+              const range = [element.startTag.range[1], contentFirst.range[0]]
               return fixer.replaceTextRange(range, '\n')
             }
           })
         }
 
-        if (isEmpty(node, sourceCode)) {
+        if (isEmpty(element, sourceCode)) {
           return
         }
 
         if (isInvalidLineBreaks(afterLineBreaks)) {
           context.report({
-            node: template.getFirstToken(node.endTag),
+            node: template.getFirstToken(element.endTag),
             loc: {
               start: contentLast.loc.end,
-              end: node.endTag.loc.start
+              end: element.endTag.loc.start
             },
             messageId: 'unexpectedBeforeOpeningBracket',
             data: {
-              name: node.name,
+              name: element.name,
               actual: getPhrase(afterLineBreaks)
             },
             fix(fixer) {
-              const range = [contentLast.range[1], node.endTag.range[0]]
+              /** @type {Range} */
+              const range = [contentLast.range[1], element.endTag.range[0]]
               return fixer.replaceTextRange(range, '\n')
             }
           })
diff --git a/lib/rules/mustache-interpolation-spacing.js b/lib/rules/mustache-interpolation-spacing.js
index 83fb7886c..8522c8ad9 100644
--- a/lib/rules/mustache-interpolation-spacing.js
+++ b/lib/rules/mustache-interpolation-spacing.js
@@ -29,7 +29,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || 'always'
     const template =
@@ -41,6 +41,7 @@ module.exports = {
     // ----------------------------------------------------------------------
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VExpressionContainer} node */
       'VExpressionContainer[expression!=null]'(node) {
         const openBrace = template.getFirstToken(node)
         const closeBrace = template.getLastToken(node)
diff --git a/lib/rules/name-property-casing.js b/lib/rules/name-property-casing.js
index 6e5a52190..d86435a95 100644
--- a/lib/rules/name-property-casing.js
+++ b/lib/rules/name-property-casing.js
@@ -30,7 +30,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0]
     const caseType =
@@ -41,28 +41,28 @@ module.exports = {
     // ----------------------------------------------------------------------
 
     return utils.executeOnVue(context, (obj) => {
-      const node = obj.properties.find(
-        (item) =>
-          item.type === 'Property' &&
-          item.key.name === 'name' &&
-          item.value.type === 'Literal'
-      )
+      const node = utils.findProperty(obj, 'name')
 
       if (!node) return
+      const valueNode = node.value
+      if (valueNode.type !== 'Literal') return
 
-      if (!casing.getChecker(caseType)(node.value.value)) {
-        const value = casing.getExactConverter(caseType)(node.value.value)
+      if (!casing.getChecker(caseType)(`${valueNode.value}`)) {
+        const value = casing.getExactConverter(caseType)(`${valueNode.value}`)
         context.report({
-          node: node.value,
+          node: valueNode,
           message: 'Property name "{{value}}" is not {{caseType}}.',
           data: {
-            value: node.value.value,
+            value: `${valueNode.value}`,
             caseType
           },
           fix: (fixer) =>
             fixer.replaceText(
-              node.value,
-              node.value.raw.replace(node.value.value, value)
+              valueNode,
+              context
+                .getSourceCode()
+                .getText(valueNode)
+                .replace(`${valueNode.value}`, value)
             )
         })
       }
diff --git a/lib/rules/no-arrow-functions-in-watch.js b/lib/rules/no-arrow-functions-in-watch.js
index 2fce3f87f..77bb6787e 100644
--- a/lib/rules/no-arrow-functions-in-watch.js
+++ b/lib/rules/no-arrow-functions-in-watch.js
@@ -16,11 +16,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
+  /** @param {RuleContext} context */
   create(context) {
     return utils.executeOnVue(context, (obj) => {
-      const watchNode = obj.properties.find(
-        (property) => utils.getStaticPropertyName(property) === 'watch'
-      )
+      const watchNode = utils.findProperty(obj, 'watch')
       if (watchNode == null) {
         return
       }
diff --git a/lib/rules/no-async-in-computed-properties.js b/lib/rules/no-async-in-computed-properties.js
index 34849d1c6..e3080d7d5 100644
--- a/lib/rules/no-async-in-computed-properties.js
+++ b/lib/rules/no-async-in-computed-properties.js
@@ -6,6 +6,11 @@
 
 const utils = require('../utils')
 
+/**
+ * @typedef {import('../utils').VueObjectData} VueObjectData
+ * @typedef {import('../utils').ComponentComputedProperty} ComponentComputedProperty
+ */
+
 const PROMISE_FUNCTIONS = ['then', 'catch', 'finally']
 
 const PROMISE_METHODS = ['all', 'race', 'reject', 'resolve']
@@ -17,6 +22,9 @@ const TIMED_FUNCTIONS = [
   'requestAnimationFrame'
 ]
 
+/**
+ * @param {CallExpression} node
+ */
 function isTimedFunction(node) {
   return (
     ((node.type === 'CallExpression' &&
@@ -26,11 +34,15 @@ function isTimedFunction(node) {
         node.callee.type === 'MemberExpression' &&
         node.callee.object.type === 'Identifier' &&
         node.callee.object.name === 'window' &&
+        node.callee.property.type === 'Identifier' &&
         TIMED_FUNCTIONS.indexOf(node.callee.property.name) !== -1)) &&
     node.arguments.length
   )
 }
 
+/**
+ * @param {CallExpression} node
+ */
 function isPromise(node) {
   if (
     node.type === 'CallExpression' &&
@@ -42,6 +54,7 @@ function isPromise(node) {
         PROMISE_FUNCTIONS.indexOf(node.callee.property.name) !== -1) || // Promise.PROMISE_METHOD()
       (node.callee.object.type === 'Identifier' &&
         node.callee.object.name === 'Promise' &&
+        node.callee.property.type === 'Identifier' &&
         PROMISE_METHODS.indexOf(node.callee.property.name) !== -1)
     )
   }
@@ -63,10 +76,17 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} upper
+     * @property {BlockStatement | Expression} body
+     */
+    /** @type {Map<ObjectExpression, ComponentComputedProperty[]>} */
     const computedPropertiesMap = new Map()
-    let scopeStack = { upper: null, body: null }
+    /** @type {ScopeStack} */
+    let scopeStack
 
     const expressionTypes = {
       promise: 'asynchronous action',
@@ -76,6 +96,10 @@ module.exports = {
       timed: 'timed function'
     }
 
+    /**
+     * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
+     * @param {VueObjectData} data
+     */
     function onFunctionEnter(node, { node: vueNode }) {
       if (node.async) {
         verify(node, node.body, 'async', computedPropertiesMap.get(vueNode))
@@ -88,7 +112,13 @@ module.exports = {
       scopeStack = scopeStack.upper
     }
 
-    function verify(node, targetBody, type, computedProperties) {
+    /**
+     * @param {ESNode} node
+     * @param {BlockStatement | Expression} targetBody
+     * @param {keyof expressionTypes} type
+     * @param {ComponentComputedProperty[]} computedProperties
+     */
+    function verify(node, targetBody, type, computedProperties = []) {
       computedProperties.forEach((cp) => {
         if (
           cp.value &&
@@ -102,7 +132,7 @@ module.exports = {
               'Unexpected {{expressionName}} in "{{propertyName}}" computed property.',
             data: {
               expressionName: expressionTypes[type],
-              propertyName: cp.key
+              propertyName: cp.key || 'unknown'
             }
           })
         }
@@ -116,7 +146,10 @@ module.exports = {
       ':function:exit': onFunctionExit,
 
       NewExpression(node, { node: vueNode }) {
-        if (node.callee.name === 'Promise') {
+        if (
+          node.callee.type === 'Identifier' &&
+          node.callee.name === 'Promise'
+        ) {
           verify(
             node,
             scopeStack.body,
diff --git a/lib/rules/no-bare-strings-in-template.js b/lib/rules/no-bare-strings-in-template.js
index 8fea1625c..d0426e3a5 100644
--- a/lib/rules/no-bare-strings-in-template.js
+++ b/lib/rules/no-bare-strings-in-template.js
@@ -12,18 +12,8 @@ const utils = require('../utils')
 const regexp = require('../utils/regexp')
 const casing = require('../utils/casing')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.VAttribute} VAttribute
- * @typedef {import('vue-eslint-parser').AST.VDirective} VDirective
- * @typedef {import('vue-eslint-parser').AST.VElement} VElement
- * @typedef {import('vue-eslint-parser').AST.VIdentifier} VIdentifier
- * @typedef {import('vue-eslint-parser').AST.VExpressionContainer} VExpressionContainer
- * @typedef {import('vue-eslint-parser').AST.VText} VText
- */
-
 /**
  * @typedef { { names: { [tagName in string]: Set<string> }, regexps: { name: RegExp, attrs: Set<string> }[], cache: { [tagName in string]: Set<string> } } } TargetAttrs
- * @typedef { { upper: ElementStack, name: string, attrs: Set<string> } } ElementStack
  */
 
 // ------------------------------------------------------------------------------
@@ -82,6 +72,7 @@ const DEFAULT_DIRECTIVES = ['v-text']
 
 /**
  * Parse attributes option
+ * @param {any} options
  * @returns {TargetAttrs}
  */
 function parseTargetAttrs(options) {
@@ -104,7 +95,7 @@ function parseTargetAttrs(options) {
 
 /**
  * Get a string from given expression container node
- * @param {VExpressionContainer} node
+ * @param {VExpressionContainer} value
  * @returns { string | null }
  */
 function getStringValue(value) {
@@ -166,8 +157,13 @@ module.exports = {
       unexpectedInAttr: 'Unexpected non-translated string used in `{{attr}}`.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
+    /**
+     * @typedef { { upper: ElementStack, name: string, attrs: Set<string> } } ElementStack
+     */
     const opts = context.options[0] || {}
+    /** @type {string[]} */
     const whitelist = opts.whitelist || DEFAULT_WHITELIST
     const attributes = parseTargetAttrs(opts.attributes || DEFAULT_ATTRIBUTES)
     const directives = opts.directives || DEFAULT_DIRECTIVES
@@ -177,8 +173,8 @@ module.exports = {
       'gu'
     )
 
-    /** @type {ElementStack | null} */
-    let elementStack = null
+    /** @type {ElementStack} */
+    let elementStack
     /**
      * Gets the bare string from given string
      * @param {string} str
diff --git a/lib/rules/no-boolean-default.js b/lib/rules/no-boolean-default.js
index 1f1e192df..e278e3011 100644
--- a/lib/rules/no-boolean-default.js
+++ b/lib/rules/no-boolean-default.js
@@ -6,10 +6,18 @@
 
 const utils = require('../utils')
 
+/**
+ * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
+ * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ */
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
+/**
+ * @param {Property | SpreadElement} prop
+ */
 function isBooleanProp(prop) {
   return (
     prop.type === 'Property' &&
@@ -20,23 +28,32 @@ function isBooleanProp(prop) {
   )
 }
 
+/**
+ * @typedef {ComponentObjectProp & { value : ObjectExpression }} ObjectExpressionProp
+ */
+
+/**
+ * @param {(ComponentArrayProp | ComponentObjectProp)[]} props
+ * @returns {ObjectExpressionProp[]}
+ */
 function getBooleanProps(props) {
   return props.filter(
+    /**
+     * @param {ComponentArrayProp | ComponentObjectProp} prop
+     * @returns {prop is ObjectExpressionProp}
+     */
     (prop) =>
-      prop.value &&
-      prop.value.properties &&
-      prop.value.properties.find(isBooleanProp)
+      prop.value != null &&
+      prop.value.type === 'ObjectExpression' &&
+      prop.value.properties.some(isBooleanProp)
   )
 }
 
+/**
+ * @param {ObjectExpressionProp} propDef
+ */
 function getDefaultNode(propDef) {
-  return propDef.value.properties.find((p) => {
-    return (
-      p.type === 'Property' &&
-      p.key.type === 'Identifier' &&
-      p.key.name === 'default'
-    )
-  })
+  return utils.findProperty(propDef.value, 'default')
 }
 
 module.exports = {
@@ -54,7 +71,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.executeOnVueComponent(context, (obj) => {
       const props = utils.getComponentProps(obj)
@@ -66,20 +83,24 @@ module.exports = {
 
       booleanProps.forEach((propDef) => {
         const defaultNode = getDefaultNode(propDef)
+        if (!defaultNode) {
+          return
+        }
 
         switch (booleanType) {
           case 'no-default':
-            if (defaultNode) {
-              context.report({
-                node: defaultNode,
-                message:
-                  'Boolean prop should not set a default (Vue defaults it to false).'
-              })
-            }
+            context.report({
+              node: defaultNode,
+              message:
+                'Boolean prop should not set a default (Vue defaults it to false).'
+            })
             break
 
           case 'default-false':
-            if (defaultNode && defaultNode.value.value !== false) {
+            if (
+              defaultNode.value.type !== 'Literal' ||
+              defaultNode.value.value !== false
+            ) {
               context.report({
                 node: defaultNode,
                 message: 'Boolean prop should only be defaulted to false.'
diff --git a/lib/rules/no-confusing-v-for-v-if.js b/lib/rules/no-confusing-v-for-v-if.js
index 43951a090..4135f163a 100644
--- a/lib/rules/no-confusing-v-for-v-if.js
+++ b/lib/rules/no-confusing-v-for-v-if.js
@@ -17,16 +17,19 @@ const utils = require('../utils')
 
 /**
  * Check whether the given `v-if` node is using the variable which is defined by the `v-for` directive.
- * @param {ASTNode} vIf The `v-if` attribute node to check.
+ * @param {VDirective} vIf The `v-if` attribute node to check.
  * @returns {boolean} `true` if the `v-if` is using the variable which is defined by the `v-for` directive.
  */
 function isUsingIterationVar(vIf) {
   const element = vIf.parent.parent
-  return vIf.value.references.some((reference) =>
-    element.variables.some(
-      (variable) =>
-        variable.id.name === reference.id.name && variable.kind === 'v-for'
-    )
+  return Boolean(
+    vIf.value &&
+      vIf.value.references.some((reference) =>
+        element.variables.some(
+          (variable) =>
+            variable.id.name === reference.id.name && variable.kind === 'v-for'
+        )
+      )
   )
 }
 
@@ -47,7 +50,7 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
       "VAttribute[directive=true][key.name.name='if']"(node) {
diff --git a/lib/rules/no-custom-modifiers-on-v-model.js b/lib/rules/no-custom-modifiers-on-v-model.js
index ea80fb7a6..6670be1da 100644
--- a/lib/rules/no-custom-modifiers-on-v-model.js
+++ b/lib/rules/no-custom-modifiers-on-v-model.js
@@ -35,6 +35,7 @@ module.exports = {
         "'v-model' directives don't support the modifier '{{name}}'."
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
       "VAttribute[directive=true][key.name.name='model']"(node) {
diff --git a/lib/rules/no-deprecated-data-object-declaration.js b/lib/rules/no-deprecated-data-object-declaration.js
index 02422c7e5..37d280ef6 100644
--- a/lib/rules/no-deprecated-data-object-declaration.js
+++ b/lib/rules/no-deprecated-data-object-declaration.js
@@ -10,14 +10,20 @@
 
 const utils = require('../utils')
 
+/** @param {Token} token */
 function isOpenParen(token) {
   return token.type === 'Punctuator' && token.value === '('
 }
 
+/** @param {Token} token */
 function isCloseParen(token) {
   return token.type === 'Punctuator' && token.value === ')'
 }
 
+/**
+ * @param {Expression} node
+ * @param {SourceCode} sourceCode
+ */
 function getFirstAndLastTokens(node, sourceCode) {
   let first = sourceCode.getFirstToken(node)
   let last = sourceCode.getLastToken(node)
@@ -56,35 +62,34 @@ module.exports = {
         "Object declaration on 'data' property is deprecated. Using function declaration instead."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
 
     return utils.executeOnVue(context, (obj) => {
-      obj.properties
-        .filter(
-          (p) =>
-            p.type === 'Property' &&
-            p.key.type === 'Identifier' &&
-            p.key.name === 'data' &&
-            p.value.type !== 'FunctionExpression' &&
-            p.value.type !== 'ArrowFunctionExpression' &&
-            p.value.type !== 'Identifier'
-        )
-        .forEach((p) => {
-          context.report({
-            node: p,
-            messageId: 'objectDeclarationIsDeprecated',
-            fix(fixer) {
-              const tokens = getFirstAndLastTokens(p.value, sourceCode)
+      const invalidData = utils.findProperty(
+        obj,
+        'data',
+        (p) =>
+          p.value.type !== 'FunctionExpression' &&
+          p.value.type !== 'ArrowFunctionExpression' &&
+          p.value.type !== 'Identifier'
+      )
+
+      if (invalidData) {
+        context.report({
+          node: invalidData,
+          messageId: 'objectDeclarationIsDeprecated',
+          fix(fixer) {
+            const tokens = getFirstAndLastTokens(invalidData.value, sourceCode)
 
-              return [
-                fixer.insertTextBefore(tokens.first, 'function() {\nreturn '),
-                fixer.insertTextAfter(tokens.last, ';\n}')
-              ]
-            }
-          })
+            return [
+              fixer.insertTextBefore(tokens.first, 'function() {\nreturn '),
+              fixer.insertTextAfter(tokens.last, ';\n}')
+            ]
+          }
         })
+      }
     })
   }
 }
diff --git a/lib/rules/no-deprecated-dollar-listeners-api.js b/lib/rules/no-deprecated-dollar-listeners-api.js
index 7c60cbbe5..97d98359c 100644
--- a/lib/rules/no-deprecated-dollar-listeners-api.js
+++ b/lib/rules/no-deprecated-dollar-listeners-api.js
@@ -29,7 +29,7 @@ module.exports = {
       deprecated: 'The `$listeners` is deprecated.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(
       context,
diff --git a/lib/rules/no-deprecated-dollar-scopedslots-api.js b/lib/rules/no-deprecated-dollar-scopedslots-api.js
index f369c70ff..bdfa0f844 100644
--- a/lib/rules/no-deprecated-dollar-scopedslots-api.js
+++ b/lib/rules/no-deprecated-dollar-scopedslots-api.js
@@ -30,7 +30,7 @@ module.exports = {
       deprecated: 'The `$scopedSlots` is deprecated.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(
       context,
diff --git a/lib/rules/no-deprecated-events-api.js b/lib/rules/no-deprecated-events-api.js
index 05d50bac1..a09f36bf0 100644
--- a/lib/rules/no-deprecated-events-api.js
+++ b/lib/rules/no-deprecated-events-api.js
@@ -29,9 +29,10 @@ module.exports = {
         'The Events api `$on`, `$off` `$once` is deprecated. Using external library instead, for example mitt.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineVueVisitor(context, {
+      /** @param {MemberExpression & {parent: CallExpression}} node */
       'CallExpression > MemberExpression'(node) {
         const call = node.parent
         if (
diff --git a/lib/rules/no-deprecated-filter.js b/lib/rules/no-deprecated-filter.js
index 0229d6e2e..87b61a5b3 100644
--- a/lib/rules/no-deprecated-filter.js
+++ b/lib/rules/no-deprecated-filter.js
@@ -29,7 +29,7 @@ module.exports = {
       noDeprecatedFilter: 'Filters are deprecated.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
       VFilterSequenceExpression(node) {
diff --git a/lib/rules/no-deprecated-functional-template.js b/lib/rules/no-deprecated-functional-template.js
index cfaa8d957..e489841b0 100644
--- a/lib/rules/no-deprecated-functional-template.js
+++ b/lib/rules/no-deprecated-functional-template.js
@@ -30,7 +30,10 @@ module.exports = {
       unexpected: 'The `functional` template are deprecated.'
     }
   },
-
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     return {
       Program(program) {
diff --git a/lib/rules/no-deprecated-html-element-is.js b/lib/rules/no-deprecated-html-element-is.js
index d62c3b479..e07f493a5 100644
--- a/lib/rules/no-deprecated-html-element-is.js
+++ b/lib/rules/no-deprecated-html-element-is.js
@@ -29,9 +29,10 @@ module.exports = {
       unexpected: 'The `is` attribute on HTML element are deprecated.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective | VAttribute} node */
       "VAttribute[directive=true][key.name.name='bind'][key.argument.name='is'], VAttribute[directive=false][key.name='is']"(
         node
       ) {
diff --git a/lib/rules/no-deprecated-inline-template.js b/lib/rules/no-deprecated-inline-template.js
index 69bdfda46..647121638 100644
--- a/lib/rules/no-deprecated-inline-template.js
+++ b/lib/rules/no-deprecated-inline-template.js
@@ -29,9 +29,10 @@ module.exports = {
       unexpected: '`inline-template` are deprecated.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VIdentifier} node */
       "VAttribute[directive=false] > VIdentifier[rawName='inline-template']"(
         node
       ) {
diff --git a/lib/rules/no-deprecated-scope-attribute.js b/lib/rules/no-deprecated-scope-attribute.js
index 24ef41042..e7e22c3d3 100644
--- a/lib/rules/no-deprecated-scope-attribute.js
+++ b/lib/rules/no-deprecated-scope-attribute.js
@@ -21,6 +21,7 @@ module.exports = {
       forbiddenScopeAttribute: '`scope` attributes are deprecated.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     const templateBodyVisitor = scopeAttribute.createTemplateBodyVisitor(
       context
diff --git a/lib/rules/no-deprecated-slot-attribute.js b/lib/rules/no-deprecated-slot-attribute.js
index c7174c12a..6459cdff4 100644
--- a/lib/rules/no-deprecated-slot-attribute.js
+++ b/lib/rules/no-deprecated-slot-attribute.js
@@ -21,6 +21,7 @@ module.exports = {
       forbiddenSlotAttribute: '`slot` attributes are deprecated.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     const templateBodyVisitor = slotAttribute.createTemplateBodyVisitor(context)
     return utils.defineTemplateBodyVisitor(context, templateBodyVisitor)
diff --git a/lib/rules/no-deprecated-slot-scope-attribute.js b/lib/rules/no-deprecated-slot-scope-attribute.js
index 1356016ed..793b1ed6d 100644
--- a/lib/rules/no-deprecated-slot-scope-attribute.js
+++ b/lib/rules/no-deprecated-slot-scope-attribute.js
@@ -23,6 +23,7 @@ module.exports = {
       forbiddenSlotScopeAttribute: '`slot-scope` are deprecated.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     const templateBodyVisitor = slotScopeAttribute.createTemplateBodyVisitor(
       context,
diff --git a/lib/rules/no-deprecated-v-bind-sync.js b/lib/rules/no-deprecated-v-bind-sync.js
index b84ebf4de..97dfe51bd 100644
--- a/lib/rules/no-deprecated-v-bind-sync.js
+++ b/lib/rules/no-deprecated-v-bind-sync.js
@@ -30,6 +30,7 @@ module.exports = {
         "'.sync' modifier on 'v-bind' directive is deprecated. Use 'v-model:propName' instead."
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
       "VAttribute[directive=true][key.name.name='bind']"(node) {
@@ -39,10 +40,13 @@ module.exports = {
             loc: node.loc,
             messageId: 'syncModifierIsDeprecated',
             fix: (fixer) => {
-              const isUsingSpreadSyntax = node.key.argument == null
-              const hasMultipleModifiers = node.key.modifiers.length > 1
-              if (isUsingSpreadSyntax || hasMultipleModifiers) {
-                return
+              if (node.key.argument == null) {
+                // is using spread syntax
+                return null
+              }
+              if (node.key.modifiers.length > 1) {
+                // has multiple modifiers
+                return null
               }
 
               const bindArgument = context
diff --git a/lib/rules/no-deprecated-v-on-native-modifier.js b/lib/rules/no-deprecated-v-on-native-modifier.js
index 16f1987c5..4f60210b0 100644
--- a/lib/rules/no-deprecated-v-on-native-modifier.js
+++ b/lib/rules/no-deprecated-v-on-native-modifier.js
@@ -30,9 +30,10 @@ module.exports = {
       deprecated: "'.native' modifier on 'v-on' directive is deprecated."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VIdentifier & {parent:VDirectiveKey} } node */
       "VAttribute[directive=true][key.name.name='on'] > VDirectiveKey > VIdentifier[name='native']"(
         node
       ) {
diff --git a/lib/rules/no-deprecated-v-on-number-modifiers.js b/lib/rules/no-deprecated-v-on-number-modifiers.js
index bf1fb88bd..544c1ee9f 100644
--- a/lib/rules/no-deprecated-v-on-number-modifiers.js
+++ b/lib/rules/no-deprecated-v-on-number-modifiers.js
@@ -32,9 +32,10 @@ module.exports = {
         "'KeyboardEvent.keyCode' modifier on 'v-on' directive is deprecated. Using 'KeyboardEvent.key' instead."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirectiveKey} node */
       "VAttribute[directive=true][key.name.name='on'] > VDirectiveKey"(node) {
         const modifier = node.modifiers.find((mod) =>
           Number.isInteger(parseInt(mod.name, 10))
@@ -48,7 +49,7 @@ module.exports = {
             messageId: 'numberModifierIsDeprecated',
             fix: (fixer) => {
               const key = keyCodeToKey[keyCodes]
-              if (!key) return
+              if (!key) return null
 
               return fixer.replaceText(modifier, `${key}`)
             }
diff --git a/lib/rules/no-deprecated-vue-config-keycodes.js b/lib/rules/no-deprecated-vue-config-keycodes.js
index 0de109ef1..b30db3fed 100644
--- a/lib/rules/no-deprecated-vue-config-keycodes.js
+++ b/lib/rules/no-deprecated-vue-config-keycodes.js
@@ -24,9 +24,10 @@ module.exports = {
       unexpected: '`Vue.config.keyCodes` are deprecated.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return {
+      /** @param {MemberExpression} node */
       "MemberExpression[property.type='Identifier'][property.name='keyCodes']"(
         node
       ) {
diff --git a/lib/rules/no-dupe-keys.js b/lib/rules/no-dupe-keys.js
index dfbebdedf..8b5e8e54c 100644
--- a/lib/rules/no-dupe-keys.js
+++ b/lib/rules/no-dupe-keys.js
@@ -6,10 +6,14 @@
 
 const utils = require('../utils')
 
+/**
+ * @typedef {import('../utils').GroupName} GroupName
+ */
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
-
+/** @type {GroupName[]} */
 const GROUP_NAMES = ['props', 'computed', 'data', 'methods', 'setup']
 
 module.exports = {
@@ -33,7 +37,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const groups = new Set(GROUP_NAMES.concat(options.groups || []))
diff --git a/lib/rules/no-duplicate-attr-inheritance.js b/lib/rules/no-duplicate-attr-inheritance.js
index 78e00b326..08426c352 100644
--- a/lib/rules/no-duplicate-attr-inheritance.js
+++ b/lib/rules/no-duplicate-attr-inheritance.js
@@ -25,23 +25,21 @@ module.exports = {
       // fill in your schema
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
+    /** @type {string | number | boolean | RegExp | BigInt | null} */
     let inheritsAttrs = true
 
     return Object.assign(
       utils.executeOnVue(context, (node) => {
-        const inheritAttrsProp = node.properties.find(
-          (prop) =>
-            prop.type === 'Property' &&
-            utils.getStaticPropertyName(prop) === 'inheritAttrs'
-        )
+        const inheritAttrsProp = utils.findProperty(node, 'inheritAttrs')
 
         if (inheritAttrsProp && inheritAttrsProp.value.type === 'Literal') {
           inheritsAttrs = inheritAttrsProp.value.value
         }
       }),
       utils.defineTemplateBodyVisitor(context, {
+        /** @param {VExpressionContainer} node */
         "VAttribute[directive=true][key.name.name='bind'][key.argument=null] > VExpressionContainer"(
           node
         ) {
diff --git a/lib/rules/no-duplicate-attributes.js b/lib/rules/no-duplicate-attributes.js
index 023dacf42..83cc52d83 100644
--- a/lib/rules/no-duplicate-attributes.js
+++ b/lib/rules/no-duplicate-attributes.js
@@ -17,15 +17,20 @@ const utils = require('../utils')
 
 /**
  * Get the name of the given attribute node.
- * @param {ASTNode} attribute The attribute node to get.
- * @returns {string} The name of the attribute.
+ * @param {VAttribute | VDirective} attribute The attribute node to get.
+ * @returns {string | null} The name of the attribute.
  */
 function getName(attribute) {
   if (!attribute.directive) {
     return attribute.key.name
   }
   if (attribute.key.name.name === 'bind') {
-    return (attribute.key.argument && attribute.key.argument.name) || null
+    return (
+      (attribute.key.argument &&
+        attribute.key.argument.type === 'VIdentifier' &&
+        attribute.key.argument.name) ||
+      null
+    )
   }
   return null
 }
@@ -58,15 +63,21 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const allowCoexistStyle = options.allowCoexistStyle !== false
     const allowCoexistClass = options.allowCoexistClass !== false
 
+    /** @type {Set<string>} */
     const directiveNames = new Set()
+    /** @type {Set<string>} */
     const attributeNames = new Set()
 
+    /**
+     * @param {string} name
+     * @param {boolean} isDirective
+     */
     function isDuplicate(name, isDirective) {
       if (
         (allowCoexistStyle && name === 'style') ||
diff --git a/lib/rules/no-empty-pattern.js b/lib/rules/no-empty-pattern.js
index daa5b1c26..2d8223876 100644
--- a/lib/rules/no-empty-pattern.js
+++ b/lib/rules/no-empty-pattern.js
@@ -5,5 +5,5 @@
 
 const { wrapCoreRule } = require('../utils')
 
-// eslint-disable-next-line
+// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
 module.exports = wrapCoreRule(require('eslint/lib/rules/no-empty-pattern'))
diff --git a/lib/rules/no-extra-parens.js b/lib/rules/no-extra-parens.js
index 4cc865a5b..3e04f193e 100644
--- a/lib/rules/no-extra-parens.js
+++ b/lib/rules/no-extra-parens.js
@@ -12,13 +12,6 @@ module.exports = wrapCoreRule(require('eslint/lib/rules/no-extra-parens'), {
   create: createForVueSyntax
 })
 
-/**
- * @typedef {import('vue-eslint-parser').AST.Token} Token
- * @typedef {import('vue-eslint-parser').AST.ESLintExpression} Expression
- * @typedef {import('vue-eslint-parser').AST.VExpressionContainer} VExpressionContainer
- * @typedef {import('vue-eslint-parser').AST.VFilterSequenceExpression} VFilterSequenceExpression
- */
-
 /**
  * Check whether the given token is a left parenthesis.
  * @param {Token} token The token to check.
@@ -75,8 +68,8 @@ function isRightBracket(token) {
 
 /**
  * Determines if a given expression node is an IIFE
- * @param {ASTNode} node The node to check
- * @returns {boolean} `true` if the given node is an IIFE
+ * @param {Expression} node The node to check
+ * @returns {node is CallExpression & { callee: FunctionExpression } } `true` if the given node is an IIFE
  */
 function isIIFE(node) {
   return (
@@ -84,14 +77,19 @@ function isIIFE(node) {
   )
 }
 
+/**
+ * @param {RuleContext} context - The rule context.
+ * @returns {TemplateListener} AST event handlers.
+ */
 function createForVueSyntax(context) {
-  const tokenStore =
-    context.parserServices.getTemplateBodyTokenStore &&
-    context.parserServices.getTemplateBodyTokenStore()
+  if (!context.parserServices.getTemplateBodyTokenStore) {
+    return {}
+  }
+  const tokenStore = context.parserServices.getTemplateBodyTokenStore()
 
   /**
    * Checks if the given node turns into a filter when unwraped.
-   * @param {Expression} node node to evaluate
+   * @param {Expression} expression node to evaluate
    * @returns {boolean} `true` if the given node turns into a filter when unwraped.
    */
   function isUnwrapChangeToFilter(expression) {
@@ -118,17 +116,17 @@ function createForVueSyntax(context) {
     return false
   }
   /**
-   * @param {VExpressionContainer} node
+   * @param {VExpressionContainer & { expression: Expression | VFilterSequenceExpression | null }} node
    */
   function verify(node) {
-    let expression = node.expression
-    if (!expression) {
+    if (!node.expression) {
       return
     }
 
-    if (expression.type === 'VFilterSequenceExpression') {
-      expression = expression.expression
-    }
+    const expression =
+      node.expression.type === 'VFilterSequenceExpression'
+        ? node.expression.expression
+        : node.expression
 
     if (!isParenthesized(expression, tokenStore)) {
       return
diff --git a/lib/rules/no-irregular-whitespace.js b/lib/rules/no-irregular-whitespace.js
index babd2d6e1..7c05083b3 100644
--- a/lib/rules/no-irregular-whitespace.js
+++ b/lib/rules/no-irregular-whitespace.js
@@ -71,9 +71,13 @@ module.exports = {
       disallow: 'Irregular whitespace not allowed.'
     }
   },
-
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     // Module store of error indexes that we have found
+    /** @type {number[]} */
     let errorIndexes = []
 
     // Lookup the `skipComments` option, which defaults to `false`.
@@ -89,7 +93,7 @@ module.exports = {
 
     /**
      * Removes errors that occur inside a string node
-     * @param {ASTNode} node to check for matching errors.
+     * @param {ASTNode | Token} node to check for matching errors.
      * @returns {void}
      * @private
      */
@@ -103,7 +107,7 @@ module.exports = {
 
     /**
      * Checks literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {ASTNode} node to check for matching errors.
+     * @param {Literal} node to check for matching errors.
      * @returns {void}
      * @private
      */
@@ -113,7 +117,7 @@ module.exports = {
 
       if (shouldCheckStrings || shouldCheckRegExps) {
         // If we have irregular characters remove them from the errors list
-        if (ALL_IRREGULARS.test(node.raw)) {
+        if (ALL_IRREGULARS.test(sourceCode.getText(node))) {
           removeWhitespaceError(node)
         }
       }
@@ -121,7 +125,7 @@ module.exports = {
 
     /**
      * Checks template string literal nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {ASTNode} node to check for matching errors.
+     * @param {TemplateElement} node to check for matching errors.
      * @returns {void}
      * @private
      */
@@ -133,7 +137,7 @@ module.exports = {
 
     /**
      * Checks HTML attribute value nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {ASTNode} node to check for matching errors.
+     * @param {VLiteral} node to check for matching errors.
      * @returns {void}
      * @private
      */
@@ -145,7 +149,7 @@ module.exports = {
 
     /**
      * Checks HTML text content nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {ASTNode} node to check for matching errors.
+     * @param {VText} node to check for matching errors.
      * @returns {void}
      * @private
      */
@@ -157,7 +161,7 @@ module.exports = {
 
     /**
      * Checks comment nodes for errors that we are choosing to ignore and calls the relevant methods to remove the errors
-     * @param {ASTNode} node to check for matching errors.
+     * @param {Comment | HTMLComment | HTMLBogusComment} node to check for matching errors.
      * @returns {void}
      * @private
      */
diff --git a/lib/rules/no-lifecycle-after-await.js b/lib/rules/no-lifecycle-after-await.js
index cafcde97c..2b5304c9b 100644
--- a/lib/rules/no-lifecycle-after-await.js
+++ b/lib/rules/no-lifecycle-after-await.js
@@ -6,6 +6,10 @@
 const { ReferenceTracker } = require('eslint-utils')
 const utils = require('../utils')
 
+/**
+ * @typedef {import('eslint-utils').TYPES.TraceMap} TraceMap
+ */
+
 const LIFECYCLE_HOOKS = [
   'onBeforeMount',
   'onBeforeUnmount',
@@ -34,17 +38,32 @@ module.exports = {
       forbidden: 'The lifecycle hooks after `await` expression are forbidden.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
+    /**
+     * @typedef {object} SetupFunctionData
+     * @property {Property} setupProperty
+     * @property {boolean} afterAwait
+     */
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} upper
+     * @property {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression} functionNode
+     */
+    /** @type {Set<ESNode>} */
     const lifecycleHookCallNodes = new Set()
+    /** @type {Map<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, SetupFunctionData>} */
     const setupFunctions = new Map()
 
-    let scopeStack = { upper: null, functionNode: null }
+    /** @type {ScopeStack} */
+    let scopeStack
 
     return Object.assign(
       {
         Program() {
           const tracker = new ReferenceTracker(context.getScope())
           const traceMap = {
+            /** @type {TraceMap} */
             vue: {
               [ReferenceTracker.ESM]: true
             }
@@ -71,14 +90,18 @@ module.exports = {
           })
         },
         AwaitExpression() {
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
+          const setupFunctionData = setupFunctions.get(
+            scopeStack && scopeStack.functionNode
+          )
           if (!setupFunctionData) {
             return
           }
           setupFunctionData.afterAwait = true
         },
         CallExpression(node) {
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
+          const setupFunctionData = setupFunctions.get(
+            scopeStack && scopeStack.functionNode
+          )
           if (!setupFunctionData || !setupFunctionData.afterAwait) {
             return
           }
diff --git a/lib/rules/no-multi-spaces.js b/lib/rules/no-multi-spaces.js
index 3c79ee7d0..ef1fee678 100644
--- a/lib/rules/no-multi-spaces.js
+++ b/lib/rules/no-multi-spaces.js
@@ -8,6 +8,10 @@
 // Rule Definition
 // ------------------------------------------------------------------------------
 
+/**
+ * @param {RuleContext} context
+ * @param {Token} node
+ */
 const isProperty = (context, node) => {
   const sourceCode = context.getSourceCode()
   return node.type === 'Punctuator' && sourceCode.getText(node) === ':'
@@ -37,7 +41,7 @@ module.exports = {
 
   /**
    * @param {RuleContext} context - The rule context.
-   * @returns {Object} AST event handlers.
+   * @returns {RuleListener} AST event handlers.
    */
   create(context) {
     const options = context.options[0] || {}
@@ -62,7 +66,7 @@ module.exports = {
           includeComments: true
         })
 
-        let prevToken = tokens.shift()
+        let prevToken = /** @type {Token} */ (tokens.shift())
         for (const token of tokens) {
           const spaces = token.range[0] - prevToken.range[1]
           const shouldIgnore =
diff --git a/lib/rules/no-multiple-slot-args.js b/lib/rules/no-multiple-slot-args.js
index e8bcae96c..f98e058ec 100644
--- a/lib/rules/no-multiple-slot-args.js
+++ b/lib/rules/no-multiple-slot-args.js
@@ -11,11 +11,6 @@
 const utils = require('../utils')
 const { findVariable } = require('eslint-utils')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.ESLintMemberExpression} MemberExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintIdentifier} Identifier
- */
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -35,7 +30,7 @@ module.exports = {
       unexpectedSpread: 'Unexpected spread argument.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     /**
      * Verify the given node
@@ -88,7 +83,6 @@ module.exports = {
      * @param {Identifier} node The node to verify
      */
     function verifyReferences(node) {
-      // @ts-ignore
       const variable = findVariable(context.getScope(), node)
       if (!variable) {
         return
diff --git a/lib/rules/no-multiple-template-root.js b/lib/rules/no-multiple-template-root.js
index 4fd0df0eb..1bbad01ca 100644
--- a/lib/rules/no-multiple-template-root.js
+++ b/lib/rules/no-multiple-template-root.js
@@ -25,7 +25,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     const sourceCode = context.getSourceCode()
 
diff --git a/lib/rules/no-mutating-props.js b/lib/rules/no-mutating-props.js
index 4498fc9f5..b8eeb17e4 100644
--- a/lib/rules/no-mutating-props.js
+++ b/lib/rules/no-mutating-props.js
@@ -7,18 +7,6 @@
 const utils = require('../utils')
 const { findVariable } = require('eslint-utils')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.ESLintObjectExpression} ObjectExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintMemberExpression} MemberExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintProperty} Property
- * @typedef {import('vue-eslint-parser').AST.ESLintIdentifier} Identifier
- * @typedef {import('vue-eslint-parser').AST.VExpressionContainer} VExpressionContainer
- * @typedef {import('vue-eslint-parser').AST.ESLintObjectPattern} ObjectPattern
- * @typedef {import('vue-eslint-parser').AST.ESLintArrayPattern} ArrayPattern
- * @typedef {import('vue-eslint-parser').AST.ESLintPattern} Pattern
- * @typedef {import('vue-eslint-parser').AST.Node} Node
- */
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -36,7 +24,7 @@ module.exports = {
       // fill in your schema
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     /** @type {Map<ObjectExpression, Set<string>>} */
     const propsMap = new Map()
@@ -44,7 +32,7 @@ module.exports = {
     let vueObjectData = null
 
     /**
-     * @param {Node} node
+     * @param {ASTNode} node
      * @param {string} name
      */
     function report(node, name) {
@@ -58,18 +46,18 @@ module.exports = {
     }
 
     /**
-     * @param {Node} node
+     * @param {ASTNode} node
      * @returns {VExpressionContainer}
      */
     function getVExpressionContainer(node) {
       let n = node
       while (n.type !== 'VExpressionContainer') {
-        n = n.parent
+        n = /** @type {ASTNode} */ (n.parent)
       }
       return n
     }
     /**
-     * @param {MemberExpression|Property} node
+     * @param {MemberExpression|AssignmentProperty} node
      * @returns {string}
      */
     function getPropertyNameText(node) {
@@ -85,7 +73,7 @@ module.exports = {
       return '?unknown?'
     }
     /**
-     * @param {Node} node
+     * @param {ASTNode} node
      * @returns {node is Identifier}
      */
     function isVmReference(node) {
@@ -171,11 +159,19 @@ module.exports = {
         onVueObjectEnter(node) {
           propsMap.set(
             node,
-            new Set(utils.getComponentProps(node).map((p) => p.propName))
+            new Set(
+              utils
+                .getComponentProps(node)
+                .map((p) => p.propName)
+                .filter(utils.isDef)
+            )
           )
         },
         onVueObjectExit(node, { type }) {
-          if (!vueObjectData || vueObjectData.type !== 'export') {
+          if (
+            (!vueObjectData || vueObjectData.type !== 'export') &&
+            type !== 'instance'
+          ) {
             vueObjectData = {
               type,
               object: node
@@ -183,7 +179,6 @@ module.exports = {
           }
         },
         onSetupFunctionEnter(node) {
-          /** @type {Pattern} */
           const propsParam = node.params[0]
           if (!propsParam) {
             // no arguments
@@ -200,7 +195,6 @@ module.exports = {
             propsParam,
             []
           )) {
-            // @ts-ignore
             const variable = findVariable(context.getScope(), prop)
             if (!variable) {
               continue
@@ -210,7 +204,6 @@ module.exports = {
               if (!reference.isRead()) {
                 continue
               }
-              /** @type {Identifier} */
               const id = reference.identifier
 
               const invalid = utils.findMutating(id)
@@ -235,6 +228,7 @@ module.exports = {
             }
           }
         },
+        /** @param {(Identifier | ThisExpression) & { parent: MemberExpression } } node */
         'MemberExpression > :matches(Identifier, ThisExpression)'(
           node,
           { node: vueNode }
@@ -242,32 +236,40 @@ module.exports = {
           if (!utils.isThis(node, context)) {
             return
           }
-          /** @type {MemberExpression} */
           const mem = node.parent
           if (mem.object !== node) {
             return
           }
           const name = utils.getStaticPropertyName(mem)
-          if (name && propsMap.get(vueNode).has(name)) {
+          if (
+            name &&
+            /** @type {Set<string>} */ (propsMap.get(vueNode)).has(name)
+          ) {
             verifyMutating(mem, name)
           }
         }
       }),
       utils.defineTemplateBodyVisitor(context, {
+        /** @param {ThisExpression & { parent: MemberExpression } } node */
         'VExpressionContainer MemberExpression > ThisExpression'(node) {
           if (!vueObjectData) {
             return
           }
-          /** @type {MemberExpression} */
           const mem = node.parent
           if (mem.object !== node) {
             return
           }
           const name = utils.getStaticPropertyName(mem)
-          if (name && propsMap.get(vueObjectData.object).has(name)) {
+          if (
+            name &&
+            /** @type {Set<string>} */ (propsMap.get(vueObjectData.object)).has(
+              name
+            )
+          ) {
             verifyMutating(mem, name)
           }
         },
+        /** @param {Identifier } node */
         'VExpressionContainer Identifier'(node) {
           if (!vueObjectData) {
             return
@@ -276,10 +278,16 @@ module.exports = {
             return
           }
           const name = node.name
-          if (name && propsMap.get(vueObjectData.object).has(name)) {
+          if (
+            name &&
+            /** @type {Set<string>} */ (propsMap.get(vueObjectData.object)).has(
+              name
+            )
+          ) {
             verifyMutating(node, name)
           }
         },
+        /** @param {ESNode} node */
         "VAttribute[directive=true][key.name.name='model'] VExpressionContainer > *"(
           node
         ) {
@@ -300,7 +308,12 @@ module.exports = {
           } else {
             return
           }
-          if (name && propsMap.get(vueObjectData.object).has(name)) {
+          if (
+            name &&
+            /** @type {Set<string>} */ (propsMap.get(vueObjectData.object)).has(
+              name
+            )
+          ) {
             report(node, name)
           }
         }
diff --git a/lib/rules/no-parsing-error.js b/lib/rules/no-parsing-error.js
index d51fd7f61..9a6b4f869 100644
--- a/lib/rules/no-parsing-error.js
+++ b/lib/rules/no-parsing-error.js
@@ -70,12 +70,15 @@ module.exports = {
         properties: Object.keys(DEFAULT_OPTIONS).reduce((ret, code) => {
           ret[code] = { type: 'boolean' }
           return ret
-        }, {}),
+        }, /** @type { { [key: string]: { type: 'boolean' } } } */ ({})),
         additionalProperties: false
       }
     ]
   },
-
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     const options = Object.assign({}, DEFAULT_OPTIONS, context.options[0] || {})
 
diff --git a/lib/rules/no-potential-component-option-typo.js b/lib/rules/no-potential-component-option-typo.js
index a29d2acf0..f3ac47363 100644
--- a/lib/rules/no-potential-component-option-typo.js
+++ b/lib/rules/no-potential-component-option-typo.js
@@ -48,50 +48,64 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const option = context.options[0] || {}
     const custom = option.custom || []
+    /** @type {('all' | 'vue' | 'vue-router' | 'nuxt')[]} */
     const presets = option.presets || ['vue']
     const threshold = option.threshold || 1
-    let candidateOptions
-    if (presets.includes('all')) {
-      candidateOptions = Object.keys(vueComponentOptions).reduce((pre, cur) => {
-        return [...pre, ...vueComponentOptions[cur]]
-      }, [])
-    } else {
-      candidateOptions = presets.reduce((pre, cur) => {
-        return [...pre, ...vueComponentOptions[cur]]
-      }, [])
+    /** @type {Set<string>} */
+    const candidateOptionSet = new Set(custom)
+    for (const preset of presets) {
+      if (preset === 'all') {
+        for (const opts of Object.values(vueComponentOptions)) {
+          for (const opt of opts) {
+            candidateOptionSet.add(opt)
+          }
+        }
+      } else {
+        for (const opt of vueComponentOptions[preset]) {
+          candidateOptionSet.add(opt)
+        }
+      }
     }
-    const candidateOptionSet = new Set([...candidateOptions, ...custom])
     const candidateOptionList = [...candidateOptionSet]
     if (!candidateOptionList.length) {
       return {}
     }
     return utils.executeOnVue(context, (obj) => {
-      const componentInstanceOptions = obj.properties.filter(
-        (p) => p.type === 'Property' && p.key.type === 'Identifier'
-      )
+      const componentInstanceOptions = obj.properties
+        .map((p) => {
+          if (p.type === 'Property') {
+            const name = utils.getStaticPropertyName(p)
+            if (name != null) {
+              return {
+                name,
+                key: p.key
+              }
+            }
+          }
+          return null
+        })
+        .filter(utils.isDef)
+
       if (!componentInstanceOptions.length) {
-        return {}
+        return
       }
       componentInstanceOptions.forEach((option) => {
         const id = option.key
-        const name = id.name
+        const name = option.name
         if (candidateOptionSet.has(name)) {
           return
         }
         const potentialTypoList = candidateOptionList
           .map((o) => ({ option: o, distance: utils.editDistance(o, name) }))
-          .filter(
-            ({ distance, option }) => distance <= threshold && distance > 0
-          )
+          .filter(({ distance }) => distance <= threshold && distance > 0)
           .sort((a, b) => a.distance - b.distance)
         if (potentialTypoList.length) {
           context.report({
             node: id,
-            loc: id.loc,
             message: `'{{name}}' may be a typo, which is similar to option [{{option}}].`,
             data: {
               name,
diff --git a/lib/rules/no-ref-as-operand.js b/lib/rules/no-ref-as-operand.js
index cfd09921c..bfb344d24 100644
--- a/lib/rules/no-ref-as-operand.js
+++ b/lib/rules/no-ref-as-operand.js
@@ -22,9 +22,20 @@ module.exports = {
         'Must use `.value` to read or write the value wrapped by `{{method}}()`.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
+    /**
+     * @typedef {object} ReferenceData
+     * @property {VariableDeclarator} variableDeclarator
+     * @property {VariableDeclaration | null} variableDeclaration
+     * @property {string} method
+     */
+    /** @type {Map<Identifier, ReferenceData>} */
     const refReferenceIds = new Map()
 
+    /**
+     * @param {Identifier} node
+     */
     function reportIfRefWrapped(node) {
       const data = refReferenceIds.get(node)
       if (!data) {
@@ -97,30 +108,37 @@ module.exports = {
         }
       },
       // if (refValue)
+      /** @param {Identifier} node */
       'IfStatement>Identifier'(node) {
         reportIfRefWrapped(node)
       },
       // switch (refValue)
+      /** @param {Identifier} node */
       'SwitchStatement>Identifier'(node) {
         reportIfRefWrapped(node)
       },
       // -refValue, +refValue, !refValue, ~refValue, typeof refValue
+      /** @param {Identifier} node */
       'UnaryExpression>Identifier'(node) {
         reportIfRefWrapped(node)
       },
       // refValue++, refValue--
+      /** @param {Identifier} node */
       'UpdateExpression>Identifier'(node) {
         reportIfRefWrapped(node)
       },
       // refValue+1, refValue-1
+      /** @param {Identifier} node */
       'BinaryExpression>Identifier'(node) {
         reportIfRefWrapped(node)
       },
       // refValue+=1, refValue-=1, foo+=refValue, foo-=refValue
+      /** @param {Identifier} node */
       'AssignmentExpression>Identifier'(node) {
         reportIfRefWrapped(node)
       },
       // refValue || other, refValue && other. ignore: other || refValue
+      /** @param {Identifier & {parent: LogicalExpression}} node */
       'LogicalExpression>Identifier'(node) {
         if (node.parent.left !== node) {
           return
@@ -139,6 +157,7 @@ module.exports = {
         reportIfRefWrapped(node)
       },
       // refValue ? x : y
+      /** @param {Identifier & {parent: ConditionalExpression}} node */
       'ConditionalExpression>Identifier'(node) {
         if (node.parent.test !== node) {
           return
@@ -146,10 +165,12 @@ module.exports = {
         reportIfRefWrapped(node)
       },
       // `${refValue}`
+      /** @param {Identifier} node */
       'TemplateLiteral>Identifier'(node) {
         reportIfRefWrapped(node)
       },
       // refValue.x
+      /** @param {Identifier & {parent: MemberExpression}} node */
       'MemberExpression>Identifier'(node) {
         if (node.parent.object !== node) {
           return
diff --git a/lib/rules/no-reserved-component-names.js b/lib/rules/no-reserved-component-names.js
index 258f1c517..e21bf7cd8 100644
--- a/lib/rules/no-reserved-component-names.js
+++ b/lib/rules/no-reserved-component-names.js
@@ -33,9 +33,14 @@ const vueBuiltInComponents = [
 
 const vue3BuiltInComponents = ['teleport', 'suspense']
 
-const isLowercase = (word) => /^[a-z]*$/.test(word)
-const capitalizeFirstLetter = (word) =>
-  word[0].toUpperCase() + word.substring(1, word.length)
+/** @param {string} word  */
+function isLowercase(word) {
+  return /^[a-z]*$/.test(word)
+}
+/** @param {string} word  */
+function capitalizeFirstLetter(word) {
+  return word[0].toUpperCase() + word.substring(1, word.length)
+}
 
 const RESERVED_NAMES_IN_HTML = new Set([
   ...htmlElements,
@@ -93,7 +98,7 @@ module.exports = {
       reservedInVue3: 'Name "{{name}}" is reserved in Vue.js 3.x.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const disallowVueBuiltInComponents =
@@ -108,6 +113,10 @@ module.exports = {
       ...RESERVED_NAMES_IN_OTHERS
     ])
 
+    /**
+     * @param {Expression | SpreadElement} node
+     * @returns {node is (Literal | TemplateLiteral)}
+     */
     function canVerify(node) {
       return (
         node.type === 'Literal' ||
@@ -117,19 +126,26 @@ module.exports = {
       )
     }
 
+    /**
+     * @param {Literal | TemplateLiteral} node
+     */
     function reportIfInvalid(node) {
       let name
       if (node.type === 'TemplateLiteral') {
         const quasis = node.quasis[0]
         name = quasis.value.cooked
       } else {
-        name = node.value
+        name = `${node.value}`
       }
       if (reservedNames.has(name)) {
         report(node, name)
       }
     }
 
+    /**
+     * @param {ESNode} node
+     * @param {string} name
+     */
     function report(node, name) {
       context.report({
         node,
@@ -164,14 +180,10 @@ module.exports = {
           .filter(({ name }) => reservedNames.has(name))
           .forEach(({ node, name }) => report(node, name))
 
-        const node = obj.properties.find(
-          (item) =>
-            item.type === 'Property' &&
-            item.key.name === 'name' &&
-            canVerify(item.value)
-        )
+        const node = utils.findProperty(obj, 'name')
 
         if (!node) return
+        if (!canVerify(node.value)) return
         reportIfInvalid(node.value)
       })
     )
diff --git a/lib/rules/no-reserved-keys.js b/lib/rules/no-reserved-keys.js
index d17ce05df..38b4f410d 100644
--- a/lib/rules/no-reserved-keys.js
+++ b/lib/rules/no-reserved-keys.js
@@ -6,11 +6,16 @@
 
 const utils = require('../utils')
 
+/**
+ * @typedef {import('../utils').GroupName} GroupName
+ */
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 const RESERVED_KEYS = require('../utils/vue-reserved.json')
+/** @type {GroupName[]} */
 const GROUP_NAMES = ['props', 'computed', 'data', 'methods', 'setup']
 
 module.exports = {
@@ -37,7 +42,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const reservedKeys = new Set(RESERVED_KEYS.concat(options.reserved || []))
diff --git a/lib/rules/no-restricted-static-attribute.js b/lib/rules/no-restricted-static-attribute.js
index 70db824db..24cab62b8 100644
--- a/lib/rules/no-restricted-static-attribute.js
+++ b/lib/rules/no-restricted-static-attribute.js
@@ -7,9 +7,6 @@
 const utils = require('../utils')
 const regexp = require('../utils/regexp')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.VAttribute} VAttribute
- */
 /**
  * @typedef {object} ParsedOption
  * @property { (key: VAttribute) => boolean } test
@@ -118,6 +115,7 @@ module.exports = {
       restrictedAttr: '{{message}}'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     if (!context.options.length) {
       return {}
diff --git a/lib/rules/no-restricted-syntax.js b/lib/rules/no-restricted-syntax.js
index 869540001..279f400cd 100644
--- a/lib/rules/no-restricted-syntax.js
+++ b/lib/rules/no-restricted-syntax.js
@@ -5,5 +5,5 @@
 
 const { wrapCoreRule } = require('../utils')
 
-// eslint-disable-next-line
+// eslint-disable-next-line no-invalid-meta, no-invalid-meta-docs-categories
 module.exports = wrapCoreRule(require('eslint/lib/rules/no-restricted-syntax'))
diff --git a/lib/rules/no-restricted-v-bind.js b/lib/rules/no-restricted-v-bind.js
index 7ec586dd5..02ac6e399 100644
--- a/lib/rules/no-restricted-v-bind.js
+++ b/lib/rules/no-restricted-v-bind.js
@@ -6,11 +6,6 @@
 
 const utils = require('../utils')
 const regexp = require('../utils/regexp')
-
-/**
- * @typedef {import('vue-eslint-parser').AST.VDirectiveKey} VDirectiveKey
- * @typedef {import('vue-eslint-parser').AST.VIdentifier} VIdentifier
- */
 /**
  * @typedef {object} ParsedOption
  * @property { (key: VDirectiveKey) => boolean } test
@@ -50,10 +45,10 @@ function parseOption(option) {
     const matcher = buildMatcher(option)
     return {
       test(key) {
-        return (
+        return Boolean(
           key.argument &&
-          key.argument.type === 'VIdentifier' &&
-          matcher(key.argument.rawName)
+            key.argument.type === 'VIdentifier' &&
+            matcher(key.argument.rawName)
         )
       },
       modifiers: []
@@ -74,7 +69,7 @@ function parseOption(option) {
       if (!argTest(key)) {
         return false
       }
-      return option.modifiers.every((modName) => {
+      return /** @type {string[]} */ (option.modifiers).every((modName) => {
         return key.modifiers.some((mid) => mid.name === modName)
       })
     }
@@ -139,6 +134,7 @@ module.exports = {
       restrictedVBind: '{{message}}'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     /** @type {ParsedOption[]} */
     const options = (context.options.length === 0
diff --git a/lib/rules/no-setup-props-destructure.js b/lib/rules/no-setup-props-destructure.js
index c4f04edd4..43b1856ee 100644
--- a/lib/rules/no-setup-props-destructure.js
+++ b/lib/rules/no-setup-props-destructure.js
@@ -23,9 +23,15 @@ module.exports = {
         'Getting a value from the `props` in root scope of `setup()` will cause the value to lose reactivity.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
+    /** @type {Map<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, Set<Identifier>>} */
     const setupScopePropsReferenceIds = new Map()
 
+    /**
+     * @param {ESNode} node
+     * @param {string} messageId
+     */
     function report(node, messageId) {
       context.report({
         node,
@@ -33,6 +39,11 @@ module.exports = {
       })
     }
 
+    /**
+     * @param {Pattern} left
+     * @param {Expression | null} right
+     * @param {Set<Identifier>} propsReferenceIds
+     */
     function verify(left, right, propsReferenceIds) {
       if (!right) {
         return
@@ -46,23 +57,31 @@ module.exports = {
         return
       }
 
+      /** @type {Expression | Super} */
       let rightId = right
       while (rightId.type === 'MemberExpression') {
         rightId = rightId.object
       }
-      if (propsReferenceIds.has(rightId)) {
+      if (rightId.type === 'Identifier' && propsReferenceIds.has(rightId)) {
         report(left, 'getProperty')
       }
     }
-
-    let scopeStack = null
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} upper
+     * @property {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression} functionNode
+     */
+    /**
+     * @type {ScopeStack}
+     */
+    let scopeStack
 
     return utils.defineVueVisitor(context, {
       ':function'(node) {
         scopeStack = { upper: scopeStack, functionNode: node }
       },
       onSetupFunctionEnter(node) {
-        const propsParam = node.params[0]
+        const propsParam = utils.unwrapAssignmentPattern(node.params[0])
         if (!propsParam) {
           // no arguments
           return
diff --git a/lib/rules/no-shared-component-data.js b/lib/rules/no-shared-component-data.js
index 2200f0e78..160f41ef9 100644
--- a/lib/rules/no-shared-component-data.js
+++ b/lib/rules/no-shared-component-data.js
@@ -6,14 +6,20 @@
 
 const utils = require('../utils')
 
+/** @param {Token} token  */
 function isOpenParen(token) {
   return token.type === 'Punctuator' && token.value === '('
 }
 
+/** @param {Token} token  */
 function isCloseParen(token) {
   return token.type === 'Punctuator' && token.value === ')'
 }
 
+/**
+ * @param {Expression} node
+ * @param {SourceCode} sourceCode
+ */
 function getFirstAndLastTokens(node, sourceCode) {
   let first = sourceCode.getFirstToken(node)
   let last = sourceCode.getLastToken(node)
@@ -46,35 +52,33 @@ module.exports = {
     fixable: 'code',
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
 
     return utils.executeOnVueComponent(context, (obj) => {
-      obj.properties
-        .filter(
-          (p) =>
-            p.type === 'Property' &&
-            p.key.type === 'Identifier' &&
-            p.key.name === 'data' &&
-            p.value.type !== 'FunctionExpression' &&
-            p.value.type !== 'ArrowFunctionExpression' &&
-            p.value.type !== 'Identifier'
-        )
-        .forEach((p) => {
-          context.report({
-            node: p,
-            message: '`data` property in component must be a function.',
-            fix(fixer) {
-              const tokens = getFirstAndLastTokens(p.value, sourceCode)
+      const invalidData = utils.findProperty(
+        obj,
+        'data',
+        (p) =>
+          p.value.type !== 'FunctionExpression' &&
+          p.value.type !== 'ArrowFunctionExpression' &&
+          p.value.type !== 'Identifier'
+      )
+      if (invalidData) {
+        context.report({
+          node: invalidData,
+          message: '`data` property in component must be a function.',
+          fix(fixer) {
+            const tokens = getFirstAndLastTokens(invalidData.value, sourceCode)
 
-              return [
-                fixer.insertTextBefore(tokens.first, 'function() {\nreturn '),
-                fixer.insertTextAfter(tokens.last, ';\n}')
-              ]
-            }
-          })
+            return [
+              fixer.insertTextBefore(tokens.first, 'function() {\nreturn '),
+              fixer.insertTextAfter(tokens.last, ';\n}')
+            ]
+          }
         })
+      }
     })
   }
 }
diff --git a/lib/rules/no-side-effects-in-computed-properties.js b/lib/rules/no-side-effects-in-computed-properties.js
index 59f3b37e7..e6cd548e9 100644
--- a/lib/rules/no-side-effects-in-computed-properties.js
+++ b/lib/rules/no-side-effects-in-computed-properties.js
@@ -7,8 +7,7 @@
 const utils = require('../utils')
 
 /**
- * @typedef {import('vue-eslint-parser').AST.ESLintObjectExpression} ObjectExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintMemberExpression} MemberExpression
+ * @typedef {import('../utils').VueObjectData} VueObjectData
  * @typedef {import('../utils').ComponentComputedProperty} ComponentComputedProperty
  */
 
@@ -28,12 +27,21 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     /** @type {Map<ObjectExpression, ComponentComputedProperty[]>} */
     const computedPropertiesMap = new Map()
-    let scopeStack = { upper: null, body: null }
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} upper
+     * @property {BlockStatement | Expression} body
+     */
+    /**
+     * @type {ScopeStack}
+     */
+    let scopeStack
 
+    /** @param {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} node */
     function onFunctionEnter(node) {
       scopeStack = { upper: scopeStack, body: node.body }
     }
@@ -49,21 +57,25 @@ module.exports = {
       ':function': onFunctionEnter,
       ':function:exit': onFunctionExit,
 
+      /**
+       * @param {(Identifier | ThisExpression) & {parent: MemberExpression}} node
+       * @param {VueObjectData} data
+       */
       'MemberExpression > :matches(Identifier, ThisExpression)'(
         node,
         { node: vueNode }
       ) {
         const targetBody = scopeStack.body
-        const computedProperty = computedPropertiesMap
-          .get(vueNode)
-          .find((cp) => {
-            return (
-              cp.value &&
-              node.loc.start.line >= cp.value.loc.start.line &&
-              node.loc.end.line <= cp.value.loc.end.line &&
-              targetBody === cp.value
-            )
-          })
+        const computedProperty = /** @type {ComponentComputedProperty[]} */ (computedPropertiesMap.get(
+          vueNode
+        )).find((cp) => {
+          return (
+            cp.value &&
+            node.loc.start.line >= cp.value.loc.start.line &&
+            node.loc.end.line <= cp.value.loc.end.line &&
+            targetBody === cp.value
+          )
+        })
         if (!computedProperty) {
           return
         }
@@ -71,7 +83,6 @@ module.exports = {
         if (!utils.isThis(node, context)) {
           return
         }
-        /** @type {MemberExpression} */
         const mem = node.parent
         if (mem.object !== node) {
           return
@@ -82,7 +93,7 @@ module.exports = {
           context.report({
             node: invalid.node,
             message: 'Unexpected side effect in "{{key}}" computed property.',
-            data: { key: computedProperty.key }
+            data: { key: computedProperty.key || 'Unknown' }
           })
         }
       }
diff --git a/lib/rules/no-spaces-around-equal-signs-in-attribute.js b/lib/rules/no-spaces-around-equal-signs-in-attribute.js
index 4bb32f03f..8357fbf3d 100644
--- a/lib/rules/no-spaces-around-equal-signs-in-attribute.js
+++ b/lib/rules/no-spaces-around-equal-signs-in-attribute.js
@@ -26,7 +26,7 @@ module.exports = {
     fixable: 'whitespace',
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
     return utils.defineTemplateBodyVisitor(context, {
@@ -34,6 +34,7 @@ module.exports = {
         if (!node.value) {
           return
         }
+        /** @type {Range} */
         const range = [node.key.range[1], node.value.range[0]]
         const eqText = sourceCode.text.slice(range[0], range[1])
         const expect = eqText.trim()
diff --git a/lib/rules/no-static-inline-styles.js b/lib/rules/no-static-inline-styles.js
index 73421a97b..7dce27e1a 100644
--- a/lib/rules/no-static-inline-styles.js
+++ b/lib/rules/no-static-inline-styles.js
@@ -30,10 +30,11 @@ module.exports = {
       forbiddenStyleAttr: '`style` attributes are forbidden.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     /**
      * Checks whether if the given property node is a static value.
-     * @param {AssignmentProperty} prop property node to check
+     * @param {Property} prop property node to check
      * @returns {boolean} `true` if the given property node is a static value.
      */
     function isStaticValue(prop) {
@@ -55,8 +56,8 @@ module.exports = {
      * - If all properties are static properties, it returns one root node.
      *   `:style="[ { color: 'red' }, { display: 'flex', width: '16px' } ]"`
      *    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-     * @param {VAttribute} node `:style` node to check
-     * @returns {AssignmentProperty[] | [VAttribute]} the static properties.
+     * @param {VDirective} node `:style` node to check
+     * @returns {Property[] | [VDirective]} the static properties.
      */
     function getReportNodes(node) {
       const { value } = node
@@ -108,7 +109,7 @@ module.exports = {
 
     /**
      * Reports if the value is static.
-     * @param {VAttribute} node `:style` node to check
+     * @param {VDirective} node `:style` node to check
      */
     function verifyVBindStyle(node) {
       for (const n of getReportNodes(node)) {
@@ -119,7 +120,9 @@ module.exports = {
       }
     }
 
+    /** @type {TemplateListener} */
     const visitor = {
+      /** @param {VAttribute} node */
       "VAttribute[directive=false][key.name='style']"(node) {
         context.report({
           node,
diff --git a/lib/rules/no-template-key.js b/lib/rules/no-template-key.js
index c7b06ef56..935113820 100644
--- a/lib/rules/no-template-key.js
+++ b/lib/rules/no-template-key.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VElement} node */
       "VElement[name='template']"(node) {
         if (
           utils.hasAttribute(node, 'key') ||
diff --git a/lib/rules/no-template-shadow.js b/lib/rules/no-template-shadow.js
index 73aeca296..c228642f4 100644
--- a/lib/rules/no-template-shadow.js
+++ b/lib/rules/no-template-shadow.js
@@ -10,10 +10,15 @@
 
 const utils = require('../utils')
 
+/**
+ * @typedef {import('../utils').GroupName} GroupName
+ */
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
+/** @type {GroupName[]} */
 const GROUP_NAMES = ['props', 'computed', 'data', 'methods']
 
 module.exports = {
@@ -28,13 +33,18 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
+    /** @type {Set<string>} */
     const jsVars = new Set()
-    let scope = {
-      parent: null,
-      nodes: []
-    }
+
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} parent
+     * @property {Identifier[]} nodes
+     */
+    /** @type {ScopeStack} */
+    let scope
 
     // ----------------------------------------------------------------------
     // Public
@@ -43,10 +53,13 @@ module.exports = {
     return utils.defineTemplateBodyVisitor(
       context,
       {
+        /** @param {VElement} node */
         VElement(node) {
           scope = {
             parent: scope,
-            nodes: scope.nodes.slice() // make copy
+            nodes: scope
+              ? scope.nodes.slice() // make copy
+              : []
           }
           if (node.variables) {
             for (const variable of node.variables) {
@@ -71,7 +84,7 @@ module.exports = {
             }
           }
         },
-        'VElement:exit'(node) {
+        'VElement:exit'() {
           scope = scope.parent
         }
       },
diff --git a/lib/rules/no-template-target-blank.js b/lib/rules/no-template-target-blank.js
index f7c1ab864..b671091ce 100644
--- a/lib/rules/no-template-target-blank.js
+++ b/lib/rules/no-template-target-blank.js
@@ -13,6 +13,7 @@ const utils = require('../utils')
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
+/** @param {VAttribute} node */
 function isTargetBlank(node) {
   return (
     node.key &&
@@ -21,11 +22,17 @@ function isTargetBlank(node) {
     node.value.value === '_blank'
   )
 }
-
+/**
+ * @param {VStartTag} node
+ * @param {boolean} allowReferrer
+ */
 function hasSecureRel(node, allowReferrer) {
   return node.attributes.some((attr) => {
     if (attr.key && attr.key.name === 'rel') {
-      const tags = attr.value && attr.value.value.toLowerCase().split(' ')
+      const tags =
+        attr.value &&
+        attr.value.type === 'VLiteral' &&
+        attr.value.value.toLowerCase().split(' ')
       return (
         tags &&
         tags.includes('noopener') &&
@@ -37,16 +44,23 @@ function hasSecureRel(node, allowReferrer) {
   })
 }
 
+/**
+ * @param {VStartTag} node
+ */
 function hasExternalLink(node) {
   return node.attributes.some(
     (attr) =>
       attr.key &&
       attr.key.name === 'href' &&
       attr.value &&
+      attr.value.type === 'VLiteral' &&
       /^(?:\w+:|\/\/)/.test(attr.value.value)
   )
 }
 
+/**
+ * @param {VStartTag} node
+ */
 function hasDynamicLink(node) {
   return node.attributes.some(
     (attr) =>
@@ -55,6 +69,7 @@ function hasDynamicLink(node) {
       attr.key.name &&
       attr.key.name.name === 'bind' &&
       attr.key.argument &&
+      attr.key.argument.type === 'VIdentifier' &&
       attr.key.argument.name === 'href'
   )
 }
@@ -100,7 +115,8 @@ module.exports = {
     const enforceDynamicLinks = configuration.enforceDynamicLinks || 'always'
 
     return utils.defineTemplateBodyVisitor(context, {
-      VAttribute(node) {
+      /** @param {VAttribute} node */
+      'VAttribute[directive=false]'(node) {
         if (!isTargetBlank(node) || hasSecureRel(node.parent, allowReferrer)) {
           return
         }
diff --git a/lib/rules/no-textarea-mustache.js b/lib/rules/no-textarea-mustache.js
index 06dabbf57..abbe01157 100644
--- a/lib/rules/no-textarea-mustache.js
+++ b/lib/rules/no-textarea-mustache.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VExpressionContainer} node */
       "VElement[name='textarea'] VExpressionContainer"(node) {
         if (node.parent.type !== 'VElement') {
           return
diff --git a/lib/rules/no-unregistered-components.js b/lib/rules/no-unregistered-components.js
index d4ac6fa15..205580221 100644
--- a/lib/rules/no-unregistered-components.js
+++ b/lib/rules/no-unregistered-components.js
@@ -29,7 +29,7 @@ const VUE_BUILT_IN_COMPONENTS = [
  *
  * Includes `suspense` and `teleport` from Vue 3.
  *
- * @param {ASTNode} node The start tag node to check.
+ * @param {VElement} node The start tag node to check.
  * @returns {boolean} `true` if the node is a built-in component.
  */
 const isBuiltInComponent = (node) => {
@@ -68,16 +68,20 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
+    /** @type {string[]} */
     const ignorePatterns = options.ignorePatterns || []
+    /** @type { { node: VElement | VDirective | VAttribute, name: string }[] } */
     const usedComponentNodes = []
+    /** @type { { node: Property, name: string }[] } */
     const registeredComponents = []
 
     return utils.defineTemplateBodyVisitor(
       context,
       {
+        /** @param {VElement} node */
         VElement(node) {
           if (
             (!utils.isHtmlElementNode(node) && !utils.isSvgElementNode(node)) ||
@@ -90,6 +94,7 @@ module.exports = {
 
           usedComponentNodes.push({ node, name: node.rawName })
         },
+        /** @param {VDirective} node */
         "VAttribute[directive=true][key.name.name='bind'][key.argument.name='is']"(
           node
         ) {
@@ -101,11 +106,17 @@ module.exports = {
             return
 
           if (node.value.expression.type === 'Literal') {
-            if (utils.isHtmlWellKnownElementName(node.value.expression.value))
+            if (
+              utils.isHtmlWellKnownElementName(`${node.value.expression.value}`)
+            )
               return
-            usedComponentNodes.push({ node, name: node.value.expression.value })
+            usedComponentNodes.push({
+              node,
+              name: `${node.value.expression.value}`
+            })
           }
         },
+        /** @param {VAttribute} node */
         "VAttribute[directive=false][key.name='is']"(node) {
           if (
             !node.value || // `<component is />`
@@ -114,6 +125,7 @@ module.exports = {
             return
           usedComponentNodes.push({ node, name: node.value.value })
         },
+        /** @param {VElement} node */
         "VElement[name='template']:exit"() {
           // All registered components, transformed to kebab-case
           const registeredComponentNames = registeredComponents.map(
diff --git a/lib/rules/no-unsupported-features.js b/lib/rules/no-unsupported-features.js
index 4089eef94..eaf9ce57a 100644
--- a/lib/rules/no-unsupported-features.js
+++ b/lib/rules/no-unsupported-features.js
@@ -4,7 +4,7 @@
  */
 'use strict'
 
-const { Range } = require('semver')
+const semver = require('semver')
 const utils = require('../utils')
 
 const FEATURES = {
@@ -22,7 +22,7 @@ const cache = new Map()
 /**
  * Get the `semver.Range` object of a given range text.
  * @param {string} x The text expression for a semver range.
- * @returns {Range|null} The range object of a given range text.
+ * @returns {semver.Range} The range object of a given range text.
  * It's null if the `x` is not a valid range text.
  */
 function getSemverRange(x) {
@@ -31,7 +31,7 @@ function getSemverRange(x) {
 
   if (!ret) {
     try {
-      ret = new Range(s)
+      ret = new semver.Range(s)
     } catch (_error) {
       // Ignore parsing error.
     }
@@ -41,29 +41,6 @@ function getSemverRange(x) {
   return ret
 }
 
-/**
- * Merge two visitors.
- * @param {Visitor} x The visitor which is assigned.
- * @param {Visitor} y The visitor which is assigning.
- * @returns {Visitor} `x`.
- */
-function merge(x, y) {
-  for (const key of Object.keys(y)) {
-    if (typeof x[key] === 'function') {
-      if (x[key]._handlers == null) {
-        const fs = [x[key], y[key]]
-        x[key] = (node) => fs.forEach((h) => h(node))
-        x[key]._handlers = fs
-      } else {
-        x[key]._handlers.push(y[key])
-      }
-    } else {
-      x[key] = y[key]
-    }
-  }
-  return x
-}
-
 module.exports = {
   meta: {
     type: 'suggestion',
@@ -106,6 +83,7 @@ module.exports = {
         '`.prop` shorthand are not supported except Vue.js ">=2.6.0-beta.1 <=2.6.0-beta.3".'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     const { version, ignores } = Object.assign(
       {
@@ -122,7 +100,7 @@ module.exports = {
 
     /**
      * Check whether a given case object is full-supported on the configured node version.
-     * @param {{supported:string}} aCase The case object to check.
+     * @param { { supported?: string | ((range: semver.Range) => boolean) } } aCase The case object to check.
      * @returns {boolean} `true` if it's supporting.
      */
     function isNotSupportingVersion(aCase) {
@@ -131,13 +109,16 @@ module.exports = {
       }
       return versionRange.intersects(getSemverRange(`<${aCase.supported}`))
     }
-    const templateBodyVisitor = Object.keys(FEATURES)
+
+    const keys = /** @type {(keyof FEATURES)[]} */ (Object.keys(FEATURES))
+
+    const templateBodyVisitor = keys
       .filter((syntaxName) => !ignores.includes(syntaxName))
       .filter((syntaxName) => isNotSupportingVersion(FEATURES[syntaxName]))
       .reduce((result, syntaxName) => {
         const visitor = FEATURES[syntaxName].createTemplateBodyVisitor(context)
         if (visitor) {
-          merge(result, visitor)
+          return utils.compositingVisitors(result, visitor)
         }
         return result
       }, {})
diff --git a/lib/rules/no-unused-components.js b/lib/rules/no-unused-components.js
index 09cad4af7..b76af7198 100644
--- a/lib/rules/no-unused-components.js
+++ b/lib/rules/no-unused-components.js
@@ -37,7 +37,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const ignoreWhenBindingPresent =
@@ -45,13 +45,16 @@ module.exports = {
         ? options.ignoreWhenBindingPresent
         : true
     const usedComponents = new Set()
+    /** @type { { node: Property, name: string }[] } */
     let registeredComponents = []
     let ignoreReporting = false
+    /** @type {Position} */
     let templateLocation
 
     return utils.defineTemplateBodyVisitor(
       context,
       {
+        /** @param {VElement} node */
         VElement(node) {
           if (
             (!utils.isHtmlElementNode(node) && !utils.isSvgElementNode(node)) ||
@@ -63,6 +66,7 @@ module.exports = {
 
           usedComponents.add(node.rawName)
         },
+        /** @param {VDirective} node */
         "VAttribute[directive=true][key.name.name='bind'][key.argument.name='is']"(
           node
         ) {
@@ -79,17 +83,23 @@ module.exports = {
             ignoreReporting = true
           }
         },
+        /** @param {VAttribute} node */
         "VAttribute[directive=false][key.name='is']"(node) {
+          if (!node.value) {
+            return
+          }
           usedComponents.add(node.value.value)
         },
-        "VElement[name='template']"(rootNode) {
-          templateLocation = templateLocation || rootNode.loc.start
+        /** @param {VElement} node */
+        "VElement[name='template']"(node) {
+          templateLocation = templateLocation || node.loc.start
         },
-        "VElement[name='template']:exit"(rootNode) {
+        /** @param {VElement} node */
+        "VElement[name='template']:exit"(node) {
           if (
-            rootNode.loc.start !== templateLocation ||
+            node.loc.start !== templateLocation ||
             ignoreReporting ||
-            utils.hasAttribute(rootNode, 'src')
+            utils.hasAttribute(node, 'src')
           )
             return
 
diff --git a/lib/rules/no-unused-properties.js b/lib/rules/no-unused-properties.js
index 8dce09b40..951d6a2db 100644
--- a/lib/rules/no-unused-properties.js
+++ b/lib/rules/no-unused-properties.js
@@ -11,25 +11,9 @@
 const utils = require('../utils')
 const eslintUtils = require('eslint-utils')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.Node} Node
- * @typedef {import('vue-eslint-parser').AST.ESLintNode} ASTNode
- * @typedef {import('vue-eslint-parser').AST.ESLintObjectPattern} ObjectPattern
- * @typedef {import('vue-eslint-parser').AST.ESLintIdentifier} Identifier
- * @typedef {import('vue-eslint-parser').AST.ESLintPattern} Pattern
- * @typedef {import('vue-eslint-parser').AST.ESLintThisExpression} ThisExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintMemberExpression} MemberExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintFunctionExpression} FunctionExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintArrowFunctionExpression} ArrowFunctionExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintFunctionDeclaration} FunctionDeclaration
- * @typedef {import('vue-eslint-parser').AST.VAttribute} VAttribute
- * @typedef {import('vue-eslint-parser').AST.VIdentifier} VIdentifier
- * @typedef {import('vue-eslint-parser').AST.VExpressionContainer} VExpressionContainer
- * @typedef {import('eslint').Scope.Variable} Variable
- * @typedef {import('eslint').Rule.RuleContext} RuleContext
- */
 /**
  * @typedef {import('../utils').ComponentPropertyData} ComponentPropertyData
+ * @typedef {import('../utils').VueObjectData} VueObjectData
  */
 /**
  * @typedef {object} TemplatePropertiesContainer
@@ -58,11 +42,12 @@ const GROUP_SETUP = 'setup'
 const GROUP_WATCHER = 'watch'
 
 const PROPERTY_LABEL = {
-  [GROUP_PROPERTY]: 'property',
-  [GROUP_DATA]: 'data',
-  [GROUP_COMPUTED_PROPERTY]: 'computed property',
-  [GROUP_METHODS]: 'method',
-  [GROUP_SETUP]: 'property returned from `setup()`'
+  props: 'property',
+  data: 'data',
+  computed: 'computed property',
+  methods: 'method',
+  setup: 'property returned from `setup()`',
+  watch: 'watch'
 }
 
 // ------------------------------------------------------------------------------
@@ -72,27 +57,26 @@ const PROPERTY_LABEL = {
 /**
  * Find the variable of a given name.
  * @param {RuleContext} context The rule context
- * @param {ASTNode} node The variable name to find.
+ * @param {Identifier} node The variable name to find.
  * @returns {Variable|null} The found variable or null.
  */
 function findVariable(context, node) {
-  // @ts-ignore
   return eslintUtils.findVariable(getScope(context, node), node)
 }
 /**
  * Gets the scope for the current node
  * @param {RuleContext} context The rule context
- * @param {ASTNode} currentNode The node to get the scope of
- * @returns { import('eslint-scope').Scope } The scope information for this node
+ * @param {ESNode} currentNode The node to get the scope of
+ * @returns { import('eslint').Scope.Scope } The scope information for this node
  */
 function getScope(context, currentNode) {
   // On Program node, get the outermost scope to avoid return Node.js special function scope or ES modules scope.
   const inner = currentNode.type !== 'Program'
   const scopeManager = context.getSourceCode().scopeManager
 
-  // @ts-ignore
-  for (let node = currentNode; node; node = node.parent) {
-    // @ts-ignore
+  /** @type {ESNode | null} */
+  let node = currentNode
+  for (; node; node = /** @type {ESNode | null} */ (node.parent)) {
     const scope = scopeManager.acquire(node, inner)
 
     if (scope) {
@@ -108,6 +92,7 @@ function getScope(context, currentNode) {
 
 /**
  * Extract names from references objects.
+ * @param {VReference[]} references
  */
 function getReferencesNames(references) {
   return references
@@ -169,7 +154,15 @@ function extractObjectPatternProperties(node) {
   for (const prop of node.properties) {
     if (prop.type === 'Property') {
       const name = utils.getStaticPropertyName(prop)
-      usedNames.add(name, getObjectPatternPropertyPatternTracker(prop.value))
+      if (name) {
+        usedNames.add(name, getObjectPatternPropertyPatternTracker(prop.value))
+      } else {
+        // If cannot trace name, everything is used!
+        return {
+          usedNames,
+          unknown: true
+        }
+      }
     } else {
       // If use RestElement, everything is used!
       return {
@@ -206,8 +199,6 @@ function getObjectPatternPropertyPatternTracker(pattern) {
         return result
       }
       for (const reference of variable.references) {
-        /** @type {Identifier} */
-        // @ts-ignore
         const id = reference.identifier
         const { usedNames, unknown, calls } = extractPatternOrThisProperties(
           id,
@@ -259,8 +250,6 @@ function extractPatternOrThisProperties(node, context) {
           return result
         }
         for (const reference of variable.references) {
-          /** @type {Identifier} */
-          // @ts-ignore
           const id = reference.identifier
           const { usedNames, unknown, calls } = extractPatternOrThisProperties(
             id,
@@ -287,7 +276,6 @@ function extractPatternOrThisProperties(node, context) {
     }
     return result
   } else if (parent.type === 'CallExpression') {
-    // @ts-ignore
     const argIndex = parent.arguments.indexOf(node)
     if (argIndex > -1 && parent.callee.type === 'Identifier') {
       // `foo(arg)`
@@ -299,13 +287,12 @@ function extractPatternOrThisProperties(node, context) {
         const def = calleeVariable.defs[0]
         if (
           def.type === 'Variable' &&
-          def.parent &&
           def.parent.kind === 'const' &&
+          def.node.init &&
           (def.node.init.type === 'FunctionExpression' ||
             def.node.init.type === 'ArrowFunctionExpression')
         ) {
           result.calls.push({
-            // @ts-ignore
             node: def.node.init,
             index: argIndex
           })
@@ -338,12 +325,14 @@ class UsedProps {
  */
 class ParamUsedProps extends UsedProps {
   /**
-   * @param {ASTNode} paramNode
+   * @param {Pattern} paramNode
    * @param {RuleContext} context
    */
   constructor(paramNode, context) {
     super()
-
+    while (paramNode.type === 'AssignmentPattern') {
+      paramNode = paramNode.left
+    }
     if (paramNode.type === 'RestElement' || paramNode.type === 'ArrayPattern') {
       // cannot check
       return
@@ -354,13 +343,14 @@ class ParamUsedProps extends UsedProps {
       this.unknown = this.unknown || unknown
       return
     }
+    if (paramNode.type !== 'Identifier') {
+      return
+    }
     const variable = findVariable(context, paramNode)
     if (!variable) {
       return
     }
     for (const reference of variable.references) {
-      /** @type {Identifier} */
-      // @ts-ignore
       const id = reference.identifier
       const { usedNames, unknown, calls } = extractPatternOrThisProperties(
         id,
@@ -390,7 +380,7 @@ class ParamsUsedProps {
 
   /**
    * @param {number} index
-   * @returns {ParamUsedProps}
+   * @returns {ParamUsedProps | null}
    */
   getParam(index) {
     const param = this.params[index]
@@ -446,7 +436,7 @@ module.exports = {
       unused: "'{{name}}' of {{group}} found, but never used."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const groups = new Set(options.groups || [GROUP_PROPERTY])
@@ -607,7 +597,9 @@ module.exports = {
           const container = getVueComponentPropertiesContainer(vueData.node)
           if (node.params[0]) {
             const paramsUsedProps = getParamsUsedProps(node)
-            const paramUsedProps = paramsUsedProps.getParam(0)
+            const paramUsedProps = /** @type {ParamUsedProps} */ (paramsUsedProps.getParam(
+              0
+            ))
 
             processParamPropsUsed(container, paramUsedProps)
           }
@@ -617,7 +609,9 @@ module.exports = {
           if (node.params[0]) {
             // for Vue 3.x render
             const paramsUsedProps = getParamsUsedProps(node)
-            const paramUsedProps = paramsUsedProps.getParam(0)
+            const paramUsedProps = /** @type {ParamUsedProps} */ (paramsUsedProps.getParam(
+              0
+            ))
 
             processParamPropsUsed(container, paramUsedProps)
             if (container.unknownProps) {
@@ -628,7 +622,9 @@ module.exports = {
           if (vueData.functional && node.params[1]) {
             // for Vue 2.x render & functional
             const paramsUsedProps = getParamsUsedProps(node)
-            const paramUsedProps = paramsUsedProps.getParam(1)
+            const paramUsedProps = /** @type {ParamUsedProps} */ (paramsUsedProps.getParam(
+              1
+            ))
 
             for (const { usedNames, unknown } of iterateUsedProps(
               paramUsedProps
@@ -647,6 +643,10 @@ module.exports = {
             }
           }
         },
+        /**
+         * @param {ThisExpression | Identifier} node
+         * @param {VueObjectData} vueData
+         */
         'ThisExpression, Identifier'(node, vueData) {
           if (!utils.isThis(node, context)) {
             return
@@ -666,6 +666,7 @@ module.exports = {
         }
       }),
       {
+        /** @param {Program} node */
         'Program:exit'(node) {
           if (!node.templateBody) {
             reportUnusedProperties()
diff --git a/lib/rules/no-unused-vars.js b/lib/rules/no-unused-vars.js
index e808ee7f9..a9939c1ae 100644
--- a/lib/rules/no-unused-vars.js
+++ b/lib/rules/no-unused-vars.js
@@ -7,12 +7,7 @@
 const utils = require('../utils')
 
 /**
- * @typedef {import('vue-eslint-parser').AST.Node} Node
- * @typedef {import('vue-eslint-parser').AST.VElement} VElement
- * @typedef {import('vue-eslint-parser').AST.Variable} Variable
- */
-/**
- * @typedef {Variable['kind']} VariableKind
+ * @typedef {VVariable['kind']} VariableKind
  */
 
 // ------------------------------------------------------------------------------
@@ -22,10 +17,10 @@ const utils = require('../utils')
 /**
  * Groups variables by directive kind.
  * @param {VElement} node The element node
- * @returns { { [kind in VariableKind]?: Variable[] } } The variables of grouped by directive kind.
+ * @returns { { [kind in VariableKind]?: VVariable[] } } The variables of grouped by directive kind.
  */
 function groupingVariables(node) {
-  /** @type { { [kind in VariableKind]?: Variable[] } } */
+  /** @type { { [kind in VariableKind]?: VVariable[] } } */
   const result = {}
   for (const variable of node.variables) {
     const vars = result[variable.kind] || (result[variable.kind] = [])
@@ -36,12 +31,12 @@ function groupingVariables(node) {
 
 /**
  * Checks if the given variable was defined by destructuring.
- * @param {Variable} variable the given variable to check
+ * @param {VVariable} variable the given variable to check
  * @returns {boolean} `true` if the given variable was defined by destructuring.
  */
 function isDestructuringVar(variable) {
   const node = variable.id
-  /** @type {Node} */
+  /** @type {ASTNode | null} */
   let parent = node.parent
   while (parent) {
     if (
@@ -84,10 +79,11 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const option = context.options[0] || {}
     const ignorePattern = option.ignorePattern
+    /** @type {RegExp | null} */
     let ignoreRegEx = null
     if (ignorePattern) {
       ignoreRegEx = new RegExp(ignorePattern, 'u')
@@ -99,6 +95,9 @@ module.exports = {
       VElement(node) {
         const vars = groupingVariables(node)
         for (const variables of Object.values(vars)) {
+          if (!variables) {
+            continue
+          }
           let hasAfterUsed = false
 
           for (let i = variables.length - 1; i >= 0; i--) {
@@ -122,7 +121,9 @@ module.exports = {
               node: variable.id,
               loc: variable.id.loc,
               message: `'{{name}}' is defined but never used.`,
-              data: variable.id,
+              data: {
+                name: variable.id.name
+              },
               suggest:
                 ignorePattern === '^_'
                   ? [
diff --git a/lib/rules/no-use-v-if-with-v-for.js b/lib/rules/no-use-v-if-with-v-for.js
index a12fda3c9..0cc4aba49 100644
--- a/lib/rules/no-use-v-if-with-v-for.js
+++ b/lib/rules/no-use-v-if-with-v-for.js
@@ -20,14 +20,18 @@ const utils = require('../utils')
 
 /**
  * Check whether the given `v-if` node is using the variable which is defined by the `v-for` directive.
- * @param {ASTNode} vIf The `v-if` attribute node to check.
+ * @param {VDirective} vIf The `v-if` attribute node to check.
  * @returns {boolean} `true` if the `v-if` is using the variable which is defined by the `v-for` directive.
  */
 function isUsingIterationVar(vIf) {
   return !!getVForUsingIterationVar(vIf)
 }
 
+/** @param {VDirective} vIf */
 function getVForUsingIterationVar(vIf) {
+  if (!vIf.value) {
+    return null
+  }
   const element = vIf.parent.parent
   for (const reference of vIf.value.references) {
     const targetVFor = element.variables.find(
@@ -38,7 +42,7 @@ function getVForUsingIterationVar(vIf) {
       return targetVFor
     }
   }
-  return undefined
+  return null
 }
 
 // ------------------------------------------------------------------------------
@@ -65,11 +69,12 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const allowUsingIterationVar = options.allowUsingIterationVar === true // default false
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='if']"(node) {
         const element = node.parent.parent
 
@@ -77,10 +82,13 @@ module.exports = {
           if (isUsingIterationVar(node)) {
             if (!allowUsingIterationVar) {
               const vForVar = getVForUsingIterationVar(node)
+              if (!vForVar) {
+                return
+              }
 
               let targetVForExpr = vForVar.id.parent
               while (targetVForExpr.type !== 'VForExpression') {
-                targetVForExpr = targetVForExpr.parent
+                targetVForExpr = /** @type {ASTNode} */ (targetVForExpr.parent)
               }
               const iteratorNode = targetVForExpr.right
               context.report({
diff --git a/lib/rules/no-useless-mustaches.js b/lib/rules/no-useless-mustaches.js
index c10889a23..89d8d5422 100644
--- a/lib/rules/no-useless-mustaches.js
+++ b/lib/rules/no-useless-mustaches.js
@@ -6,15 +6,10 @@
 
 const utils = require('../utils')
 
-/**
- * @typedef {import('eslint').Rule.RuleContext} RuleContext
- * @typedef {import('vue-eslint-parser').AST.VExpressionContainer} VExpressionContainer
- */
-
 /**
  * Strip quotes string
  * @param {string} text
- * @returns {string}
+ * @returns {string|null}
  */
 function stripQuotesForHTML(text) {
   if (
@@ -76,13 +71,16 @@ module.exports = {
       if (!expression) {
         return
       }
-      let strValue, rawValue
+      /** @type {string} */
+      let strValue
+      /** @type {string} */
+      let rawValue
       if (expression.type === 'Literal') {
         if (typeof expression.value !== 'string') {
           return
         }
         strValue = expression.value
-        rawValue = expression.raw.slice(1, -1)
+        rawValue = sourceCode.getText(expression).slice(1, -1)
       } else if (expression.type === 'TemplateLiteral') {
         if (expression.expressions.length > 0) {
           return
@@ -127,7 +125,6 @@ module.exports = {
       }
 
       context.report({
-        // @ts-ignore
         node,
         messageId: 'unexpected',
         fix(fixer) {
@@ -135,7 +132,6 @@ module.exports = {
             // cannot fix
             return null
           }
-          context.parserServices.getDocumentFragment()
           const text = stripQuotesForHTML(sourceCode.getText(expression))
           if (text == null) {
             // unknowns
diff --git a/lib/rules/no-useless-v-bind.js b/lib/rules/no-useless-v-bind.js
index 2ffa71400..d64e95535 100644
--- a/lib/rules/no-useless-v-bind.js
+++ b/lib/rules/no-useless-v-bind.js
@@ -9,11 +9,6 @@ const utils = require('../utils')
 const DOUBLE_QUOTES_RE = /"/gu
 const SINGLE_QUOTES_RE = /'/gu
 
-/**
- * @typedef {import('eslint').Rule.RuleContext} RuleContext
- * @typedef {import('vue-eslint-parser').AST.VDirective} VDirective
- */
-
 module.exports = {
   meta: {
     docs: {
@@ -52,20 +47,24 @@ module.exports = {
      * @param {VDirective} node the node to check
      */
     function verify(node) {
-      if (!node.value || node.key.modifiers.length) {
+      const { value } = node
+      if (!value || node.key.modifiers.length) {
         return
       }
-      const { expression } = node.value
+      const { expression } = value
       if (!expression) {
         return
       }
-      let strValue, rawValue
+      /** @type {string} */
+      let strValue
+      /** @type {string} */
+      let rawValue
       if (expression.type === 'Literal') {
         if (typeof expression.value !== 'string') {
           return
         }
         strValue = expression.value
-        rawValue = expression.raw.slice(1, -1)
+        rawValue = sourceCode.getText(expression).slice(1, -1)
       } else if (expression.type === 'TemplateLiteral') {
         if (expression.expressions.length > 0) {
           return
@@ -78,7 +77,7 @@ module.exports = {
 
       const tokenStore = context.parserServices.getTemplateBodyTokenStore()
       const hasComment = tokenStore
-        .getTokens(node.value, { includeComments: true })
+        .getTokens(value, { includeComments: true })
         .some((t) => t.type === 'Block' || t.type === 'Line')
       if (ignoreIncludesComment && hasComment) {
         return
@@ -110,7 +109,6 @@ module.exports = {
       }
 
       context.report({
-        // @ts-ignore
         node,
         messageId: 'unexpected',
         fix(fixer) {
@@ -118,11 +116,11 @@ module.exports = {
             // cannot fix
             return null
           }
-          const text = sourceCode.getText(node.value)
+          const text = sourceCode.getText(value)
           const quoteChar = text[0]
 
           const shorthand = node.key.name.rawName === ':'
-          /** @type { [number, number] } */
+          /** @type {Range} */
           const keyDirectiveRange = [
             node.key.name.range[0],
             node.key.name.range[1] + (shorthand ? 0 : 1)
diff --git a/lib/rules/no-v-html.js b/lib/rules/no-v-html.js
index 24044c644..33a1bfa30 100644
--- a/lib/rules/no-v-html.js
+++ b/lib/rules/no-v-html.js
@@ -20,8 +20,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='html']"(node) {
         context.report({
           node,
diff --git a/lib/rules/no-v-model-argument.js b/lib/rules/no-v-model-argument.js
index 281aa9edf..615af912c 100644
--- a/lib/rules/no-v-model-argument.js
+++ b/lib/rules/no-v-model-argument.js
@@ -29,9 +29,10 @@ module.exports = {
       vModelRequireNoArgument: "'v-model' directives require no argument."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='model']"(node) {
         const element = node.parent.parent
 
diff --git a/lib/rules/no-watch-after-await.js b/lib/rules/no-watch-after-await.js
index 378a1138d..d9a8c3822 100644
--- a/lib/rules/no-watch-after-await.js
+++ b/lib/rules/no-watch-after-await.js
@@ -6,6 +6,9 @@
 const { ReferenceTracker } = require('eslint-utils')
 const utils = require('../utils')
 
+/**
+ * @param {CallExpression} node
+ */
 function isMaybeUsedStopHandle(node) {
   const parent = node.parent
   if (parent) {
@@ -47,11 +50,19 @@ module.exports = {
       forbidden: 'The `watch` after `await` expression are forbidden.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
     const watchCallNodes = new Set()
+    /** @type {Map<FunctionExpression | ArrowFunctionExpression | FunctionDeclaration, { setupProperty: Property, afterAwait: boolean }>} */
     const setupFunctions = new Map()
 
-    let scopeStack = { upper: null, functionNode: null }
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} upper
+     * @property {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} functionNode
+     */
+    /** @type {ScopeStack} */
+    let scopeStack
 
     return Object.assign(
       {
@@ -75,6 +86,7 @@ module.exports = {
         }
       },
       utils.defineVueVisitor(context, {
+        /** @param {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} node */
         ':function'(node) {
           scopeStack = { upper: scopeStack, functionNode: node }
         },
@@ -91,6 +103,7 @@ module.exports = {
           }
           setupFunctionData.afterAwait = true
         },
+        /** @param {CallExpression} node */
         CallExpression(node) {
           const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
           if (!setupFunctionData || !setupFunctionData.afterAwait) {
@@ -104,6 +117,7 @@ module.exports = {
             })
           }
         },
+        /** @param {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} node */
         ':function:exit'(node) {
           scopeStack = scopeStack.upper
 
diff --git a/lib/rules/one-component-per-file.js b/lib/rules/one-component-per-file.js
index cc1ce17df..619942c1d 100644
--- a/lib/rules/one-component-per-file.js
+++ b/lib/rules/one-component-per-file.js
@@ -23,7 +23,9 @@ module.exports = {
       toManyComponents: 'There is more than one component in this file.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
+    /** @type {ObjectExpression[]} */
     const components = []
 
     return Object.assign(
diff --git a/lib/rules/order-in-components.js b/lib/rules/order-in-components.js
index afdb17828..fcff89ab2 100644
--- a/lib/rules/order-in-components.js
+++ b/lib/rules/order-in-components.js
@@ -7,6 +7,10 @@
 const utils = require('../utils')
 const traverseNodes = require('vue-eslint-parser').AST.traverseNodes
 
+/**
+ * @typedef {import('eslint-visitor-keys').VisitorKeys} VisitorKeys
+ */
+
 const defaultOrder = [
   // Side Effects (triggers effects outside the component)
   'el',
@@ -71,6 +75,7 @@ const defaultOrder = [
   'renderError'
 ]
 
+/** @type { { [key: string]: string[] } } */
 const groups = {
   LIFECYCLE_HOOKS: [
     'beforeCreate',
@@ -92,7 +97,11 @@ const groups = {
   ROUTER_GUARDS: ['beforeRouteEnter', 'beforeRouteUpdate', 'beforeRouteLeave']
 }
 
+/**
+ * @param {(string | string[])[]} order
+ */
 function getOrderMap(order) {
+  /** @type {Map<string, number>} */
   const orderMap = new Map()
 
   order.forEach((property, i) => {
@@ -106,6 +115,9 @@ function getOrderMap(order) {
   return orderMap
 }
 
+/**
+ * @param {Token} node
+ */
 function isComma(node) {
   return node.type === 'Punctuator' && node.value === ','
 }
@@ -114,15 +126,15 @@ const ARITHMETIC_OPERATORS = ['+', '-', '*', '/', '%', '**' /* es2016 */]
 const BITWISE_OPERATORS = ['&', '|', '^', '~', '<<', '>>', '>>>']
 const COMPARISON_OPERATORS = ['==', '!=', '===', '!==', '>', '>=', '<', '<=']
 const RELATIONAL_OPERATORS = ['in', 'instanceof']
-const ALL_BINARY_OPERATORS = [].concat(
-  ARITHMETIC_OPERATORS,
-  BITWISE_OPERATORS,
-  COMPARISON_OPERATORS,
-  RELATIONAL_OPERATORS
-)
+const ALL_BINARY_OPERATORS = [
+  ...ARITHMETIC_OPERATORS,
+  ...BITWISE_OPERATORS,
+  ...COMPARISON_OPERATORS,
+  ...RELATIONAL_OPERATORS
+]
 const LOGICAL_OPERATORS = ['&&', '||', '??' /* es2020 */]
 
-/*
+/**
  * Result `true` if the node is sure that there are no side effects
  *
  * Currently known side effects types
@@ -135,12 +147,13 @@ const LOGICAL_OPERATORS = ['&&', '||', '??' /* es2020 */]
  * node.type === 'UnaryExpression' && node.operator === 'delete'
  *
  * @param  {ASTNode} node target node
- * @param  {Object} visitorKeys sourceCode.visitorKey
- * @returns {Boolean} no side effects
+ * @param  {VisitorKeys} visitorKeys sourceCode.visitorKey
+ * @returns {boolean} no side effects
  */
 function isNotSideEffectsNode(node, visitorKeys) {
   let result = true
-  let skipNode = false
+  /** @type {ASTNode | null} */
+  let skipNode = null
   traverseNodes(node, {
     visitorKeys,
     enterNode(node) {
@@ -213,33 +226,63 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
+    /** @type {(string|string[])[]} */
     const order = options.order || defaultOrder
-    const extendedOrder = order.map((property) => groups[property] || property)
+    /** @type {(string|string[])[]} */
+    const extendedOrder = order.map(
+      (property) =>
+        (typeof property === 'string' && groups[property]) || property
+    )
     const orderMap = getOrderMap(extendedOrder)
     const sourceCode = context.getSourceCode()
 
-    function checkOrder(propertiesNodes, orderMap) {
+    /**
+     * @param {string} name
+     */
+    function getOrderPosition(name) {
+      const num = orderMap.get(name)
+      return num == null ? -1 : num
+    }
+
+    /**
+     * @param {(Property | SpreadElement)[]} propertiesNodes
+     */
+    function checkOrder(propertiesNodes) {
       const properties = propertiesNodes
-        .filter((property) => property.type === 'Property')
-        .map((property) => property.key)
+        .filter(utils.isProperty)
+        .map((property) => {
+          return {
+            node: property,
+            name:
+              utils.getStaticPropertyName(property) ||
+              (property.key.type === 'Identifier' && property.key.name) ||
+              ''
+          }
+        })
 
       properties.forEach((property, i) => {
+        const orderPos = getOrderPosition(property.name)
+        if (orderPos < 0) {
+          return
+        }
         const propertiesAbove = properties.slice(0, i)
         const unorderedProperties = propertiesAbove
-          .filter((p) => orderMap.get(p.name) > orderMap.get(property.name))
+          .filter(
+            (p) => getOrderPosition(p.name) > getOrderPosition(property.name)
+          )
           .sort((p1, p2) =>
-            orderMap.get(p1.name) > orderMap.get(p2.name) ? 1 : -1
+            getOrderPosition(p1.name) > getOrderPosition(p2.name) ? 1 : -1
           )
 
         const firstUnorderedProperty = unorderedProperties[0]
 
         if (firstUnorderedProperty) {
-          const line = firstUnorderedProperty.loc.start.line
+          const line = firstUnorderedProperty.node.loc.start.line
           context.report({
-            node: property,
+            node: property.node,
             message: `The "{{name}}" property should be above the "{{firstUnorderedPropertyName}}" property on line {{line}}.`,
             data: {
               name: property.name,
@@ -247,8 +290,8 @@ module.exports = {
               line
             },
             fix(fixer) {
-              const propertyNode = property.parent
-              const firstUnorderedPropertyNode = firstUnorderedProperty.parent
+              const propertyNode = property.node
+              const firstUnorderedPropertyNode = firstUnorderedProperty.node
               const hasSideEffectsPossibility = propertiesNodes
                 .slice(
                   propertiesNodes.indexOf(firstUnorderedPropertyNode),
@@ -259,7 +302,7 @@ module.exports = {
                     !isNotSideEffectsNode(property, sourceCode.visitorKeys)
                 )
               if (hasSideEffectsPossibility) {
-                return undefined
+                return null
               }
               const afterComma = sourceCode.getTokenAfter(propertyNode)
               const hasAfterComma = isComma(afterComma)
@@ -292,7 +335,7 @@ module.exports = {
     }
 
     return utils.executeOnVue(context, (obj) => {
-      checkOrder(obj.properties, orderMap)
+      checkOrder(obj.properties)
     })
   }
 }
diff --git a/lib/rules/padding-line-between-blocks.js b/lib/rules/padding-line-between-blocks.js
index 0fb5ee8d5..b9215e2c9 100644
--- a/lib/rules/padding-line-between-blocks.js
+++ b/lib/rules/padding-line-between-blocks.js
@@ -30,7 +30,9 @@ function verifyForNever(context, prevBlock, nextBlock, betweenTokens) {
     return
   }
   const tokenOrNodes = [...betweenTokens, nextBlock]
+  /** @type {ASTNode | Token} */
   let prev = prevBlock
+  /** @type {[ASTNode | Token, ASTNode | Token][]} */
   const paddingLines = []
   for (const tokenOrNode of tokenOrNodes) {
     const numOfLineBreaks = tokenOrNode.loc.start.line - prev.loc.end.line
@@ -70,7 +72,9 @@ function verifyForNever(context, prevBlock, nextBlock, betweenTokens) {
  */
 function verifyForAlways(context, prevBlock, nextBlock, betweenTokens) {
   const tokenOrNodes = [...betweenTokens, nextBlock]
+  /** @type {ASTNode | Token} */
   let prev = prevBlock
+  /** @type {ASTNode | Token | undefined} */
   let linebreak
   for (const tokenOrNode of tokenOrNodes) {
     const numOfLineBreaks = tokenOrNode.loc.start.line - prev.loc.end.line
@@ -130,20 +134,30 @@ module.exports = {
       always: 'Expected blank line before this block.'
     }
   },
+  /** @param {RuleContext} context */
   create(context) {
-    const paddingType = PaddingTypes[context.options[0] || 'always']
-    const documentFragment =
-      context.parserServices.getDocumentFragment &&
-      context.parserServices.getDocumentFragment()
+    if (!context.parserServices.getDocumentFragment) {
+      return {}
+    }
+    /** @type {'always' | 'never'} */
+    const option = context.options[0] || 'always'
+    const paddingType = PaddingTypes[option]
+
+    const documentFragment = context.parserServices.getDocumentFragment()
 
+    /** @type {Token[]} */
     let tokens
+    /**
+     * @returns {VElement[]}
+     */
     function getTopLevelHTMLElements() {
-      if (documentFragment) {
-        return documentFragment.children.filter((e) => e.type === 'VElement')
-      }
-      return []
+      return documentFragment.children.filter(utils.isVElement)
     }
 
+    /**
+     * @param {VElement} prev
+     * @param {VElement} next
+     */
     function getTokenAndCommentsBetween(prev, next) {
       // When there is no <template>, tokenStore.getTokensBetween cannot be used.
       if (!tokens) {
@@ -179,6 +193,7 @@ module.exports = {
       context,
       {},
       {
+        /** @param {Program} node */
         Program(node) {
           if (utils.hasInvalidEOF(node)) {
             return
@@ -187,6 +202,9 @@ module.exports = {
 
           let prev = elements.shift()
           for (const element of elements) {
+            if (!prev) {
+              return
+            }
             const betweenTokens = getTokenAndCommentsBetween(prev, element)
             paddingType.verify(context, prev, element, betweenTokens)
             prev = element
diff --git a/lib/rules/prop-name-casing.js b/lib/rules/prop-name-casing.js
index 3ea2864cd..826197313 100644
--- a/lib/rules/prop-name-casing.js
+++ b/lib/rules/prop-name-casing.js
@@ -11,7 +11,7 @@ const allowedCaseOptions = ['camelCase', 'snake_case']
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
-
+/** @param {RuleContext} context */
 function create(context) {
   const options = context.options[0]
   const caseType =
@@ -23,18 +23,19 @@ function create(context) {
   // ----------------------------------------------------------------------
 
   return utils.executeOnVue(context, (obj) => {
-    const props = utils
-      .getComponentProps(obj)
-      .filter(
-        (prop) =>
-          prop.key &&
-          (prop.key.type === 'Literal' ||
-            (prop.key.type === 'Identifier' && !prop.node.computed))
-      )
-
-    for (const item of props) {
+    for (const item of utils.getComponentProps(obj)) {
+      if (item.propName == null) {
+        continue
+      }
       const propName =
-        item.key.type === 'Literal' ? item.key.value : item.key.name
+        item.key.type === 'Literal'
+          ? item.key.value
+          : item.key.type === 'TemplateLiteral'
+          ? null
+          : item.propName
+      // TODO We should use propName.
+      // const propName = item.propName
+
       if (typeof propName !== 'string') {
         // (boolean | null | number | RegExp) Literal
         continue
diff --git a/lib/rules/require-component-is.js b/lib/rules/require-component-is.js
index 0ddab6551..12fda302b 100644
--- a/lib/rules/require-component-is.js
+++ b/lib/rules/require-component-is.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VElement} node */
       "VElement[name='component']"(node) {
         if (!utils.hasDirective(node, 'bind', 'is')) {
           context.report({
diff --git a/lib/rules/require-default-prop.js b/lib/rules/require-default-prop.js
index 02ed48238..ff014ca8f 100644
--- a/lib/rules/require-default-prop.js
+++ b/lib/rules/require-default-prop.js
@@ -4,11 +4,6 @@
  */
 'use strict'
 
-/**
- * @typedef {import('vue-eslint-parser').AST.ESLintExpression} Expression
- * @typedef {import('vue-eslint-parser').AST.ESLintObjectExpression} ObjectExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintPattern} Pattern
- */
 /**
  * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
  * @typedef {ComponentObjectProp & { value: ObjectExpression} } ComponentObjectPropObject
@@ -41,7 +36,7 @@ module.exports = {
     fixable: null, // or "code" or "whitespace"
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     // ----------------------------------------------------------------------
     // Helpers
@@ -155,7 +150,6 @@ module.exports = {
         .getComponentProps(obj)
         .filter(
           (prop) =>
-            prop.key &&
             prop.value &&
             !(prop.node.type === 'Property' && prop.node.shorthand)
         )
@@ -169,7 +163,7 @@ module.exports = {
         const propName =
           prop.propName != null
             ? prop.propName
-            : `[${context.getSourceCode().getText(prop.key)}]`
+            : `[${context.getSourceCode().getText(prop.node.key)}]`
 
         context.report({
           node: prop.node,
diff --git a/lib/rules/require-direct-export.js b/lib/rules/require-direct-export.js
index 472a01846..4464569ff 100644
--- a/lib/rules/require-direct-export.js
+++ b/lib/rules/require-direct-export.js
@@ -6,13 +6,6 @@
 
 const utils = require('../utils')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.ESLintExportDefaultDeclaration} ExportDefaultDeclaration
- * @typedef {import('vue-eslint-parser').AST.ESLintDeclaration} Declaration
- * @typedef {import('vue-eslint-parser').AST.ESLintExpression} Expression
- * @typedef {import('vue-eslint-parser').AST.ESLintReturnStatement} ReturnStatement
- *
- */
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -36,7 +29,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const filePath = context.getFilename()
     if (!utils.isVueFile(filePath)) return {}
@@ -44,8 +37,16 @@ module.exports = {
     const disallowFunctional = (context.options[0] || {})
       .disallowFunctionalComponentFunction
 
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} upper
+     * @property {boolean} withinVue3FunctionalBody
+     */
+
+    /** @type { { body: BlockStatement, hasReturnArgument: boolean } } */
     let maybeVue3Functional
-    let scopeStack = null
+    /** @type {ScopeStack} */
+    let scopeStack
 
     return {
       /** @param {Declaration | Expression} node */
@@ -61,7 +62,8 @@ module.exports = {
               return
             }
             maybeVue3Functional = {
-              body: node.body
+              body: node.body,
+              hasReturnArgument: false
             }
             return
           }
@@ -70,7 +72,8 @@ module.exports = {
             node.type === 'FunctionDeclaration'
           ) {
             maybeVue3Functional = {
-              body: node.body
+              body: node.body,
+              hasReturnArgument: false
             }
             return
           }
@@ -84,6 +87,7 @@ module.exports = {
       ...(disallowFunctional
         ? {}
         : {
+            /** @param {BlockStatement} node */
             ':function > BlockStatement'(node) {
               if (!maybeVue3Functional) {
                 return
@@ -103,7 +107,7 @@ module.exports = {
                 maybeVue3Functional.hasReturnArgument = true
               }
             },
-            ':function > BlockStatement:exit'(node) {
+            ':function > BlockStatement:exit'() {
               scopeStack = scopeStack && scopeStack.upper
             },
             /** @param {ExportDefaultDeclaration} node */
diff --git a/lib/rules/require-explicit-emits.js b/lib/rules/require-explicit-emits.js
index 034921622..7dc1706bb 100644
--- a/lib/rules/require-explicit-emits.js
+++ b/lib/rules/require-explicit-emits.js
@@ -5,11 +5,9 @@
 'use strict'
 
 /**
- * @typedef {import('vue-eslint-parser').AST.ESLintLiteral} Literal
- * @typedef {import('vue-eslint-parser').AST.ESLintProperty} Property
- * @typedef {import('vue-eslint-parser').AST.ESLintObjectExpression} ObjectExpression
  * @typedef {import('../utils').ComponentArrayEmit} ComponentArrayEmit
  * @typedef {import('../utils').ComponentObjectEmit} ComponentObjectEmit
+ * @typedef {import('../utils').VueObjectData} VueObjectData
  */
 
 // ------------------------------------------------------------------------------
@@ -102,11 +100,12 @@ module.exports = {
         'Add the `emits` option with object syntax and define "{{name}}" event.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     /** @typedef { { node: Literal, name: string } } EmitCellName */
-
+    /** @type {Map<ObjectExpression, { contextReferenceIds: Set<Identifier>, emitReferenceIds: Set<Identifier> }>} */
     const setupContexts = new Map()
+    /** @type {Map<ObjectExpression, (ComponentArrayEmit | ComponentObjectEmit)[]>} */
     const vueEmitsDeclarations = new Map()
 
     /** @type {EmitCellName[]} */
@@ -114,15 +113,23 @@ module.exports = {
     /** @type { { type: 'export' | 'mark' | 'definition', object: ObjectExpression, emits: (ComponentArrayEmit | ComponentObjectEmit)[] } | null } */
     let vueObjectData = null
 
+    /**
+     * @param {Literal} nameLiteralNode
+     */
     function addTemplateEmitCellName(nameLiteralNode) {
       templateEmitCellNames.push({
         node: nameLiteralNode,
-        name: nameLiteralNode.value
+        name: `${nameLiteralNode.value}`
       })
     }
 
+    /**
+     * @param {(ComponentArrayEmit | ComponentObjectEmit)[]} emitsDeclarations
+     * @param {Literal} nameLiteralNode
+     * @param {ObjectExpression} vueObjectNode
+     */
     function verify(emitsDeclarations, nameLiteralNode, vueObjectNode) {
-      const name = nameLiteralNode.value
+      const name = `${nameLiteralNode.value}`
       if (emitsDeclarations.some((e) => e.emitName === name)) {
         return
       }
@@ -144,9 +151,10 @@ module.exports = {
     return utils.defineTemplateBodyVisitor(
       context,
       {
+        /** @param { CallExpression & { argument: [Literal, ...Expression] } } node */
         'CallExpression[arguments.0.type=Literal]'(node) {
           const callee = node.callee
-          const nameLiteralNode = node.arguments[0]
+          const nameLiteralNode = /** @type {Literal} */ (node.arguments[0])
           if (!nameLiteralNode || typeof nameLiteralNode.value !== 'string') {
             // cannot check
             return
@@ -201,20 +209,24 @@ module.exports = {
             // cannot check
             return
           }
+          /** @type {Set<Identifier>} */
           const contextReferenceIds = new Set()
+          /** @type {Set<Identifier>} */
           const emitReferenceIds = new Set()
           if (contextParam.type === 'ObjectPattern') {
-            const emitProperty = contextParam.properties.find(
-              (p) =>
-                p.type === 'Property' &&
-                utils.getStaticPropertyName(p) === 'emit'
+            const emitProperty = utils.findAssignmentProperty(
+              contextParam,
+              'emit'
             )
             if (!emitProperty) {
               return
             }
             const emitParam = emitProperty.value
             // `setup(props, {emit})`
-            const variable = findVariable(context.getScope(), emitParam)
+            const variable =
+              emitParam.type === 'Identifier'
+                ? findVariable(context.getScope(), emitParam)
+                : null
             if (!variable) {
               return
             }
@@ -225,7 +237,7 @@ module.exports = {
 
               emitReferenceIds.add(reference.identifier)
             }
-          } else {
+          } else if (contextParam.type === 'Identifier') {
             // `setup(props, context)`
             const variable = findVariable(context.getScope(), contextParam)
             if (!variable) {
@@ -244,6 +256,10 @@ module.exports = {
             emitReferenceIds
           })
         },
+        /**
+         * @param {CallExpression & { arguments: [Literal, ...Expression] }} node
+         * @param {VueObjectData} data
+         */
         'CallExpression[arguments.0.type=Literal]'(node, { node: vueNode }) {
           const callee = node.callee
           const nameLiteralNode = node.arguments[0]
@@ -252,6 +268,9 @@ module.exports = {
             return
           }
           const emitsDeclarations = vueEmitsDeclarations.get(vueNode)
+          if (!emitsDeclarations) {
+            return
+          }
 
           let emit
           if (callee.type === 'MemberExpression') {
@@ -265,12 +284,13 @@ module.exports = {
           const setupContext = setupContexts.get(vueNode)
           if (setupContext) {
             const { contextReferenceIds, emitReferenceIds } = setupContext
-            if (emitReferenceIds.has(callee)) {
+            if (callee.type === 'Identifier' && emitReferenceIds.has(callee)) {
               // verify setup(props,{emit}) {emit()}
               verify(emitsDeclarations, nameLiteralNode, vueNode)
             } else if (
               emit &&
               emit.name === 'emit' &&
+              emit.member.object.type === 'Identifier' &&
               contextReferenceIds.has(emit.member.object)
             ) {
               // verify setup(props,context) {context.emit()}
@@ -287,11 +307,17 @@ module.exports = {
           }
         },
         onVueObjectExit(node, { type }) {
+          const emits = vueEmitsDeclarations.get(node)
           if (!vueObjectData || vueObjectData.type !== 'export') {
-            vueObjectData = {
-              type,
-              object: node,
-              emits: vueEmitsDeclarations.get(node)
+            if (
+              emits &&
+              (type === 'mark' || type === 'export' || type === 'definition')
+            ) {
+              vueObjectData = {
+                type,
+                object: node,
+                emits
+              }
             }
           }
           setupContexts.delete(node)
@@ -307,6 +333,7 @@ module.exports = {
  * @param {(ComponentArrayEmit | ComponentObjectEmit)[]} emits
  * @param {Literal} nameNode
  * @param {RuleContext} context
+ * @returns {Rule.SuggestionReportDescriptor[]}
  */
 function buildSuggest(object, emits, nameNode, context) {
   const certainEmits = emits.filter((e) => e.key)
@@ -315,7 +342,7 @@ function buildSuggest(object, emits, nameNode, context) {
     return [
       {
         messageId: 'addOneOption',
-        data: { name: nameNode.value },
+        data: { name: `${nameNode.value}` },
         fix(fixer) {
           if (last.value === null) {
             // Array
@@ -332,9 +359,7 @@ function buildSuggest(object, emits, nameNode, context) {
     ]
   }
 
-  const propertyNodes = object.properties.filter(
-    (p) => p.type === 'Property' && p.key.type === 'Identifier'
-  )
+  const propertyNodes = object.properties.filter(utils.isProperty)
 
   const emitsOption = propertyNodes.find(
     (p) => utils.getStaticPropertyName(p) === 'emits'
@@ -343,14 +368,14 @@ function buildSuggest(object, emits, nameNode, context) {
     const sourceCode = context.getSourceCode()
     const emitsOptionValue = emitsOption.value
     if (emitsOptionValue.type === 'ArrayExpression') {
-      const leftBracket = sourceCode.getFirstToken(
+      const leftBracket = /** @type {Token} */ (sourceCode.getFirstToken(
         emitsOptionValue,
         isLeftBracket
-      )
+      ))
       return [
         {
           messageId: 'addOneOption',
-          data: { name: nameNode.value },
+          data: { name: `${nameNode.value}` },
           fix(fixer) {
             return fixer.insertTextAfter(
               leftBracket,
@@ -362,11 +387,14 @@ function buildSuggest(object, emits, nameNode, context) {
         }
       ]
     } else if (emitsOptionValue.type === 'ObjectExpression') {
-      const leftBrace = sourceCode.getFirstToken(emitsOptionValue, isLeftBrace)
+      const leftBrace = /** @type {Token} */ (sourceCode.getFirstToken(
+        emitsOptionValue,
+        isLeftBrace
+      ))
       return [
         {
           messageId: 'addOneOption',
-          data: { name: nameNode.value },
+          data: { name: `${nameNode.value}` },
           fix(fixer) {
             return fixer.insertTextAfter(
               leftBrace,
@@ -383,12 +411,12 @@ function buildSuggest(object, emits, nameNode, context) {
 
   const sourceCode = context.getSourceCode()
   const afterOptionNode = propertyNodes.find((p) =>
-    FIX_EMITS_AFTER_OPTIONS.includes(utils.getStaticPropertyName(p))
+    FIX_EMITS_AFTER_OPTIONS.includes(utils.getStaticPropertyName(p) || '')
   )
   return [
     {
       messageId: 'addArrayEmitsOption',
-      data: { name: nameNode.value },
+      data: { name: `${nameNode.value}` },
       fix(fixer) {
         if (afterOptionNode) {
           return fixer.insertTextAfter(
@@ -404,8 +432,14 @@ function buildSuggest(object, emits, nameNode, context) {
             `,\nemits: ['${nameNode.value}']`
           )
         } else {
-          const objectLeftBrace = sourceCode.getFirstToken(object, isLeftBrace)
-          const objectRightBrace = sourceCode.getLastToken(object, isRightBrace)
+          const objectLeftBrace = /** @type {Token} */ (sourceCode.getFirstToken(
+            object,
+            isLeftBrace
+          ))
+          const objectRightBrace = /** @type {Token} */ (sourceCode.getLastToken(
+            object,
+            isRightBrace
+          ))
           return fixer.insertTextAfter(
             objectLeftBrace,
             `\nemits: ['${nameNode.value}']${
@@ -419,7 +453,7 @@ function buildSuggest(object, emits, nameNode, context) {
     },
     {
       messageId: 'addObjectEmitsOption',
-      data: { name: nameNode.value },
+      data: { name: `${nameNode.value}` },
       fix(fixer) {
         if (afterOptionNode) {
           return fixer.insertTextAfter(
@@ -435,8 +469,14 @@ function buildSuggest(object, emits, nameNode, context) {
             `,\nemits: {'${nameNode.value}': null}`
           )
         } else {
-          const objectLeftBrace = sourceCode.getFirstToken(object, isLeftBrace)
-          const objectRightBrace = sourceCode.getLastToken(object, isRightBrace)
+          const objectLeftBrace = /** @type {Token} */ (sourceCode.getFirstToken(
+            object,
+            isLeftBrace
+          ))
+          const objectRightBrace = /** @type {Token} */ (sourceCode.getLastToken(
+            object,
+            isRightBrace
+          ))
           return fixer.insertTextAfter(
             objectLeftBrace,
             `\nemits: {'${nameNode.value}': null}${
diff --git a/lib/rules/require-name-property.js b/lib/rules/require-name-property.js
index cf25b4aec..e8930ceb4 100644
--- a/lib/rules/require-name-property.js
+++ b/lib/rules/require-name-property.js
@@ -6,8 +6,16 @@
 
 const utils = require('../utils')
 
+/**
+ * @param {Property | SpreadElement} node
+ * @returns {node is ObjectExpressionProperty}
+ */
 function isNameProperty(node) {
-  return node.type === 'Property' && node.key.name === 'name' && !node.computed
+  return (
+    node.type === 'Property' &&
+    utils.getStaticPropertyName(node) === 'name' &&
+    !node.computed
+  )
 }
 
 module.exports = {
@@ -21,7 +29,7 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.executeOnVue(context, (component) => {
       if (component.properties.some(isNameProperty)) return
diff --git a/lib/rules/require-prop-type-constructor.js b/lib/rules/require-prop-type-constructor.js
index 74a7d5d4c..1104c7a33 100644
--- a/lib/rules/require-prop-type-constructor.js
+++ b/lib/rules/require-prop-type-constructor.js
@@ -19,8 +19,15 @@ const forbiddenTypes = [
   'UpdateExpression'
 ]
 
-const isForbiddenType = (node) =>
-  forbiddenTypes.indexOf(node.type) > -1 && node.raw !== 'null'
+/**
+ * @param {ESNode} node
+ */
+function isForbiddenType(node) {
+  return (
+    forbiddenTypes.indexOf(node.type) > -1 &&
+    !(node.type === 'Literal' && node.value == null && !node.bigint)
+  )
+}
 
 module.exports = {
   meta: {
@@ -34,74 +41,55 @@ module.exports = {
     schema: []
   },
 
+  /** @param {RuleContext} context */
   create(context) {
-    const fix = (node) => (fixer) => {
-      let newText
-      if (node.type === 'Literal') {
-        if (typeof node.value !== 'string') {
-          return undefined
-        }
-        newText = node.value
-      } else if (
-        node.type === 'TemplateLiteral' &&
-        node.expressions.length === 0 &&
-        node.quasis.length === 1
-      ) {
-        newText = node.quasis[0].value.cooked
-      } else {
-        return undefined
-      }
-      if (newText) {
-        return fixer.replaceText(node, newText)
-      }
-    }
+    /**
+     * @param {string} propName
+     * @param {ESNode} node
+     */
+    function checkPropertyNode(propName, node) {
+      /** @type {ESNode[]} */
+      const nodes = node.type === 'ArrayExpression' ? node.elements : [node]
 
-    const checkPropertyNode = (key, node) => {
-      if (isForbiddenType(node)) {
-        context.report({
-          node,
-          message,
-          data: {
-            name: utils.getStaticPropertyName(key)
-          },
-          fix: fix(node)
-        })
-      } else if (node.type === 'ArrayExpression') {
-        node.elements
-          .filter((prop) => prop && isForbiddenType(prop))
-          .forEach((prop) =>
-            context.report({
-              node: prop,
-              message,
-              data: {
-                name: utils.getStaticPropertyName(key)
-              },
-              fix: fix(prop)
-            })
-          )
-      }
+      nodes
+        .filter((prop) => prop && isForbiddenType(prop))
+        .forEach((prop) =>
+          context.report({
+            node: prop,
+            message,
+            data: {
+              name: propName
+            },
+            fix: (fixer) => {
+              if (prop.type === 'Literal' || prop.type === 'TemplateLiteral') {
+                const newText = utils.getStringLiteralValue(prop, true)
+
+                if (newText) {
+                  return fixer.replaceText(prop, newText)
+                }
+              }
+              return null
+            }
+          })
+        )
     }
 
     return utils.executeOnVueComponent(context, (obj) => {
-      const props = utils
-        .getComponentProps(obj)
-        .filter((prop) => prop.key && prop.value)
-
-      for (const prop of props) {
+      for (const prop of utils.getComponentProps(obj)) {
+        if (!prop.value || prop.propName == null) {
+          continue
+        }
         if (
           isForbiddenType(prop.value) ||
           prop.value.type === 'ArrayExpression'
         ) {
-          checkPropertyNode(prop.key, prop.value)
+          checkPropertyNode(prop.propName, prop.value)
         } else if (prop.value.type === 'ObjectExpression') {
-          const typeProperty = prop.value.properties.find(
-            (property) =>
-              property.type === 'Property' && property.key.name === 'type'
-          )
+          const typeProperty = utils.findProperty(prop.value, 'type')
 
           if (!typeProperty) continue
 
-          checkPropertyNode(prop.key, typeProperty.value)
+          checkPropertyNode(prop.propName, typeProperty.value)
         }
       }
     })
diff --git a/lib/rules/require-prop-types.js b/lib/rules/require-prop-types.js
index 0fe880aee..17037853f 100644
--- a/lib/rules/require-prop-types.js
+++ b/lib/rules/require-prop-types.js
@@ -6,6 +6,11 @@
 
 const utils = require('../utils')
 
+/**
+ * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
+ * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ */
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -23,25 +28,35 @@ module.exports = {
       // fill in your schema
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     // ----------------------------------------------------------------------
     // Helpers
     // ----------------------------------------------------------------------
 
+    /**
+     * @param {ObjectExpression} node
+     * @returns {boolean}
+     */
     function objectHasType(node) {
       const typeProperty = node.properties.find(
         (p) =>
-          utils.getStaticPropertyName(p.key) === 'type' &&
+          p.type === 'Property' &&
+          utils.getStaticPropertyName(p) === 'type' &&
           (p.value.type !== 'ArrayExpression' || p.value.elements.length > 0)
       )
       const validatorProperty = node.properties.find(
-        (p) => utils.getStaticPropertyName(p.key) === 'validator'
+        (p) =>
+          p.type === 'Property' &&
+          utils.getStaticPropertyName(p) === 'validator'
       )
       return Boolean(typeProperty || validatorProperty)
     }
 
-    function checkProperty(key, value, node) {
+    /**
+     * @param { ComponentArrayProp | ComponentObjectProp } prop
+     */
+    function checkProperty({ value, node, propName }) {
       let hasType = true
 
       if (!value) {
@@ -59,11 +74,15 @@ module.exports = {
         hasType = false
       }
       if (!hasType) {
+        const name =
+          propName ||
+          (node.type === 'Identifier' && node.name) ||
+          'Unknown prop'
         context.report({
           node,
           message: 'Prop "{{name}}" should define at least its type.',
           data: {
-            name: utils.getStaticPropertyName(key || node) || 'Unknown prop'
+            name
           }
         })
       }
@@ -77,7 +96,7 @@ module.exports = {
       const props = utils.getComponentProps(obj)
 
       for (const prop of props) {
-        checkProperty(prop.key, prop.value, prop.node)
+        checkProperty(prop)
       }
     })
   }
diff --git a/lib/rules/require-render-return.js b/lib/rules/require-render-return.js
index 30e11b8fc..8d3b2096e 100644
--- a/lib/rules/require-render-return.js
+++ b/lib/rules/require-render-return.js
@@ -21,33 +21,26 @@ module.exports = {
     fixable: null, // or "code" or "whitespace"
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
+    /** @type {Map<ESNode, Property['key']>} */
     const renderFunctions = new Map()
 
     // ----------------------------------------------------------------------
     // Public
     // ----------------------------------------------------------------------
 
-    return Object.assign(
-      {},
+    return utils.compositingVisitors(
       utils.defineVueVisitor(context, {
-        onVueObjectEnter(obj) {
-          const node = obj.properties.find(
-            (item) =>
-              item.type === 'Property' &&
-              utils.getStaticPropertyName(item) === 'render' &&
-              (item.value.type === 'ArrowFunctionExpression' ||
-                item.value.type === 'FunctionExpression')
-          )
-          if (!node) return
-          renderFunctions.set(node.value, node.key)
+        onRenderFunctionEnter(node) {
+          renderFunctions.set(node.parent.value, node.parent.key)
         }
       }),
       utils.executeOnFunctionsWithoutReturn(true, (node) => {
-        if (renderFunctions.has(node)) {
+        const key = renderFunctions.get(node)
+        if (key) {
           context.report({
-            node: renderFunctions.get(node),
+            node: key,
             message: 'Expected to return a value in render function.'
           })
         }
diff --git a/lib/rules/require-slots-as-functions.js b/lib/rules/require-slots-as-functions.js
index 07493ddbb..36a3f9339 100644
--- a/lib/rules/require-slots-as-functions.js
+++ b/lib/rules/require-slots-as-functions.js
@@ -11,12 +11,6 @@
 const utils = require('../utils')
 const { findVariable } = require('eslint-utils')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.ESLintMemberExpression} MemberExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintIdentifier} Identifier
- * @typedef {import('vue-eslint-parser').AST.ESLintExpression} Expression
- */
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -35,7 +29,7 @@ module.exports = {
       unexpected: 'Property in `$slots` should be used as function.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     /**
      * Verify the given node
@@ -86,7 +80,6 @@ module.exports = {
      * @param {Expression} reportNode The node to report
      */
     function verifyReferences(node, reportNode) {
-      // @ts-ignore
       const variable = findVariable(context.getScope(), node)
       if (!variable) {
         return
diff --git a/lib/rules/require-toggle-inside-transition.js b/lib/rules/require-toggle-inside-transition.js
index b4ae77561..93a074f2b 100644
--- a/lib/rules/require-toggle-inside-transition.js
+++ b/lib/rules/require-toggle-inside-transition.js
@@ -16,7 +16,7 @@ const utils = require('../utils')
 
 /**
  * Check whether the given node is an well-known element or not.
- * @param {ASTNode} node The element node to check.
+ * @param {VElement} node The element node to check.
  * @returns {boolean} `true` if the name is an well-known element name.
  */
 function isWellKnownElement(node) {
@@ -51,7 +51,7 @@ module.exports = {
         'The element inside `<transition>` is expected to have a `v-if` or `v-show` directive.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     /**
      * Check if the given element has display control.
@@ -77,6 +77,7 @@ module.exports = {
     }
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VElement} node */
       "VElement[name='transition'] > VElement"(node) {
         if (node.parent.children[0] !== node) {
           return
diff --git a/lib/rules/require-v-for-key.js b/lib/rules/require-v-for-key.js
index b595c7489..987cb9794 100644
--- a/lib/rules/require-v-for-key.js
+++ b/lib/rules/require-v-for-key.js
@@ -26,11 +26,11 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     /**
      * Check the given element about `v-bind:key` attributes.
-     * @param {ASTNode} element The element node to check.
+     * @param {VElement} element The element node to check.
      */
     function checkKey(element) {
       if (element.name === 'template' || element.name === 'slot') {
@@ -53,6 +53,7 @@ module.exports = {
     }
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='for']"(node) {
         checkKey(node.parent.parent)
       }
diff --git a/lib/rules/require-valid-default-prop.js b/lib/rules/require-valid-default-prop.js
index 6d6c7456f..5003d20c7 100644
--- a/lib/rules/require-valid-default-prop.js
+++ b/lib/rules/require-valid-default-prop.js
@@ -5,15 +5,10 @@
 'use strict'
 const utils = require('../utils')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.ESLintObjectExpression} ObjectExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintExpression} Expression
- * @typedef {import('vue-eslint-parser').AST.ESLintProperty} Property
- * @typedef {import('vue-eslint-parser').AST.ESLintBlockStatement} BlockStatement
- * @typedef {import('vue-eslint-parser').AST.ESLintPattern} Pattern
- */
 /**
  * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
+ * @typedef {import('../utils').VueObjectData} VueObjectData
  */
 
 // ----------------------------------------------------------------------
@@ -61,12 +56,21 @@ function getTypes(node) {
     return [node.name]
   } else if (node.type === 'ArrayExpression') {
     return node.elements
-      .filter((item) => item.type === 'Identifier')
+      .filter(
+        /**
+         * @param {Expression | SpreadElement} item
+         * @returns {item is Identifier}
+         */
+        (item) => item.type === 'Identifier'
+      )
       .map((item) => item.name)
   }
   return []
 }
 
+/**
+ * @param {string} text
+ */
 function capitalize(text) {
   return text[0].toUpperCase() + text.slice(1)
 }
@@ -86,11 +90,11 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     /**
      * @typedef { { type: string, function: false } } StandardValueType
-     * @typedef { { type: 'Function', function: true, expression: true, functionBody: BlockStatement, returnType: string | null } } FunctionExprValueType
+     * @typedef { { type: 'Function', function: true, expression: true, functionBody: Expression, returnType: string | null } } FunctionExprValueType
      * @typedef { { type: 'Function', function: true, expression: false, functionBody: BlockStatement, returnTypes: ReturnType[] } } FunctionValueType
      * @typedef { ComponentObjectProp & { value: ObjectExpression } } ComponentObjectDefineProp
      * @typedef { { prop: ComponentObjectDefineProp, type: Set<string>, default: FunctionValueType } } PropDefaultFunctionContext
@@ -102,8 +106,11 @@ module.exports = {
      */
     const vueObjectPropsContexts = new Map()
 
-    /** @type { { upper: any, body: null | BlockStatement, returnTypes?: null | ReturnType[] } } */
+    /** @type { { upper: any, body: null | BlockStatement | Expression, returnTypes?: null | ReturnType[] } } */
     let scopeStack = { upper: null, body: null, returnTypes: null }
+    /**
+     * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
+     */
     function onFunctionEnter(node) {
       scopeStack = { upper: scopeStack, body: node.body, returnTypes: null }
     }
@@ -196,7 +203,7 @@ module.exports = {
       const propName =
         prop.propName != null
           ? prop.propName
-          : `[${context.getSourceCode().getText(prop.key)}]`
+          : `[${context.getSourceCode().getText(prop.node.key)}]`
       context.report({
         node,
         message:
@@ -215,12 +222,14 @@ module.exports = {
     return utils.defineVueVisitor(context, {
       onVueObjectEnter(obj) {
         /** @type {ComponentObjectDefineProp[]} */
-        const props = utils
-          .getComponentProps(obj)
-          .filter(
-            (prop) =>
-              prop.key && prop.value && prop.value.type === 'ObjectExpression'
-          )
+        const props = utils.getComponentProps(obj).filter(
+          /**
+           * @param {ComponentObjectProp | ComponentArrayProp} prop
+           * @returns {prop is ComponentObjectDefineProp}
+           */
+          (prop) =>
+            Boolean(prop.value && prop.value.type === 'ObjectExpression')
+        )
         /** @type {PropDefaultFunctionContext[]} */
         const propContexts = []
         for (const prop of props) {
@@ -274,17 +283,27 @@ module.exports = {
         }
         vueObjectPropsContexts.set(obj, propContexts)
       },
+      /**
+       * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
+       * @param {VueObjectData} data
+       */
       ':function'(node, { node: vueNode }) {
         onFunctionEnter(node)
 
-        for (const { default: defType } of vueObjectPropsContexts.get(
-          vueNode
-        )) {
+        const data = vueObjectPropsContexts.get(vueNode)
+        if (!data) {
+          return
+        }
+
+        for (const { default: defType } of data) {
           if (node.body === defType.functionBody) {
             scopeStack.returnTypes = defType.returnTypes
           }
         }
       },
+      /**
+       * @param {ReturnStatement} node
+       */
       ReturnStatement(node) {
         if (scopeStack.returnTypes && node.argument) {
           const type = getValueType(node.argument)
@@ -298,11 +317,11 @@ module.exports = {
       },
       ':function:exit': onFunctionExit,
       onVueObjectExit(obj) {
-        for (const {
-          prop,
-          type: typeNames,
-          default: defType
-        } of vueObjectPropsContexts.get(obj)) {
+        const data = vueObjectPropsContexts.get(obj)
+        if (!data) {
+          return
+        }
+        for (const { prop, type: typeNames, default: defType } of data) {
           for (const returnType of defType.returnTypes) {
             if (typeNames.has(returnType.type)) continue
 
diff --git a/lib/rules/return-in-computed-property.js b/lib/rules/return-in-computed-property.js
index 3a1243b3e..770e0c597 100644
--- a/lib/rules/return-in-computed-property.js
+++ b/lib/rules/return-in-computed-property.js
@@ -6,6 +6,10 @@
 
 const utils = require('../utils')
 
+/**
+ * @typedef {import('../utils').ComponentComputedProperty} ComponentComputedProperty
+ */
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -32,13 +36,16 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const treatUndefinedAsUnspecified = !(
       options.treatUndefinedAsUnspecified === false
     )
 
+    /**
+     * @type {Set<ComponentComputedProperty>}
+     */
     const computedProperties = new Set()
 
     // ----------------------------------------------------------------------
@@ -48,7 +55,7 @@ module.exports = {
     return Object.assign(
       {},
       utils.defineVueVisitor(context, {
-        onVueObjectEnter(obj, { node: vueNode }) {
+        onVueObjectEnter(obj) {
           for (const computedProperty of utils.getComputedProperties(obj)) {
             computedProperties.add(computedProperty)
           }
@@ -64,7 +71,7 @@ module.exports = {
                 message:
                   'Expected to return a value in "{{name}}" computed property.',
                 data: {
-                  name: cp.key
+                  name: cp.key || 'Unknown'
                 }
               })
             }
diff --git a/lib/rules/return-in-emits-validator.js b/lib/rules/return-in-emits-validator.js
index 7dad041c3..15493a8d0 100644
--- a/lib/rules/return-in-emits-validator.js
+++ b/lib/rules/return-in-emits-validator.js
@@ -7,7 +7,8 @@
 const utils = require('../utils')
 
 /**
- * @typedef {import('vue-eslint-parser').AST.ESLintExpression} Expression
+ * @typedef {import('../utils').ComponentArrayEmit} ComponentArrayEmit
+ * @typedef {import('../utils').ComponentObjectEmit} ComponentObjectEmit
  */
 
 /**
@@ -45,25 +46,37 @@ module.exports = {
     fixable: null, // or "code" or "whitespace"
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
+    /** @type {ComponentObjectEmit[]} */
     const emitsValidators = []
 
     // ----------------------------------------------------------------------
     // Public
     // ----------------------------------------------------------------------
 
-    let scopeStack = null
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} upper
+     * @property {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} functionNode
+     * @property {boolean} hasReturnValue
+     * @property {boolean} possibleOfReturnTrue
+     */
+    /**
+     * @type {ScopeStack}
+     */
+    let scopeStack
 
     return Object.assign(
       {},
       utils.defineVueVisitor(context, {
+        /** @param {ObjectExpression} obj */
         onVueObjectEnter(obj) {
           for (const emits of utils.getComponentEmits(obj)) {
-            const emitsValue = emits.value
-            if (!emitsValue) {
+            if (!emits.value) {
               continue
             }
+            const emitsValue = emits.value
             if (
               emitsValue.type !== 'FunctionExpression' &&
               emitsValue.type !== 'ArrowFunctionExpression'
@@ -73,6 +86,7 @@ module.exports = {
             emitsValidators.push(emits)
           }
         },
+        /** @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node */
         ':function'(node) {
           scopeStack = {
             upper: scopeStack,
@@ -89,6 +103,7 @@ module.exports = {
             }
           }
         },
+        /** @param {ReturnStatement} node */
         ReturnStatement(node) {
           if (node.argument) {
             scopeStack.hasReturnValue = true
@@ -98,6 +113,7 @@ module.exports = {
             }
           }
         },
+        /** @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node */
         ':function:exit'(node) {
           if (!scopeStack.possibleOfReturnTrue) {
             const emits = emitsValidators.find((e) => e.value === node)
@@ -108,7 +124,7 @@ module.exports = {
                   ? 'Expected to return a true value in "{{name}}" emits validator.'
                   : 'Expected to return a boolean value in "{{name}}" emits validator.',
                 data: {
-                  name: emits.emitName
+                  name: emits.emitName || 'Unknown'
                 }
               })
             }
diff --git a/lib/rules/script-indent.js b/lib/rules/script-indent.js
index 09a9292f1..6a85e7114 100644
--- a/lib/rules/script-indent.js
+++ b/lib/rules/script-indent.js
@@ -49,6 +49,7 @@ module.exports = {
       }
     ]
   },
+  /** @param {RuleContext} context */
   create(context) {
     return indentCommon.defineVisitor(context, context.getSourceCode(), {})
   }
diff --git a/lib/rules/singleline-html-element-content-newline.js b/lib/rules/singleline-html-element-content-newline.js
index 1261d2b73..52b5ed1fe 100644
--- a/lib/rules/singleline-html-element-content-newline.js
+++ b/lib/rules/singleline-html-element-content-newline.js
@@ -16,10 +16,16 @@ const INLINE_ELEMENTS = require('../utils/inline-non-void-elements.json')
 // Helpers
 // ------------------------------------------------------------------------------
 
+/**
+ * @param {VElement & { endTag: VEndTag } } element
+ */
 function isSinglelineElement(element) {
   return element.loc.start.line === element.endTag.loc.start.line
 }
 
+/**
+ * @param {any} options
+ */
 function parseOptions(options) {
   return Object.assign(
     {
@@ -34,7 +40,7 @@ function parseOptions(options) {
 /**
  * Check whether the given element is empty or not.
  * This ignores whitespaces, doesn't ignore comments.
- * @param {VElement} node The element node to check.
+ * @param {VElement & { endTag: VEndTag } } node The element node to check.
  * @param {SourceCode} sourceCode The source code object of the current context.
  * @returns {boolean} `true` if the element is empty.
  */
@@ -86,7 +92,7 @@ module.exports = {
         'Expected 1 line break before closing tag (`</{{name}}>`), but no line breaks found.'
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = parseOptions(context.options[0])
     const ignores = options.ignores
@@ -97,8 +103,10 @@ module.exports = {
       context.parserServices.getTemplateBodyTokenStore()
     const sourceCode = context.getSourceCode()
 
-    let inIgnoreElement
+    /** @type {VElement | null} */
+    let inIgnoreElement = null
 
+    /** @param {VElement} node */
     function isIgnoredElement(node) {
       return (
         ignores.includes(node.name) ||
@@ -108,6 +116,7 @@ module.exports = {
     }
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VElement} node */
       VElement(node) {
         if (inIgnoreElement) {
           return
@@ -122,71 +131,80 @@ module.exports = {
           return
         }
 
-        if (!isSinglelineElement(node)) {
+        const elem = /** @type {VElement & { endTag: VEndTag } } */ (node)
+
+        if (!isSinglelineElement(elem)) {
           return
         }
-        if (ignoreWhenNoAttributes && node.startTag.attributes.length === 0) {
+        if (ignoreWhenNoAttributes && elem.startTag.attributes.length === 0) {
           return
         }
 
+        /** @type {SourceCode.CursorWithCountOptions} */
         const getTokenOption = {
           includeComments: true,
           filter: (token) => token.type !== 'HTMLWhitespace'
         }
         if (
           ignoreWhenEmpty &&
-          node.children.length === 0 &&
+          elem.children.length === 0 &&
           template.getFirstTokensBetween(
-            node.startTag,
-            node.endTag,
+            elem.startTag,
+            elem.endTag,
             getTokenOption
           ).length === 0
         ) {
           return
         }
 
-        const contentFirst = template.getTokenAfter(
-          node.startTag,
+        const contentFirst = /** @type {Token} */ (template.getTokenAfter(
+          elem.startTag,
+          getTokenOption
+        ))
+        const contentLast = /** @type {Token} */ (template.getTokenBefore(
+          elem.endTag,
           getTokenOption
-        )
-        const contentLast = template.getTokenBefore(node.endTag, getTokenOption)
+        ))
 
         context.report({
-          node: template.getLastToken(node.startTag),
+          node: template.getLastToken(elem.startTag),
           loc: {
-            start: node.startTag.loc.end,
+            start: elem.startTag.loc.end,
             end: contentFirst.loc.start
           },
           messageId: 'unexpectedAfterClosingBracket',
           data: {
-            name: node.rawName
+            name: elem.rawName
           },
           fix(fixer) {
-            const range = [node.startTag.range[1], contentFirst.range[0]]
+            /** @type {Range} */
+            const range = [elem.startTag.range[1], contentFirst.range[0]]
             return fixer.replaceTextRange(range, '\n')
           }
         })
 
-        if (isEmpty(node, sourceCode)) {
+        if (isEmpty(elem, sourceCode)) {
           return
         }
 
         context.report({
-          node: template.getFirstToken(node.endTag),
+          node: template.getFirstToken(elem.endTag),
           loc: {
             start: contentLast.loc.end,
-            end: node.endTag.loc.start
+            end: elem.endTag.loc.start
           },
           messageId: 'unexpectedBeforeOpeningBracket',
           data: {
-            name: node.rawName
+            name: elem.rawName
           },
           fix(fixer) {
-            const range = [contentLast.range[1], node.endTag.range[0]]
+            /** @type {Range} */
+            const range = [contentLast.range[1], elem.endTag.range[0]]
             return fixer.replaceTextRange(range, '\n')
           }
         })
       },
+      /** @param {VElement} node */
       'VElement:exit'(node) {
         if (inIgnoreElement === node) {
           inIgnoreElement = null
diff --git a/lib/rules/sort-keys.js b/lib/rules/sort-keys.js
index 246329e0b..5e4fa3c10 100644
--- a/lib/rules/sort-keys.js
+++ b/lib/rules/sort-keys.js
@@ -23,7 +23,7 @@ const utils = require('../utils')
  *   whether it's a computed property or not.
  * - If the property has a static name, this returns the static name.
  * - Otherwise, this returns null.
- * @param {ASTNode} node The `Property` node to get.
+ * @param {Property} node The `Property` node to get.
  * @returns {string|null} The property name or null.
  * @private
  */
@@ -34,15 +34,16 @@ function getPropertyName(node) {
     return staticName
   }
 
-  return node.key.name || null
+  return node.key.type === 'Identifier' ? node.key.name : null
 }
 
 /**
  * Functions which check that the given 2 names are in specific order.
  *
  * Postfix `I` is meant insensitive.
- * Postfix `N` is meant natual.
+ * Postfix `N` is meant natural.
  * @private
+ * @type { { [key: string]: (a:string, b:string) => boolean } }
  */
 const isValidOrders = {
   asc(a, b) {
@@ -119,14 +120,22 @@ module.exports = {
         },
         additionalProperties: false
       }
-    ]
+    ],
+    messages: {
+      sortKeys:
+        "Expected object keys to be in {{natural}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'."
+    }
   },
-
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
   create(context) {
     // Parse options.
     const options = context.options[1]
     const order = context.options[0] || 'asc'
 
+    /** @type {string[]} */
     const ignoreGrandchildrenOf = (options &&
       options.ignoreGrandchildrenOf) || [
       'computed',
@@ -135,108 +144,112 @@ module.exports = {
       'props',
       'watch'
     ]
+    /** @type {string[]} */
     const ignoreChildrenOf = (options && options.ignoreChildrenOf) || ['model']
     const insensitive = options && options.caseSensitive === false
     const minKeys = options && options.minKeys
-    const natual = options && options.natural
+    const natural = options && options.natural
     const isValidOrder =
-      isValidOrders[order + (insensitive ? 'I' : '') + (natual ? 'N' : '')]
-
-    // The stack to save the previous property's name for each object literals.
-    let stack = null
+      isValidOrders[order + (insensitive ? 'I' : '') + (natural ? 'N' : '')]
 
-    let errors = []
-    const names = {}
-
-    const reportErrors = (isVue) => {
-      if (isVue) {
-        errors = errors.filter((error) => {
-          let parentIsRoot = !error.hasUpper
-          let grandParentIsRoot = !error.grandparent
-          let greatGrandparentIsRoot = !error.greatGrandparent
-
-          const stackPrevChar = stack && stack.prevChar
-          if (stackPrevChar) {
-            parentIsRoot = stackPrevChar === error.parent
-            grandParentIsRoot = stackPrevChar === error.grandparent
-            greatGrandparentIsRoot = stackPrevChar === error.greatGrandparent
-          }
+    /**
+     * @typedef {object} ObjectStack
+     * @property {ObjectStack} ObjectStack.upper
+     * @property {string | null} ObjectStack.prevName
+     * @property {number} ObjectStack.numKeys
+     * @property {VueState} ObjectStack.vueState
+     *
+     * @typedef {object} VueState
+     * @property {Property} [VueState.currentProperty]
+     * @property {boolean} [VueState.isVueObject]
+     * @property {boolean} [VueState.within]
+     * @property {string} [VueState.propName]
+     * @property {number} [VueState.chainLevel]
+     * @property {boolean} [VueState.ignore]
+     */
 
-          if (parentIsRoot) {
-            return false
-          } else if (grandParentIsRoot) {
-            return (
-              !error.parentIsProperty ||
-              !ignoreChildrenOf.includes(names[error.parent])
-            )
-          } else if (greatGrandparentIsRoot) {
-            return (
-              !error.parentIsProperty ||
-              !ignoreGrandchildrenOf.includes(names[error.grandparent])
-            )
-          }
-          return true
-        })
-      }
-      errors.forEach((error) => error.errors.forEach((e) => context.report(e)))
-      errors = []
-    }
+    /**
+     * The stack to save the previous property's name for each object literals.
+     * @type {ObjectStack}
+     */
+    let stack
 
-    const sortTests = {
+    return {
       ObjectExpression(node) {
-        if (!stack) {
-          reportErrors(false)
-        }
+        /** @type {VueState} */
+        const vueState = {}
+        const upperVueState = (stack && stack.vueState) || {}
         stack = {
           upper: stack,
-          prevChar: null,
           prevName: null,
           numKeys: node.properties.length,
-          parentIsProperty: node.parent.type === 'Property',
-          errors: []
+          vueState
+        }
+
+        vueState.isVueObject = utils.getVueObjectType(context, node) != null
+        if (vueState.isVueObject) {
+          vueState.within = vueState.isVueObject
+          // Ignore Vue object properties
+          vueState.ignore = true
+        } else {
+          if (upperVueState.within && upperVueState.currentProperty) {
+            const isChain = utils.isPropertyChain(
+              upperVueState.currentProperty,
+              node
+            )
+            if (isChain) {
+              let propName
+              let chainLevel
+              if (upperVueState.isVueObject) {
+                propName =
+                  utils.getStaticPropertyName(upperVueState.currentProperty) ||
+                  ''
+                chainLevel = 1
+              } else {
+                propName = upperVueState.propName
+                chainLevel = upperVueState.chainLevel + 1
+              }
+              vueState.propName = propName
+              vueState.chainLevel = chainLevel
+              // chaining
+              vueState.within = true
+
+              // Judge whether to ignore the property.
+              if (chainLevel === 1) {
+                if (ignoreChildrenOf.includes(propName)) {
+                  vueState.ignore = true
+                }
+              } else if (chainLevel === 2) {
+                if (ignoreGrandchildrenOf.includes(propName)) {
+                  vueState.ignore = true
+                }
+              }
+            } else {
+              // chaining has broken.
+              vueState.within = false
+            }
+          }
         }
       },
-      'ObjectExpression:exit'(node) {
-        errors.push({
-          errors: stack.errors,
-          hasUpper: !!stack.upper,
-          parentIsProperty: node.parent.type === 'Property',
-          parent: stack.upper && stack.upper.prevChar,
-          grandparent:
-            stack.upper && stack.upper.upper && stack.upper.upper.prevChar,
-          greatGrandparent:
-            stack.upper &&
-            stack.upper.upper &&
-            stack.upper.upper.upper &&
-            stack.upper.upper.upper.prevChar
-        })
+      'ObjectExpression:exit'() {
         stack = stack.upper
       },
       SpreadElement(node) {
         if (node.parent.type === 'ObjectExpression') {
           stack.prevName = null
-          stack.prevChar = null
         }
       },
-      'Program:exit'() {
-        reportErrors(false)
-      },
-      Property(node) {
-        if (node.parent.type === 'ObjectPattern') {
+      'ObjectExpression > Property'(node) {
+        stack.vueState.currentProperty = node
+        if (stack.vueState.ignore) {
           return
         }
-
         const prevName = stack.prevName
         const numKeys = stack.numKeys
         const thisName = getPropertyName(node)
 
         if (thisName !== null) {
           stack.prevName = thisName
-          stack.prevChar = node.range[0]
-          if (Object.prototype.hasOwnProperty.call(names, node.range[0])) {
-            throw new Error('Name clash')
-          }
-          names[node.range[0]] = thisName
         }
 
         if (prevName === null || thisName === null || numKeys < minKeys) {
@@ -244,41 +257,20 @@ module.exports = {
         }
 
         if (!isValidOrder(prevName, thisName)) {
-          stack.errors.push({
+          context.report({
             node,
             loc: node.key.loc,
-            message:
-              "Expected object keys to be in {{natual}}{{insensitive}}{{order}}ending order. '{{thisName}}' should be before '{{prevName}}'.",
+            messageId: 'sortKeys',
             data: {
               thisName,
               prevName,
               order,
               insensitive: insensitive ? 'insensitive ' : '',
-              natual: natual ? 'natural ' : ''
+              natural: natural ? 'natural ' : ''
             }
           })
         }
       }
     }
-
-    const execOnVue = utils.executeOnVue(context, (obj) => {
-      reportErrors(true)
-    })
-
-    const result = { ...sortTests }
-
-    Object.keys(execOnVue).forEach((key) => {
-      // Ensure we call both the callback from sortTests and execOnVue if they both use the same key
-      if (Object.prototype.hasOwnProperty.call(sortTests, key)) {
-        result[key] = (node) => {
-          sortTests[key](node)
-          execOnVue[key](node)
-        }
-      } else {
-        result[key] = execOnVue[key]
-      }
-    })
-
-    return result
   }
 }
diff --git a/lib/rules/static-class-names-order.js b/lib/rules/static-class-names-order.js
index 3a43dbf23..bee820fa2 100644
--- a/lib/rules/static-class-names-order.js
+++ b/lib/rules/static-class-names-order.js
@@ -24,10 +24,16 @@ module.exports = {
     fixable: 'code',
     schema: []
   },
+  /** @param {RuleContext} context */
   create: (context) => {
     return defineTemplateBodyVisitor(context, {
+      /** @param {VAttribute} node */
       "VAttribute[directive=false][key.name='class']"(node) {
-        const classList = node.value.value
+        const value = node.value
+        if (!value) {
+          return
+        }
+        const classList = value.value
         const classListWithWhitespace = classList.split(/(\s+)/)
 
         // Detect and reuse any type of whitespace.
@@ -46,11 +52,7 @@ module.exports = {
             node,
             loc: node.loc,
             message: 'Classes should be ordered alphabetically.',
-            fix: (fixer) =>
-              fixer.replaceTextRange(
-                [node.value.range[0], node.value.range[1]],
-                `"${classListSorted}"`
-              )
+            fix: (fixer) => fixer.replaceText(value, `"${classListSorted}"`)
           })
         }
       }
diff --git a/lib/rules/syntaxes/dynamic-directive-arguments.js b/lib/rules/syntaxes/dynamic-directive-arguments.js
index ae720d87a..314bceeaa 100644
--- a/lib/rules/syntaxes/dynamic-directive-arguments.js
+++ b/lib/rules/syntaxes/dynamic-directive-arguments.js
@@ -5,15 +5,16 @@
 'use strict'
 module.exports = {
   supported: '2.6.0',
+  /** @param {RuleContext} context */
   createTemplateBodyVisitor(context) {
     /**
      * Reports dynamic argument node
-     * @param {VExpressionContainer} dinamicArgument node of dynamic argument
+     * @param {VExpressionContainer} dynamicArgument node of dynamic argument
      * @returns {void}
      */
-    function reportDynamicArgument(dinamicArgument) {
+    function reportDynamicArgument(dynamicArgument) {
       context.report({
-        node: dinamicArgument,
+        node: dynamicArgument,
         messageId: 'forbiddenDynamicDirectiveArguments'
       })
     }
diff --git a/lib/rules/syntaxes/scope-attribute.js b/lib/rules/syntaxes/scope-attribute.js
index b382eb40d..e2b0a697e 100644
--- a/lib/rules/syntaxes/scope-attribute.js
+++ b/lib/rules/syntaxes/scope-attribute.js
@@ -5,6 +5,7 @@
 'use strict'
 module.exports = {
   deprecated: '2.5.0',
+  /** @param {RuleContext} context */
   createTemplateBodyVisitor(context) {
     /**
      * Reports `scope` node
diff --git a/lib/rules/syntaxes/slot-attribute.js b/lib/rules/syntaxes/slot-attribute.js
index d20095a17..12d6ad67a 100644
--- a/lib/rules/syntaxes/slot-attribute.js
+++ b/lib/rules/syntaxes/slot-attribute.js
@@ -5,6 +5,7 @@
 'use strict'
 module.exports = {
   deprecated: '2.6.0',
+  /** @param {RuleContext} context */
   createTemplateBodyVisitor(context) {
     const sourceCode = context.getSourceCode()
 
@@ -27,7 +28,7 @@ module.exports = {
 
     /**
      * Checks whether the given node can convert to the `v-slot`.
-     * @param {VAttribute} slotAttr node of `v-bind:slot`
+     * @param {VDirective} slotAttr node of `v-bind:slot`
      * @returns {boolean} `true` if the given node can convert to the `v-slot`
      */
     function canConvertFromVBindSlotToVSlot(slotAttr) {
@@ -51,11 +52,11 @@ module.exports = {
 
     /**
      * Convert to `v-slot`.
-     * @param {object} fixer fixer
-     * @param {VAttribute} slotAttr node of `slot`
+     * @param {RuleFixer} fixer fixer
+     * @param {VAttribute|VDirective} slotAttr node of `slot`
      * @param {string | null} slotName name of `slot`
      * @param {boolean} vBind `true` if `slotAttr` is `v-bind:slot`
-     * @returns {*} fix data
+     * @returns {Fix[]} fix data
      */
     function fixSlotToVSlot(fixer, slotAttr, slotName, vBind) {
       const element = slotAttr.parent
@@ -104,7 +105,7 @@ module.exports = {
     }
     /**
      * Reports `v-bind:slot` node
-     * @param {VAttribute} slotAttr node of `v-bind:slot`
+     * @param {VDirective} slotAttr node of `v-bind:slot`
      * @returns {void}
      */
     function reportVBindSlot(slotAttr) {
diff --git a/lib/rules/syntaxes/slot-scope-attribute.js b/lib/rules/syntaxes/slot-scope-attribute.js
index c4c20b771..6efa41552 100644
--- a/lib/rules/syntaxes/slot-scope-attribute.js
+++ b/lib/rules/syntaxes/slot-scope-attribute.js
@@ -6,6 +6,11 @@
 module.exports = {
   deprecated: '2.6.0',
   supported: '2.5.0',
+  /**
+   * @param {RuleContext} context
+   * @param {object} option
+   * @param {boolean} [option.fixToUpgrade]
+   */
   createTemplateBodyVisitor(context, { fixToUpgrade } = {}) {
     const sourceCode = context.getSourceCode()
 
@@ -33,6 +38,7 @@ module.exports = {
           attr.directive === true &&
           attr.key.name.name === 'bind' &&
           attr.key.argument &&
+          attr.key.argument.type === 'VIdentifier' &&
           attr.key.argument.name === 'slot'
       )
       if (vBindSlotAttr) {
@@ -45,9 +51,9 @@ module.exports = {
 
     /**
      * Convert to `v-slot`.
-     * @param {object} fixer fixer
-     * @param {VAttribute | null} scopeAttr node of `slot-scope`
-     * @returns {*} fix data
+     * @param {RuleFixer} fixer fixer
+     * @param {VDirective} scopeAttr node of `slot-scope`
+     * @returns {Fix} fix data
      */
     function fixSlotScopeToVSlot(fixer, scopeAttr) {
       const scopeValue =
@@ -60,7 +66,7 @@ module.exports = {
     }
     /**
      * Reports `slot-scope` node
-     * @param {VAttribute} scopeAttr node of `slot-scope`
+     * @param {VDirective} scopeAttr node of `slot-scope`
      * @returns {void}
      */
     function reportSlotScope(scopeAttr) {
diff --git a/lib/rules/syntaxes/v-bind-prop-modifier-shorthand.js b/lib/rules/syntaxes/v-bind-prop-modifier-shorthand.js
index 386277002..1374379f2 100644
--- a/lib/rules/syntaxes/v-bind-prop-modifier-shorthand.js
+++ b/lib/rules/syntaxes/v-bind-prop-modifier-shorthand.js
@@ -3,18 +3,20 @@
  * See LICENSE file in root directory for full license.
  */
 'use strict'
-const { Range } = require('semver')
-const unsupported = new Range('<=2.5 || >=2.6.0')
+const semver = require('semver')
+const unsupported = new semver.Range('<=2.5 || >=2.6.0')
 
 module.exports = {
   // >=2.6.0-beta.1 <=2.6.0-beta.3
+  /** @param {semver.Range} versionRange */
   supported: (versionRange) => {
     return !versionRange.intersects(unsupported)
   },
+  /** @param {RuleContext} context */
   createTemplateBodyVisitor(context) {
     /**
      * Reports `.prop` shorthand node
-     * @param {VDirectiveKey} bindPropKey node of `.prop` shorthand
+     * @param { VDirectiveKey & { argument: VIdentifier } } bindPropKey node of `.prop` shorthand
      * @returns {void}
      */
     function reportPropModifierShorthand(bindPropKey) {
diff --git a/lib/rules/syntaxes/v-slot.js b/lib/rules/syntaxes/v-slot.js
index 1b17f7c1c..c3b5dfc0d 100644
--- a/lib/rules/syntaxes/v-slot.js
+++ b/lib/rules/syntaxes/v-slot.js
@@ -5,12 +5,13 @@
 'use strict'
 module.exports = {
   supported: '2.6.0',
+  /** @param {RuleContext} context */
   createTemplateBodyVisitor(context) {
     const sourceCode = context.getSourceCode()
 
     /**
      * Checks whether the given node can convert to the `slot`.
-     * @param {VAttribute} vSlotAttr node of `v-slot`
+     * @param {VDirective} vSlotAttr node of `v-slot`
      * @returns {boolean} `true` if the given node can convert to the `slot`
      */
     function canConvertToSlot(vSlotAttr) {
@@ -21,9 +22,9 @@ module.exports = {
     }
     /**
      * Convert to `slot` and `slot-scope`.
-     * @param {object} fixer fixer
-     * @param {VAttribute} vSlotAttr node of `v-slot`
-     * @returns {*} fix data
+     * @param {RuleFixer} fixer fixer
+     * @param {VDirective} vSlotAttr node of `v-slot`
+     * @returns {null|Fix} fix data
      */
     function fixVSlotToSlot(fixer, vSlotAttr) {
       const key = vSlotAttr.key
@@ -60,7 +61,7 @@ module.exports = {
     }
     /**
      * Reports `v-slot` node
-     * @param {VAttribute} vSlotAttr node of `v-slot`
+     * @param {VDirective} vSlotAttr node of `v-slot`
      * @returns {void}
      */
     function reportVSlot(vSlotAttr) {
diff --git a/lib/rules/this-in-template.js b/lib/rules/this-in-template.js
index cec83201e..10c89a81e 100644
--- a/lib/rules/this-in-template.js
+++ b/lib/rules/this-in-template.js
@@ -39,80 +39,82 @@ module.exports = {
    */
   create(context) {
     const options = context.options[0] !== 'always' ? 'never' : 'always'
-    let scope = {
-      parent: null,
-      nodes: []
-    }
+    /**
+     * @typedef {object} ScopeStack
+     * @property {ScopeStack} parent
+     * @property {Identifier[]} nodes
+     */
 
-    return utils.defineTemplateBodyVisitor(
-      context,
-      Object.assign(
-        {
-          VElement(node) {
-            scope = {
-              parent: scope,
-              nodes: scope.nodes.slice() // make copy
+    /** @type {ScopeStack} */
+    let scope
+
+    return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VElement} node */
+      VElement(node) {
+        scope = {
+          parent: scope,
+          nodes: scope
+            ? scope.nodes.slice() // make copy
+            : []
+        }
+        if (node.variables) {
+          for (const variable of node.variables) {
+            const varNode = variable.id
+            const name = varNode.name
+            if (!scope.nodes.some((node) => node.name === name)) {
+              // Prevent adding duplicates
+              scope.nodes.push(varNode)
             }
-            if (node.variables) {
-              for (const variable of node.variables) {
-                const varNode = variable.id
-                const name = varNode.name
-                if (!scope.nodes.some((node) => node.name === name)) {
-                  // Prevent adding duplicates
-                  scope.nodes.push(varNode)
-                }
+          }
+        }
+      },
+      'VElement:exit'() {
+        scope = scope.parent
+      },
+      ...(options === 'never'
+        ? {
+            /** @param { ThisExpression & { parent: MemberExpression } } node */
+            'VExpressionContainer MemberExpression > ThisExpression'(node) {
+              const propertyName = utils.getStaticPropertyName(node.parent)
+              if (
+                !propertyName ||
+                scope.nodes.some((el) => el.name === propertyName) ||
+                RESERVED_NAMES.has(propertyName) || // this.class | this['class']
+                /^[0-9].*$|[^a-zA-Z0-9_]/.test(propertyName) // this['0aaaa'] | this['foo-bar bas']
+              ) {
+                return
               }
+
+              context.report({
+                node,
+                loc: node.loc,
+                message: "Unexpected usage of 'this'."
+              })
             }
-          },
-          'VElement:exit'(node) {
-            scope = scope.parent
           }
-        },
-        options === 'never'
-          ? {
-              'VExpressionContainer MemberExpression > ThisExpression'(node) {
-                const propertyName = utils.getStaticPropertyName(
-                  node.parent.property
-                )
-                if (
-                  !propertyName ||
-                  scope.nodes.some((el) => el.name === propertyName) ||
-                  RESERVED_NAMES.has(propertyName) || // this.class | this['class']
-                  /^[0-9].*$|[^a-zA-Z0-9_]/.test(propertyName) // this['0aaaa'] | this['foo-bar bas']
-                ) {
-                  return
-                }
-
-                context.report({
-                  node,
-                  loc: node.loc,
-                  message: "Unexpected usage of 'this'."
-                })
+        : {
+            /** @param {VExpressionContainer} node */
+            VExpressionContainer(node) {
+              if (node.parent.type === 'VDirectiveKey') {
+                // We cannot use `.` in dynamic arguments because the right of the `.` becomes a modifier.
+                // For example, In `:[this.prop]` case, `:[this` is an argument and `prop]` is a modifier.
+                return
               }
-            }
-          : {
-              VExpressionContainer(node) {
-                if (node.parent.type === 'VDirectiveKey') {
-                  // We cannot use `.` in dynamic arguments because the right of the `.` becomes a modifier.
-                  // For example, In `:[this.prop]` case, `:[this` is an argument and `prop]` is a modifier.
-                  return
-                }
-                if (node.references) {
-                  for (const reference of node.references) {
-                    if (
-                      !scope.nodes.some((el) => el.name === reference.id.name)
-                    ) {
-                      context.report({
-                        node: reference.id,
-                        loc: reference.id.loc,
-                        message: "Expected 'this'."
-                      })
-                    }
+              if (node.references) {
+                for (const reference of node.references) {
+                  if (
+                    !scope.nodes.some((el) => el.name === reference.id.name)
+                  ) {
+                    context.report({
+                      node: reference.id,
+                      loc: reference.id.loc,
+                      message: "Expected 'this'."
+                    })
                   }
                 }
               }
             }
-      )
-    )
+          })
+    })
   }
 }
diff --git a/lib/rules/use-v-on-exact.js b/lib/rules/use-v-on-exact.js
index baaaf8c60..0a1790658 100644
--- a/lib/rules/use-v-on-exact.js
+++ b/lib/rules/use-v-on-exact.js
@@ -8,6 +8,10 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
+/**
+ * @typedef { {name: string, node: VDirectiveKey, modifiers: string[] } } EventDirective
+ */
+
 const utils = require('../utils')
 
 const SYSTEM_MODIFIERS = new Set(['ctrl', 'shift', 'alt', 'meta'])
@@ -28,22 +32,18 @@ const GLOBAL_MODIFIERS = new Set([
 /**
  * Finds and returns all keys for event directives
  *
- * @param {array} attributes Element attributes
+ * @param {VStartTag} startTag Element startTag
  * @param {SourceCode} sourceCode The source code object.
- * @returns {array[object]} [{ name, node, modifiers }]
+ * @returns {EventDirective[]} [{ name, node, modifiers }]
  */
-function getEventDirectives(attributes, sourceCode) {
-  return attributes
-    .filter(
-      (attribute) => attribute.directive && attribute.key.name.name === 'on'
-    )
-    .map((attribute) => ({
-      name: attribute.key.argument
-        ? sourceCode.getText(attribute.key.argument)
-        : '',
-      node: attribute.key,
-      modifiers: attribute.key.modifiers.map((modifier) => modifier.name)
-    }))
+function getEventDirectives(startTag, sourceCode) {
+  return utils.getDirectives(startTag, 'on').map((attribute) => ({
+    name: attribute.key.argument
+      ? sourceCode.getText(attribute.key.argument)
+      : '',
+    node: attribute.key,
+    modifiers: attribute.key.modifiers.map((modifier) => modifier.name)
+  }))
 }
 
 /**
@@ -70,7 +70,7 @@ function isSystemModifier(modifier) {
  * Checks whether given any of provided modifiers
  * has system modifier
  *
- * @param {array} modifiers
+ * @param {string[]} modifiers
  * @returns {boolean}
  */
 function hasSystemModifier(modifiers) {
@@ -81,8 +81,8 @@ function hasSystemModifier(modifiers) {
  * Groups all events in object,
  * with keys represinting each event name
  *
- * @param {array} events
- * @returns {object} { click: [], keypress: [] }
+ * @param {EventDirective[]} events
+ * @returns { { [key: string]: EventDirective[]  } } { click: [], keypress: [] }
  */
 function groupEvents(events) {
   return events.reduce((acc, event) => {
@@ -91,15 +91,14 @@ function groupEvents(events) {
     } else {
       acc[event.name] = [event]
     }
-
     return acc
-  }, {})
+  }, /** @type { { [key: string]: EventDirective[] } }*/ ({}))
 }
 
 /**
  * Creates alphabetically sorted string with system modifiers
  *
- * @param {array[string]} modifiers
+ * @param {string[]} modifiers
  * @returns {string} e.g. "alt,ctrl,del,shift"
  */
 function getSystemModifiersString(modifiers) {
@@ -109,7 +108,7 @@ function getSystemModifiersString(modifiers) {
 /**
  * Creates alphabetically sorted string with key modifiers
  *
- * @param {array[string]} modifiers
+ * @param {string[]} modifiers
  * @returns {string} e.g. "enter,tab"
  */
 function getKeyModifiersString(modifiers) {
@@ -120,8 +119,8 @@ function getKeyModifiersString(modifiers) {
  * Compares two events based on their modifiers
  * to detect possible event leakeage
  *
- * @param {object} baseEvent
- * @param {object} event
+ * @param {EventDirective} baseEvent
+ * @param {EventDirective} event
  * @returns {boolean}
  */
 function hasConflictedModifiers(baseEvent, event) {
@@ -151,8 +150,8 @@ function hasConflictedModifiers(baseEvent, event) {
 /**
  * Searches for events that might conflict with each other
  *
- * @param {array} events
- * @returns {array} conflicted events, without duplicates
+ * @param {EventDirective[]} events
+ * @returns {EventDirective[]} conflicted events, without duplicates
  */
 function findConflictedEvents(events) {
   return events.reduce((acc, event) => {
@@ -162,7 +161,7 @@ function findConflictedEvents(events) {
         .filter((evt) => !acc.find((e) => evt === e)) // No duplicates
         .filter(hasConflictedModifiers.bind(null, event))
     ]
-  }, [])
+  }, /** @type {EventDirective[]} */ ([]))
 }
 
 // ------------------------------------------------------------------------------
@@ -191,11 +190,12 @@ module.exports = {
     const sourceCode = context.getSourceCode()
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VStartTag} node */
       VStartTag(node) {
         if (node.attributes.length === 0) return
 
         const isCustomComponent = utils.isCustomComponent(node.parent)
-        let events = getEventDirectives(node.attributes, sourceCode)
+        let events = getEventDirectives(node, sourceCode)
 
         if (isCustomComponent) {
           // For components consider only events with `native` modifier
diff --git a/lib/rules/v-bind-style.js b/lib/rules/v-bind-style.js
index 1e7c50e69..e6878a349 100644
--- a/lib/rules/v-bind-style.js
+++ b/lib/rules/v-bind-style.js
@@ -26,11 +26,12 @@ module.exports = {
     fixable: 'code',
     schema: [{ enum: ['shorthand', 'longform'] }]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const preferShorthand = context.options[0] !== 'longform'
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='bind'][key.argument!=null]"(
         node
       ) {
diff --git a/lib/rules/v-on-function-call.js b/lib/rules/v-on-function-call.js
index 1897b65f0..04eb79792 100644
--- a/lib/rules/v-on-function-call.js
+++ b/lib/rules/v-on-function-call.js
@@ -9,13 +9,6 @@
 
 const utils = require('../utils')
 
-/**
- * @typedef {import('vue-eslint-parser').AST.VOnExpression} VOnExpression
- * @typedef {import('vue-eslint-parser').AST.Token} Token
- * @typedef {import('vue-eslint-parser').AST.ESLintExpressionStatement} ExpressionStatement
- * @typedef {import('vue-eslint-parser').AST.ESLintCallExpression} CallExpression
- */
-
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
@@ -60,7 +53,7 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const always = context.options[0] === 'always'
 
@@ -102,6 +95,7 @@ module.exports = {
     return utils.defineTemplateBodyVisitor(context, {
       ...(always
         ? {
+            /** @param {Identifier} node */
             "VAttribute[directive=true][key.name.name='on'][key.argument!=null] > VExpressionContainer > Identifier"(
               node
             ) {
@@ -122,14 +116,15 @@ module.exports = {
                 return
               }
               const option = context.options[1] || {}
-              const ignoreIncludesComment = option.ignoreIncludesComment
+              const ignoreIncludesComment = !!option.ignoreIncludesComment
 
               const tokenStore = context.parserServices.getTemplateBodyTokenStore()
-              /** @type {Token[]} */
               const tokens = tokenStore.getTokens(node.parent, {
                 includeComments: true
               })
+              /** @type {Token | undefined} */
               let leftQuote
+              /** @type {Token | undefined} */
               let rightQuote
               if (isQuote(tokens[0])) {
                 leftQuote = tokens.shift()
@@ -151,12 +146,14 @@ module.exports = {
                 fix: hasComment
                   ? null /* The comment is included and cannot be fixed. */
                   : (fixer) => {
-                      const range = leftQuote
-                        ? [leftQuote.range[1], rightQuote.range[0]]
-                        : [
-                            tokens[0].range[0],
-                            tokens[tokens.length - 1].range[1]
-                          ]
+                      /** @type {Range} */
+                      const range =
+                        leftQuote && rightQuote
+                          ? [leftQuote.range[1], rightQuote.range[0]]
+                          : [
+                              tokens[0].range[0],
+                              tokens[tokens.length - 1].range[1]
+                            ]
 
                       return fixer.replaceTextRange(
                         range,
diff --git a/lib/rules/v-on-style.js b/lib/rules/v-on-style.js
index bda26be94..4649aacf9 100644
--- a/lib/rules/v-on-style.js
+++ b/lib/rules/v-on-style.js
@@ -26,11 +26,12 @@ module.exports = {
     fixable: 'code',
     schema: [{ enum: ['shorthand', 'longform'] }]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const preferShorthand = context.options[0] !== 'longform'
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='on'][key.argument!=null]"(
         node
       ) {
diff --git a/lib/rules/v-slot-style.js b/lib/rules/v-slot-style.js
index bbae1989e..f0cbe3610 100644
--- a/lib/rules/v-slot-style.js
+++ b/lib/rules/v-slot-style.js
@@ -20,6 +20,7 @@ const utils = require('../utils')
  * @returns {Options} The normalized options.
  */
 function normalizeOptions(options) {
+  /** @type {Options} */
   const normalized = {
     atComponent: 'v-slot',
     default: 'shorthand',
@@ -27,9 +28,11 @@ function normalizeOptions(options) {
   }
 
   if (typeof options === 'string') {
-    normalized.atComponent = normalized.default = normalized.named = options
+    normalized.atComponent = normalized.default = normalized.named = /** @type {"shorthand" | "longform"} */ (options)
   } else if (options != null) {
-    for (const key of ['atComponent', 'default', 'named']) {
+    /** @type {(keyof Options)[]} */
+    const keys = ['atComponent', 'default', 'named']
+    for (const key of keys) {
       if (options[key] != null) {
         normalized[key] = options[key]
       }
@@ -42,7 +45,7 @@ function normalizeOptions(options) {
 /**
  * Get the expected style.
  * @param {Options} options The options that defined expected types.
- * @param {VAttribute} node The `v-slot` node to check.
+ * @param {VDirective} node The `v-slot` node to check.
  * @returns {"shorthand" | "longform" | "v-slot"} The expected style.
  */
 function getExpectedStyle(options, node) {
@@ -60,7 +63,7 @@ function getExpectedStyle(options, node) {
 
 /**
  * Get the expected style.
- * @param {VAttribute} node The `v-slot` node to check.
+ * @param {VDirective} node The `v-slot` node to check.
  * @returns {"shorthand" | "longform" | "v-slot"} The expected style.
  */
 function getActualStyle(node) {
@@ -107,12 +110,13 @@ module.exports = {
       expectedVSlot: "Expected 'v-slot' instead of '{{actual}}'."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
     const options = normalizeOptions(context.options[0])
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='slot']"(node) {
         const expected = getExpectedStyle(options, node)
         const actual = getActualStyle(node)
@@ -121,6 +125,7 @@ module.exports = {
         }
 
         const { name, argument } = node.key
+        /** @type {Range} */
         const range = [name.range[0], (argument || name).range[1]]
         const argumentText = argument ? sourceCode.getText(argument) : 'default'
         context.report({
diff --git a/lib/rules/valid-template-root.js b/lib/rules/valid-template-root.js
index f7928d294..703ab8b8e 100644
--- a/lib/rules/valid-template-root.js
+++ b/lib/rules/valid-template-root.js
@@ -26,11 +26,12 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
 
     return {
+      /** @param {Program} program */
       Program(program) {
         const element = program.templateBody
         if (element == null) {
diff --git a/lib/rules/valid-v-bind-sync.js b/lib/rules/valid-v-bind-sync.js
index 6b9225308..3799d0895 100644
--- a/lib/rules/valid-v-bind-sync.js
+++ b/lib/rules/valid-v-bind-sync.js
@@ -16,7 +16,7 @@ const utils = require('../utils')
 
 /**
  * Check whether the given node is valid or not.
- * @param {ASTNode} node The element node to check.
+ * @param {VElement} node The element node to check.
  * @returns {boolean} `true` if the node is valid.
  */
 function isValidElement(node) {
@@ -63,9 +63,10 @@ module.exports = {
         "'.sync' modifiers cannot update the iteration variable '{{varName}}' itself."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='bind']"(node) {
         if (!node.key.modifiers.map((mod) => mod.name).includes('sync')) {
           return
diff --git a/lib/rules/valid-v-bind.js b/lib/rules/valid-v-bind.js
index 7d88bad38..385272f71 100644
--- a/lib/rules/valid-v-bind.js
+++ b/lib/rules/valid-v-bind.js
@@ -32,9 +32,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='bind']"(node) {
         for (const modifier of node.key.modifiers) {
           if (!VALID_MODIFIERS.has(modifier.name)) {
diff --git a/lib/rules/valid-v-cloak.js b/lib/rules/valid-v-cloak.js
index b571ebd00..4fd51d781 100644
--- a/lib/rules/valid-v-cloak.js
+++ b/lib/rules/valid-v-cloak.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='cloak']"(node) {
         if (node.key.argument) {
           context.report({
diff --git a/lib/rules/valid-v-else-if.js b/lib/rules/valid-v-else-if.js
index 59252855b..aafe97b1c 100644
--- a/lib/rules/valid-v-else-if.js
+++ b/lib/rules/valid-v-else-if.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='else-if']"(node) {
         const element = node.parent.parent
 
diff --git a/lib/rules/valid-v-else.js b/lib/rules/valid-v-else.js
index 2479f467e..7a8542787 100644
--- a/lib/rules/valid-v-else.js
+++ b/lib/rules/valid-v-else.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='else']"(node) {
         const element = node.parent.parent
 
diff --git a/lib/rules/valid-v-for.js b/lib/rules/valid-v-for.js
index 443afc2d0..81fcc8a0d 100644
--- a/lib/rules/valid-v-for.js
+++ b/lib/rules/valid-v-for.js
@@ -17,8 +17,8 @@ const utils = require('../utils')
 
 /**
  * Check whether the given attribute is using the variables which are defined by `v-for` directives.
- * @param {ASTNode} vFor The attribute node of `v-for` to check.
- * @param {ASTNode} vBindKey The attribute node of `v-bind:key` to check.
+ * @param {VDirective} vFor The attribute node of `v-for` to check.
+ * @param {VDirective} vBindKey The attribute node of `v-bind:key` to check.
  * @returns {boolean} `true` if the node is using the variables which are defined by `v-for` directives.
  */
 function isUsingIterationVar(vFor, vBindKey) {
@@ -38,14 +38,14 @@ function isUsingIterationVar(vFor, vBindKey) {
 /**
  * Check the child element in tempalte v-for about `v-bind:key` attributes.
  * @param {RuleContext} context The rule context to report.
- * @param {ASTNode} vFor The attribute node of `v-for` to check.
- * @param {ASTNode} child The child node to check.
+ * @param {VDirective} vFor The attribute node of `v-for` to check.
+ * @param {VElement} child The child node to check.
  */
 function checkChildKey(context, vFor, child) {
   const childFor = utils.getDirective(child, 'for')
   // if child has v-for, check if parent iterator is used in v-for
   if (childFor != null) {
-    const childForRefs = childFor.value.references
+    const childForRefs = (childFor.value && childFor.value.references) || []
     const variables = vFor.parent.parent.variables
     const usedInFor = childForRefs.some((cref) =>
       variables.some(
@@ -66,8 +66,8 @@ function checkChildKey(context, vFor, child) {
 /**
  * Check the given element about `v-bind:key` attributes.
  * @param {RuleContext} context The rule context to report.
- * @param {ASTNode} vFor The attribute node of `v-for` to check.
- * @param {ASTNode} element The element node to check.
+ * @param {VDirective} vFor The attribute node of `v-for` to check.
+ * @param {VElement} element The element node to check.
  */
 function checkKey(context, vFor, element) {
   if (element.name === 'template') {
@@ -113,11 +113,12 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='for']"(node) {
         const element = node.parent.parent
 
@@ -167,8 +168,7 @@ module.exports = {
 
         if (value === null) {
           context.report({
-            node: value || expr,
-            loc: value && value.loc,
+            node: expr,
             message: "Invalid alias ''."
           })
         }
diff --git a/lib/rules/valid-v-html.js b/lib/rules/valid-v-html.js
index 575939a2a..d88997682 100644
--- a/lib/rules/valid-v-html.js
+++ b/lib/rules/valid-v-html.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='html']"(node) {
         if (node.key.argument) {
           context.report({
diff --git a/lib/rules/valid-v-if.js b/lib/rules/valid-v-if.js
index c07ae2c81..b61435ab0 100644
--- a/lib/rules/valid-v-if.js
+++ b/lib/rules/valid-v-if.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='if']"(node) {
         const element = node.parent.parent
 
diff --git a/lib/rules/valid-v-model.js b/lib/rules/valid-v-model.js
index 0c7431c05..451787367 100644
--- a/lib/rules/valid-v-model.js
+++ b/lib/rules/valid-v-model.js
@@ -19,7 +19,7 @@ const VALID_MODIFIERS = new Set(['lazy', 'number', 'trim'])
 
 /**
  * Check whether the given node is valid or not.
- * @param {ASTNode} node The element node to check.
+ * @param {VElement} node The element node to check.
  * @returns {boolean} `true` if the node is valid.
  */
 function isValidElement(node) {
@@ -48,8 +48,8 @@ function isLhs(node) {
 /**
  * Get the variable by names.
  * @param {string} name The variable name to find.
- * @param {ASTNode} leafNode The node to look up.
- * @returns {Variable|null} The found variable or null.
+ * @param {VElement} leafNode The node to look up.
+ * @returns {VVariable|null} The found variable or null.
  */
 function getVariable(name, leafNode) {
   let node = leafNode
@@ -62,6 +62,10 @@ function getVariable(name, leafNode) {
       return variable
     }
 
+    if (node.parent.type === 'VDocumentFragment') {
+      break
+    }
+
     node = node.parent
   }
 
@@ -83,9 +87,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='model']"(node) {
         const element = node.parent.parent
         const name = element.name
diff --git a/lib/rules/valid-v-on.js b/lib/rules/valid-v-on.js
index bcdb76db0..4d55d7f19 100644
--- a/lib/rules/valid-v-on.js
+++ b/lib/rules/valid-v-on.js
@@ -46,6 +46,10 @@ const VERB_MODIFIERS = new Set(['stop', 'prevent'])
 // https://www.w3.org/TR/uievents-key/
 const KEY_ALIASES = new Set(keyAliases)
 
+/**
+ * @param {VIdentifier} modifierNode
+ * @param {Set<string>} customModifiers
+ */
 function isValidModifier(modifierNode, customModifiers) {
   const modifier = modifierNode.name
   return (
@@ -87,13 +91,15 @@ module.exports = {
       }
     ]
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
+    /** @type {Set<string>} */
     const customModifiers = new Set(options.modifiers || [])
     const sourceCode = context.getSourceCode()
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='on']"(node) {
         for (const modifier of node.key.modifiers) {
           if (!isValidModifier(modifier, customModifiers)) {
diff --git a/lib/rules/valid-v-once.js b/lib/rules/valid-v-once.js
index aef2ca37d..83ff3ddcf 100644
--- a/lib/rules/valid-v-once.js
+++ b/lib/rules/valid-v-once.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='once']"(node) {
         if (node.key.argument) {
           context.report({
diff --git a/lib/rules/valid-v-pre.js b/lib/rules/valid-v-pre.js
index c975b1e2d..90174db12 100644
--- a/lib/rules/valid-v-pre.js
+++ b/lib/rules/valid-v-pre.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='pre']"(node) {
         if (node.key.argument) {
           context.report({
diff --git a/lib/rules/valid-v-show.js b/lib/rules/valid-v-show.js
index 71553722c..d5378a63a 100644
--- a/lib/rules/valid-v-show.js
+++ b/lib/rules/valid-v-show.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='show']"(node) {
         if (node.key.argument) {
           context.report({
diff --git a/lib/rules/valid-v-slot.js b/lib/rules/valid-v-slot.js
index 118dc8463..a94d8c9dc 100644
--- a/lib/rules/valid-v-slot.js
+++ b/lib/rules/valid-v-slot.js
@@ -9,18 +9,16 @@ const utils = require('../utils')
 /**
  * Get all `v-slot` directives on a given element.
  * @param {VElement} node The VElement node to check.
- * @returns {VAttribute[]} The array of `v-slot` directives.
+ * @returns {VDirective[]} The array of `v-slot` directives.
  */
 function getSlotDirectivesOnElement(node) {
-  return node.startTag.attributes.filter(
-    (attribute) => attribute.directive && attribute.key.name.name === 'slot'
-  )
+  return utils.getDirectives(node, 'slot')
 }
 
 /**
  * Get all `v-slot` directives on the children of a given element.
  * @param {VElement} node The VElement node to check.
- * @returns {VAttribute[][]}
+ * @returns {VDirective[][]}
  * The array of the group of `v-slot` directives.
  * The group bundles `v-slot` directives of element sequence which is connected
  * by `v-if`/`v-else-if`/`v-else`.
@@ -58,7 +56,11 @@ function getSlotDirectivesOnChildren(node) {
         }
         return { groups, vIf }
       },
-      { groups: [], vIf: false }
+      {
+        /** @type {VElement[][]} */
+        groups: [],
+        vIf: false
+      }
     )
     .groups.map((group) =>
       group
@@ -67,14 +69,15 @@ function getSlotDirectivesOnChildren(node) {
             ? utils.getDirective(childElement, 'slot')
             : null
         )
-        .filter(Boolean)
+        .filter(utils.isDef)
     )
     .filter((group) => group.length >= 1)
 }
 
 /**
  * Get the normalized name of a given `v-slot` directive node.
- * @param {VAttribute} node The `v-slot` directive node.
+ * @param {VDirective} node The `v-slot` directive node.
+ * @param {SourceCode} sourceCode The source code.
  * @returns {string} The normalized name.
  */
 function getNormalizedName(node, sourceCode) {
@@ -85,9 +88,10 @@ function getNormalizedName(node, sourceCode) {
 
 /**
  * Get all `v-slot` directives which are distributed to the same slot as a given `v-slot` directive node.
- * @param {VAttribute[][]} vSlotGroups The result of `getAllNamedSlotElements()`.
- * @param {VElement} currentVSlot The current `v-slot` directive node.
- * @returns {VAttribute[][]} The array of the group of `v-slot` directives.
+ * @param {VDirective[][]} vSlotGroups The result of `getAllNamedSlotElements()`.
+ * @param {VDirective} currentVSlot The current `v-slot` directive node.
+ * @param {SourceCode} sourceCode The source code.
+ * @returns {VDirective[][]} The array of the group of `v-slot` directives.
  */
 function filterSameSlot(vSlotGroups, currentVSlot, sourceCode) {
   const currentName = getNormalizedName(currentVSlot, sourceCode)
@@ -124,7 +128,7 @@ function isUsingIterationVar(argument, element) {
 
 /**
  * Check whether a given argument node is using an scope variable that the directive defined.
- * @param {VAttribute} vSlot The `v-slot` directive to check.
+ * @param {VDirective} vSlot The `v-slot` directive to check.
  * @returns {boolean} `true` if that argument node is using a scope variable the directive defined.
  */
 function isUsingScopeVar(vSlot) {
@@ -143,6 +147,7 @@ function isUsingScopeVar(vSlot) {
       }
     }
   }
+  return false
 }
 
 module.exports = {
@@ -173,18 +178,24 @@ module.exports = {
         "'v-slot' directive on a custom element requires that attribute value."
     }
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     const sourceCode = context.getSourceCode()
 
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='slot']"(node) {
         const isDefaultSlot =
-          node.key.argument == null || node.key.argument.name === 'default'
+          node.key.argument == null ||
+          (node.key.argument.type === 'VIdentifier' &&
+            node.key.argument.name === 'default')
         const element = node.parent.parent
         const parentElement = element.parent
         const ownerElement =
           element.name === 'template' ? parentElement : element
+        if (ownerElement.type === 'VDocumentFragment') {
+          return
+        }
         const vSlotsOnElement = getSlotDirectivesOnElement(element)
         const vSlotGroupsOnChildren = getSlotDirectivesOnChildren(ownerElement)
 
diff --git a/lib/rules/valid-v-text.js b/lib/rules/valid-v-text.js
index f0a3f09fa..1e90ec688 100644
--- a/lib/rules/valid-v-text.js
+++ b/lib/rules/valid-v-text.js
@@ -26,9 +26,10 @@ module.exports = {
     fixable: null,
     schema: []
   },
-
+  /** @param {RuleContext} context */
   create(context) {
     return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VDirective} node */
       "VAttribute[directive=true][key.name.name='text']"(node) {
         if (node.key.argument) {
           context.report({
diff --git a/lib/utils/casing.js b/lib/utils/casing.js
index 4d5ca22aa..f6dea6d6e 100644
--- a/lib/utils/casing.js
+++ b/lib/utils/casing.js
@@ -1,23 +1,24 @@
-const assert = require('assert')
-
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
 
 /**
  * Capitalize a string.
+ * @param {string} str
  */
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1)
 }
 /**
  * Checks whether the given string has symbols.
+ * @param {string} str
  */
 function hasSymbols(str) {
   return /[!"#%&'()*+,./:;<=>?@[\\\]^`{|}]/u.exec(str) // without " ", "$", "-" and "_"
 }
 /**
  * Checks whether the given string has upper.
+ * @param {string} str
  */
 function hasUpper(str) {
   return /[A-Z]/u.exec(str)
@@ -37,6 +38,7 @@ function kebabCase(str) {
 
 /**
  * Checks whether the given string is kebab-case.
+ * @param {string} str
  */
 function isKebabCase(str) {
   if (
@@ -64,6 +66,7 @@ function snakeCase(str) {
 
 /**
  * Checks whether the given string is snake_case.
+ * @param {string} str
  */
 function isSnakeCase(str) {
   if (hasUpper(str) || hasSymbols(str) || /-|__|\s/u.exec(str)) {
@@ -86,6 +89,7 @@ function camelCase(str) {
 
 /**
  * Checks whether the given string is camelCase.
+ * @param {string} str
  */
 function isCamelCase(str) {
   if (
@@ -109,6 +113,7 @@ function pascalCase(str) {
 
 /**
  * Checks whether the given string is PascalCase.
+ * @param {string} str
  */
 function isPascalCase(str) {
   if (
@@ -136,23 +141,19 @@ const checkersMap = {
 }
 /**
  * Return case checker
- * @param {string} name type of checker to return ('camelCase', 'kebab-case', 'PascalCase')
- * @return {isKebabCase|isCamelCase|isPascalCase}
+ * @param { 'camelCase' | 'kebab-case' | 'PascalCase' | 'snake_case' } name type of checker to return ('camelCase', 'kebab-case', 'PascalCase')
+ * @return {isKebabCase|isCamelCase|isPascalCase|isSnakeCase}
  */
 function getChecker(name) {
-  assert(typeof name === 'string')
-
   return checkersMap[name] || isPascalCase
 }
 
 /**
  * Return case converter
- * @param {string} name type of converter to return ('camelCase', 'kebab-case', 'PascalCase')
- * @return {kebabCase|camelCase|pascalCase}
+ * @param { 'camelCase' | 'kebab-case' | 'PascalCase' | 'snake_case' } name type of converter to return ('camelCase', 'kebab-case', 'PascalCase')
+ * @return {kebabCase|camelCase|pascalCase|snakeCase}
  */
 function getConverter(name) {
-  assert(typeof name === 'string')
-
   return convertersMap[name] || pascalCase
 }
 
@@ -162,22 +163,22 @@ module.exports = {
   /**
    * Return case converter
    * @param {string} name type of converter to return ('camelCase', 'kebab-case', 'PascalCase')
-   * @return {kebabCase|camelCase|pascalCase}
+   * @return {kebabCase|camelCase|pascalCase|snakeCase}
    */
   getConverter,
 
   /**
    * Return case checker
    * @param {string} name type of checker to return ('camelCase', 'kebab-case', 'PascalCase')
-   * @return {isKebabCase|isCamelCase|isPascalCase}
+   * @return {isKebabCase|isCamelCase|isPascalCase|isSnakeCase}
    */
   getChecker,
 
   /**
    * Return case exact converter.
    * If the converted result is not the correct case, the original value is returned.
-   * @param {string} name type of converter to return ('camelCase', 'kebab-case', 'PascalCase')
-   * @return {kebabCase|camelCase|pascalCase}
+   * @param { 'camelCase' | 'kebab-case' | 'PascalCase' | 'snake_case' } name type of converter to return ('camelCase', 'kebab-case', 'PascalCase')
+   * @return {kebabCase|camelCase|pascalCase|snakeCase}
    */
   getExactConverter(name) {
     const converter = getConverter(name)
diff --git a/lib/utils/html-comments.js b/lib/utils/html-comments.js
index f214b7374..aced46e71 100644
--- a/lib/utils/html-comments.js
+++ b/lib/utils/html-comments.js
@@ -1,22 +1,14 @@
-/**
- * @typedef { import('eslint').SourceCode } SourceCode
- * @typedef { import('eslint').Rule.RuleContext } RuleContext
- * @typedef { import('vue-eslint-parser').AST.Token } ASTToken
- * @typedef { import('vue-eslint-parser').AST.HasLocation } HasLocation
- */
-
 /**
  * @typedef { { exceptions?: string[] } } CommentParserConfig
- * @typedef { (comment: HTMLComment) => void } HTMLCommentVisitor
+ * @typedef { (comment: ParsedHTMLComment) => void } HTMLCommentVisitor
  * @typedef { { includeDirectives?: boolean } } CommentVisitorOption
- * @typedef { ASTToken & { type: 'HTMLComment' } } HTMLCommentToken
  *
- * @typedef { ASTToken & { type: 'HTMLCommentOpen' } } HTMLCommentOpen
- * @typedef { ASTToken & { type: 'HTMLCommentOpenDecoration' } } HTMLCommentOpenDecoration
- * @typedef { ASTToken & { type: 'HTMLCommentValue' } } HTMLCommentValue
- * @typedef { ASTToken & { type: 'HTMLCommentClose' } } HTMLCommentClose
- * @typedef { ASTToken & { type: 'HTMLCommentCloseDecoration' } } HTMLCommentCloseDecoration
- * @typedef { { open: HTMLCommentOpen, openDecoration: HTMLCommentOpenDecoration | null, value: HTMLCommentValue | null, closeDecoration: HTMLCommentCloseDecoration | null, close: HTMLCommentClose } } HTMLComment
+ * @typedef { Token & { type: 'HTMLCommentOpen' } } HTMLCommentOpen
+ * @typedef { Token & { type: 'HTMLCommentOpenDecoration' } } HTMLCommentOpenDecoration
+ * @typedef { Token & { type: 'HTMLCommentValue' } } HTMLCommentValue
+ * @typedef { Token & { type: 'HTMLCommentClose' } } HTMLCommentClose
+ * @typedef { Token & { type: 'HTMLCommentCloseDecoration' } } HTMLCommentCloseDecoration
+ * @typedef { { open: HTMLCommentOpen, openDecoration: HTMLCommentOpenDecoration | null, value: HTMLCommentValue | null, closeDecoration: HTMLCommentCloseDecoration | null, close: HTMLCommentClose } } ParsedHTMLComment
  */
 // -----------------------------------------------------------------------------
 // Requirements
@@ -44,7 +36,7 @@ const TYPE_HTML_COMMENT_CLOSE = 'HTMLCommentClose'
 const TYPE_HTML_COMMENT_CLOSE_DECORATION = 'HTMLCommentCloseDecoration'
 
 /**
- * @param {HTMLCommentToken} comment
+ * @param {HTMLComment} comment
  * @returns {boolean}
  */
 function isCommentDirective(comment) {
@@ -52,7 +44,7 @@ function isCommentDirective(comment) {
 }
 
 /**
- * @param {HTMLCommentToken} comment
+ * @param {HTMLComment} comment
  * @returns {boolean}
  */
 function isIEConditionalComment(comment) {
@@ -66,8 +58,8 @@ function isIEConditionalComment(comment) {
  * Define HTML comment parser
  *
  * @param {SourceCode} sourceCode The source code instance.
- * @param {CommentParserConfig} config The config.
- * @returns { (node: ASTToken) => (HTMLComment | null) } HTML comment parser.
+ * @param {CommentParserConfig | null} config The config.
+ * @returns { (node: Token) => (ParsedHTMLComment | null) } HTML comment parser.
  */
 function defineParser(sourceCode, config) {
   config = config || {}
@@ -164,9 +156,10 @@ function defineParser(sourceCode, config) {
      * @returns {any}
      */
     const createToken = (type, value) => {
-      /** @type {[number,number]} */
+      /** @type {Range} */
       const range = [tokenIndex, tokenIndex + value.length]
       tokenIndex = range[1]
+      /** @type {SourceLocation} */
       let loc
       return {
         type,
@@ -222,15 +215,15 @@ function defineParser(sourceCode, config) {
  * Define HTML comment visitor
  *
  * @param {RuleContext} context The rule context.
- * @param {CommentParserConfig} config The config.
+ * @param {CommentParserConfig | null} config The config.
  * @param {HTMLCommentVisitor} visitHTMLComment The HTML comment visitor.
- * @param {CommentVisitorOption} visitorOption The option for visitor.
- * @returns {object} HTML comment visitor.
+ * @param {CommentVisitorOption} [visitorOption] The option for visitor.
+ * @returns {RuleListener} HTML comment visitor.
  */
 function defineVisitor(context, config, visitHTMLComment, visitorOption) {
-  visitorOption = visitorOption || {}
   return {
     Program(node) {
+      visitorOption = visitorOption || {}
       if (utils.hasInvalidEOF(node)) {
         return
       }
diff --git a/lib/utils/indent-common.js b/lib/utils/indent-common.js
index 97d285274..718f04278 100644
--- a/lib/utils/indent-common.js
+++ b/lib/utils/indent-common.js
@@ -8,8 +8,6 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
-const assert = require('assert')
-
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
@@ -122,14 +120,26 @@ const PREFORMATTED_ELEMENT_NAMES = ['pre', 'textarea']
  * @property {boolean} IndentOptions.alignAttributesVertically
  * @property {string[]} IndentOptions.ignores
  */
+/**
+ * @typedef {object} IndentUserOptions
+ * @property { " " | "\t" } [IndentUserOptions.indentChar]
+ * @property {number} [IndentUserOptions.indentSize]
+ * @property {number} [IndentUserOptions.baseIndent]
+ * @property {number} [IndentUserOptions.attribute]
+ * @property {IndentOptions['closeBracket'] | number} [IndentUserOptions.closeBracket]
+ * @property {number} [IndentUserOptions.switchCase]
+ * @property {boolean} [IndentUserOptions.alignAttributesVertically]
+ * @property {string[]} [IndentUserOptions.ignores]
+ */
 /**
  * Normalize options.
  * @param {number|"tab"|undefined} type The type of indentation.
- * @param {Object} options Other options.
- * @param {Object} defaultOptions The default value of options.
+ * @param {IndentUserOptions} options Other options.
+ * @param {Partial<IndentOptions>} defaultOptions The default value of options.
  * @returns {IndentOptions} Normalized options.
  */
 function parseOptions(type, options, defaultOptions) {
+  /** @type {IndentOptions} */
   const ret = Object.assign(
     {
       indentChar: ' ',
@@ -149,7 +159,7 @@ function parseOptions(type, options, defaultOptions) {
   )
 
   if (Number.isSafeInteger(type)) {
-    ret.indentSize = type
+    ret.indentSize = Number(type)
   } else if (type === 'tab') {
     ret.indentChar = '\t'
     ret.indentSize = 1
@@ -162,7 +172,7 @@ function parseOptions(type, options, defaultOptions) {
     ret.attribute = options.attribute
   }
   if (Number.isSafeInteger(options.closeBracket)) {
-    const num = options.closeBracket
+    const num = Number(options.closeBracket)
     ret.closeBracket = {
       startTag: num,
       endTag: num,
@@ -194,7 +204,7 @@ function parseOptions(type, options, defaultOptions) {
 
 /**
  * Check whether the given token is an arrow.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is an arrow.
  */
 function isArrow(token) {
@@ -203,7 +213,7 @@ function isArrow(token) {
 
 /**
  * Check whether the given token is a left parenthesis.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a left parenthesis.
  */
 function isLeftParen(token) {
@@ -212,7 +222,7 @@ function isLeftParen(token) {
 
 /**
  * Check whether the given token is a left parenthesis.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `false` if the token is a left parenthesis.
  */
 function isNotLeftParen(token) {
@@ -221,7 +231,7 @@ function isNotLeftParen(token) {
 
 /**
  * Check whether the given token is a right parenthesis.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a right parenthesis.
  */
 function isRightParen(token) {
@@ -230,7 +240,7 @@ function isRightParen(token) {
 
 /**
  * Check whether the given token is a right parenthesis.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `false` if the token is a right parenthesis.
  */
 function isNotRightParen(token) {
@@ -239,7 +249,7 @@ function isNotRightParen(token) {
 
 /**
  * Check whether the given token is a left brace.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a left brace.
  */
 function isLeftBrace(token) {
@@ -248,7 +258,7 @@ function isLeftBrace(token) {
 
 /**
  * Check whether the given token is a right brace.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a right brace.
  */
 function isRightBrace(token) {
@@ -257,7 +267,7 @@ function isRightBrace(token) {
 
 /**
  * Check whether the given token is a left bracket.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a left bracket.
  */
 function isLeftBracket(token) {
@@ -266,7 +276,7 @@ function isLeftBracket(token) {
 
 /**
  * Check whether the given token is a right bracket.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a right bracket.
  */
 function isRightBracket(token) {
@@ -275,7 +285,7 @@ function isRightBracket(token) {
 
 /**
  * Check whether the given token is a semicolon.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a semicolon.
  */
 function isSemicolon(token) {
@@ -284,7 +294,7 @@ function isSemicolon(token) {
 
 /**
  * Check whether the given token is a comma.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a comma.
  */
 function isComma(token) {
@@ -293,7 +303,7 @@ function isComma(token) {
 
 /**
  * Check whether the given token is a whitespace.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a whitespace.
  */
 function isNotWhitespace(token) {
@@ -302,7 +312,7 @@ function isNotWhitespace(token) {
 
 /**
  * Check whether the given token is a comment.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a comment.
  */
 function isComment(token) {
@@ -317,7 +327,7 @@ function isComment(token) {
 
 /**
  * Check whether the given token is a comment.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `false` if the token is a comment.
  */
 function isNotComment(token) {
@@ -332,7 +342,7 @@ function isNotComment(token) {
 
 /**
  * Check whether the given node is not an empty text node.
- * @param {Node} node The node to check.
+ * @param {ASTNode} node The node to check.
  * @returns {boolean} `false` if the token is empty text node.
  */
 function isNotEmptyTextNode(node) {
@@ -341,7 +351,7 @@ function isNotEmptyTextNode(node) {
 
 /**
  * Check whether the given token is a pipe operator.
- * @param {Token} token The token to check.
+ * @param {Token|undefined|null} token The token to check.
  * @returns {boolean} `true` if the token is a pipe operator.
  */
 function isPipeOperator(token) {
@@ -350,8 +360,9 @@ function isPipeOperator(token) {
 
 /**
  * Get the last element.
- * @param {Array} xs The array to get the last element.
- * @returns {any|undefined} The last element or undefined.
+ * @template T
+ * @param {T[]} xs The array to get the last element.
+ * @returns {T | undefined} The last element or undefined.
  */
 function last(xs) {
   return xs.length === 0 ? undefined : xs[xs.length - 1]
@@ -359,9 +370,9 @@ function last(xs) {
 
 /**
  * Check whether the node is at the beginning of line.
- * @param {Node} node The node to check.
+ * @param {ASTNode|null} node The node to check.
  * @param {number} index The index of the node in the nodes.
- * @param {Node[]} nodes The array of nodes.
+ * @param {(ASTNode|null)[]} nodes The array of nodes.
  * @returns {boolean} `true` if the node is at the beginning of line.
  */
 function isBeginningOfLine(node, index, nodes) {
@@ -397,9 +408,9 @@ function isClosingToken(token) {
  * Creates AST event handlers for html-indent.
  *
  * @param {RuleContext} context The rule context.
- * @param {TokenStore} tokenStore The token store object to get tokens.
- * @param {Object} defaultOptions The default value of options.
- * @returns {object} AST event handlers.
+ * @param {ParserServices.TokenStore | SourceCode} tokenStore The token store object to get tokens.
+ * @param {Partial<IndentOptions>} defaultOptions The default value of options.
+ * @returns {NodeListener} AST event handlers.
  */
 module.exports.defineVisitor = function create(
   context,
@@ -419,15 +430,15 @@ module.exports.defineVisitor = function create(
 
   /**
    * Set offset to the given tokens.
-   * @param {Token|Token[]} token The token to set.
+   * @param {Token|Token[]|null|(Token|null)[]} token The token to set.
    * @param {number} offset The offset of the tokens.
    * @param {Token} baseToken The token of the base offset.
-   * @param {boolean} [trivial=false] The flag for trivial tokens.
    * @returns {void}
    */
   function setOffset(token, offset, baseToken) {
-    assert(baseToken != null, "'baseToken' should not be null or undefined.")
-
+    if (!token) {
+      return
+    }
     if (Array.isArray(token)) {
       for (const t of token) {
         offsets.set(t, {
@@ -461,7 +472,7 @@ module.exports.defineVisitor = function create(
 
   /**
    * Sets preformatted tokens to the given element node.
-   * @param {Node} node The node to set.
+   * @param {VElement} node The node to set.
    * @returns {void}
    */
   function setPreformattedTokens(node) {
@@ -469,6 +480,7 @@ module.exports.defineVisitor = function create(
       (node.endTag && tokenStore.getFirstToken(node.endTag)) ||
       tokenStore.getTokenAfter(node)
 
+    /** @type {SourceCode.CursorWithSkipOptions} */
     const option = {
       includeComments: true,
       filter: (token) =>
@@ -492,11 +504,11 @@ module.exports.defineVisitor = function create(
   /**
    * Get the first and last tokens of the given node.
    * If the node is parenthesized, this gets the outermost parentheses.
-   * @param {Node} node The node to get.
+   * @param {ASTNode} node The node to get.
    * @param {number} [borderOffset] The least offset of the first token. Defailt is 0. This value is used to prevent false positive in the following case: `(a) => {}` The parentheses are enclosing the whole parameter part rather than the first parameter, but this offset parameter is needed to distinguish.
    * @returns {{firstToken:Token,lastToken:Token}} The gotten tokens.
    */
-  function getFirstAndLastTokens(node, borderOffset) {
+  function getFirstAndLastTokens(node, borderOffset = 0) {
     borderOffset |= 0
 
     let firstToken = tokenStore.getFirstToken(node)
@@ -522,17 +534,17 @@ module.exports.defineVisitor = function create(
    * Process the given node list.
    * The first node is offsetted from the given left token.
    * Rest nodes are adjusted to the first node.
-   * @param {Node[]} nodeList The node to process.
-   * @param {Node|Token|null} left The left parenthesis token.
-   * @param {Node|Token|null} right The right parenthesis token.
+   * @param {(ASTNode|null)[]} nodeList The node to process.
+   * @param {ASTNode|Token|null} left The left parenthesis token.
+   * @param {ASTNode|Token|null} right The right parenthesis token.
    * @param {number} offset The offset to set.
    * @param {boolean} [alignVertically=true] The flag to align vertically. If `false`, this doesn't align vertically even if the first node is not at beginning of line.
    * @returns {void}
    */
   function processNodeList(nodeList, left, right, offset, alignVertically) {
     let t
-    const leftToken = (left && tokenStore.getFirstToken(left)) || left
-    const rightToken = (right && tokenStore.getFirstToken(right)) || right
+    const leftToken = left && tokenStore.getFirstToken(left)
+    const rightToken = right && tokenStore.getFirstToken(right)
 
     if (nodeList.length >= 1) {
       let baseToken = null
@@ -616,7 +628,7 @@ module.exports.defineVisitor = function create(
       }
     }
 
-    if (rightToken != null) {
+    if (rightToken != null && leftToken != null) {
       setOffset(rightToken, 0, leftToken)
     }
   }
@@ -624,7 +636,7 @@ module.exports.defineVisitor = function create(
   /**
    * Process the given node as body.
    * The body node maybe a block statement or an expression node.
-   * @param {Node} node The body node to process.
+   * @param {ASTNode} node The body node to process.
    * @param {Token} baseToken The base token.
    * @returns {void}
    */
@@ -641,6 +653,7 @@ module.exports.defineVisitor = function create(
   function getPrefixTokens(node) {
     const prefixes = []
 
+    /** @type {Token|null} */
     let token = tokenStore.getFirstToken(node)
     while (token != null && token.range[1] <= node.key.range[0]) {
       prefixes.push(token)
@@ -655,12 +668,12 @@ module.exports.defineVisitor = function create(
 
   /**
    * Find the head of chaining nodes.
-   * @param {Node} node The start node to find the head.
+   * @param {ASTNode} node The start node to find the head.
    * @returns {Token} The head token of the chain.
    */
   function getChainHeadToken(node) {
     const type = node.type
-    while (node.parent.type === type) {
+    while (node.parent && node.parent.type === type) {
       const prevToken = tokenStore.getTokenBefore(node)
       if (isLeftParen(prevToken)) {
         // The chaining is broken by parentheses.
@@ -681,19 +694,21 @@ module.exports.defineVisitor = function create(
    * - An expression of SequenceExpression
    *
    * @param {Token} token The token to check.
-   * @param {Node} belongingNode The node that the token is belonging to.
+   * @param {ASTNode} belongingNode The node that the token is belonging to.
    * @returns {boolean} `true` if the token is the first token of an element.
    */
   function isBeginningOfElement(token, belongingNode) {
     let node = belongingNode
 
-    while (node != null) {
+    while (node != null && node.parent != null) {
       const parent = node.parent
-      const t = parent && parent.type
-      if (t != null && (t.endsWith('Statement') || t.endsWith('Declaration'))) {
+      if (
+        parent.type.endsWith('Statement') ||
+        parent.type.endsWith('Declaration')
+      ) {
         return parent.range[0] === token.range[0]
       }
-      if (t === 'VExpressionContainer') {
+      if (parent.type === 'VExpressionContainer') {
         if (node.range[0] !== token.range[0]) {
           return false
         }
@@ -704,18 +719,18 @@ module.exports.defineVisitor = function create(
         }
         return true
       }
-      if (t === 'CallExpression' || t === 'NewExpression') {
-        const openParen = tokenStore.getTokenAfter(
+      if (parent.type === 'CallExpression' || parent.type === 'NewExpression') {
+        const openParen = /** @type {Token} */ (tokenStore.getTokenAfter(
           parent.callee,
           isNotRightParen
-        )
+        ))
         return parent.arguments.some(
           (param) =>
             getFirstAndLastTokens(param, openParen.range[1]).firstToken
               .range[0] === token.range[0]
         )
       }
-      if (t === 'ArrayExpression') {
+      if (parent.type === 'ArrayExpression') {
         return parent.elements.some(
           (element) =>
             element != null &&
@@ -723,7 +738,7 @@ module.exports.defineVisitor = function create(
               token.range[0]
         )
       }
-      if (t === 'SequenceExpression') {
+      if (parent.type === 'SequenceExpression') {
         return parent.expressions.some(
           (expr) =>
             getFirstAndLastTokens(expr).firstToken.range[0] === token.range[0]
@@ -738,7 +753,7 @@ module.exports.defineVisitor = function create(
 
   /**
    * Set the base indentation to a given top-level AST node.
-   * @param {Node} node The node to set.
+   * @param {ASTNode} node The node to set.
    * @param {number} expectedIndent The number of expected indent.
    * @returns {void}
    */
@@ -759,7 +774,7 @@ module.exports.defineVisitor = function create(
 
   /**
    * Ignore all tokens of the given node.
-   * @param {Node} node The node to ignore.
+   * @param {ASTNode} node The node to ignore.
    * @returns {void}
    */
   function ignore(node) {
@@ -771,8 +786,8 @@ module.exports.defineVisitor = function create(
 
   /**
    * Define functions to ignore nodes into the given visitor.
-   * @param {Object} visitor The visitor to define functions to ignore nodes.
-   * @returns {Object} The visitor.
+   * @param {NodeListener} visitor The visitor to define functions to ignore nodes.
+   * @returns {NodeListener} The visitor.
    */
   function processIgnores(visitor) {
     for (const ignorePattern of options.ignores) {
@@ -781,6 +796,7 @@ module.exports.defineVisitor = function create(
       if (visitor.hasOwnProperty(key)) {
         const handler = visitor[key]
         visitor[key] = function (node, ...args) {
+          // @ts-expect-error
           const ret = handler.call(this, node, ...args)
           ignore(node)
           return ret
@@ -796,7 +812,7 @@ module.exports.defineVisitor = function create(
   /**
    * Calculate correct indentation of the line of the given tokens.
    * @param {Token[]} tokens Tokens which are on the same line.
-   * @returns {object|null} Correct indentation. If it failed to calculate then `null`.
+   * @returns { { expectedIndent: number, expectedBaseIndent: number } |null } Correct indentation. If it failed to calculate then `null`.
    */
   function getExpectedIndents(tokens) {
     const expectedIndents = []
@@ -855,17 +871,18 @@ module.exports.defineVisitor = function create(
   /**
    * Define the function which fixes the problem.
    * @param {Token} token The token to fix.
-   * @param {number} actualIndent The number of actual indentaion.
+   * @param {number} actualIndent The number of actual indentation.
    * @param {number} expectedIndent The number of expected indentation.
-   * @returns {Function} The defined function.
+   * @returns { (fixer: RuleFixer) => Fix } The defined function.
    */
   function defineFix(token, actualIndent, expectedIndent) {
     if (token.type === 'Block' && token.loc.start.line !== token.loc.end.line) {
       // Fix indentation in multiline block comments.
-      const lines = sourceCode.getText(token).match(LINES)
+      const lines = sourceCode.getText(token).match(LINES) || []
       const firstLine = lines.shift()
       if (lines.every((l) => BLOCK_COMMENT_PREFIX.test(l))) {
         return (fixer) => {
+          /** @type {Range} */
           const range = [token.range[0] - actualIndent, token.range[1]]
           const indent = options.indentChar.repeat(expectedIndent)
 
@@ -880,6 +897,7 @@ module.exports.defineVisitor = function create(
     }
 
     return (fixer) => {
+      /** @type {Range} */
       const range = [token.range[0] - actualIndent, token.range[0]]
       const indent = options.indentChar.repeat(expectedIndent)
       return fixer.replaceTextRange(range, indent)
@@ -890,7 +908,7 @@ module.exports.defineVisitor = function create(
    * Validate the given token with the pre-calculated expected indentation.
    * @param {Token} token The token to validate.
    * @param {number} expectedIndent The expected indentation.
-   * @param {number[]|undefined} optionalExpectedIndents The optional expected indentation.
+   * @param {number[]} [optionalExpectedIndents] The optional expected indentation.
    * @returns {void}
    */
   function validateCore(token, expectedIndent, optionalExpectedIndents) {
@@ -952,9 +970,9 @@ module.exports.defineVisitor = function create(
 
   /**
    * Get the expected indent of comments.
-   * @param {Token|null} nextToken The next token of comments.
-   * @param {number|undefined} nextExpectedIndent The expected indent of the next token.
-   * @param {number|undefined} lastExpectedIndent The expected indent of the last token.
+   * @param {Token} nextToken The next token of comments.
+   * @param {number} nextExpectedIndent The expected indent of the next token.
+   * @param {number} lastExpectedIndent The expected indent of the last token.
    * @returns {number[]}
    */
   function getCommentExpectedIndents(
@@ -1088,6 +1106,7 @@ module.exports.defineVisitor = function create(
   // ------------------------------------------------------------------------------
 
   return processIgnores({
+    /** @param {VAttribute} node */
     VAttribute(node) {
       const keyToken = tokenStore.getFirstToken(node)
       const eqToken = tokenStore.getTokenAfter(node.key)
@@ -1101,7 +1120,7 @@ module.exports.defineVisitor = function create(
         }
       }
     },
-
+    /** @param {VElement} node */
     VElement(node) {
       if (!PREFORMATTED_ELEMENT_NAMES.includes(node.name)) {
         const isTopLevel = node.parent.type !== 'VElement'
@@ -1120,7 +1139,7 @@ module.exports.defineVisitor = function create(
         setPreformattedTokens(node)
       }
     },
-
+    /** @param {VEndTag} node */
     VEndTag(node) {
       const element = node.parent
       const startTagOpenToken = tokenStore.getFirstToken(element.startTag)
@@ -1130,7 +1149,7 @@ module.exports.defineVisitor = function create(
         setOffset(closeToken, options.closeBracket.endTag, startTagOpenToken)
       }
     },
-
+    /** @param {VExpressionContainer} node */
     VExpressionContainer(node) {
       if (
         node.expression != null &&
@@ -1144,7 +1163,7 @@ module.exports.defineVisitor = function create(
         setOffset(endQuoteToken, 0, startQuoteToken)
       }
     },
-
+    /** @param {VFilter} node */
     VFilter(node) {
       const idToken = tokenStore.getFirstToken(node)
       const lastToken = tokenStore.getLastToken(node)
@@ -1154,13 +1173,14 @@ module.exports.defineVisitor = function create(
         processNodeList(node.arguments, leftParenToken, lastToken, 1)
       }
     },
-
+    /** @param {VFilterSequenceExpression} node */
     VFilterSequenceExpression(node) {
       if (node.filters.length === 0) {
         return
       }
 
       const firstToken = tokenStore.getFirstToken(node)
+      /** @type {(Token|null)[]} */
       const tokens = []
 
       for (const filter of node.filters) {
@@ -1172,11 +1192,14 @@ module.exports.defineVisitor = function create(
 
       setOffset(tokens, 1, firstToken)
     },
-
+    /** @param {VForExpression} node */
     VForExpression(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const lastOfLeft = last(node.left) || firstToken
-      const inToken = tokenStore.getTokenAfter(lastOfLeft, isNotRightParen)
+      const inToken = /** @type {Token} */ (tokenStore.getTokenAfter(
+        lastOfLeft,
+        isNotRightParen
+      ))
       const rightToken = tokenStore.getFirstToken(node.right)
 
       if (isLeftParen(firstToken)) {
@@ -1186,11 +1209,11 @@ module.exports.defineVisitor = function create(
       setOffset(inToken, 1, firstToken)
       setOffset(rightToken, 1, inToken)
     },
-
+    /** @param {VOnExpression} node */
     VOnExpression(node) {
       processNodeList(node.body, null, null, 0)
     },
-
+    /** @param {VStartTag} node */
     VStartTag(node) {
       const openToken = tokenStore.getFirstToken(node)
       const closeToken = tokenStore.getLastToken(node)
@@ -1210,7 +1233,7 @@ module.exports.defineVisitor = function create(
         setOffset(closeToken, offset, openToken)
       }
     },
-
+    /** @param {VText} node */
     VText(node) {
       const tokens = tokenStore.getTokens(node, isNotWhitespace)
       const firstTokenInfo = offsets.get(tokenStore.getFirstToken(node))
@@ -1219,7 +1242,7 @@ module.exports.defineVisitor = function create(
         offsets.set(token, Object.assign({}, firstTokenInfo))
       }
     },
-
+    /** @param {ArrayExpression | ArrayPattern} node */
     'ArrayExpression, ArrayPattern'(node) {
       processNodeList(
         node.elements,
@@ -1228,7 +1251,7 @@ module.exports.defineVisitor = function create(
         1
       )
     },
-
+    /** @param {ArrowFunctionExpression} node */
     ArrowFunctionExpression(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const secondToken = tokenStore.getTokenAfter(firstToken)
@@ -1249,12 +1272,15 @@ module.exports.defineVisitor = function create(
       setOffset(arrowToken, 1, firstToken)
       processMaybeBlock(node.body, firstToken)
     },
-
+    /** @param {AssignmentExpression | AssignmentPattern | BinaryExpression | LogicalExpression} node */
     'AssignmentExpression, AssignmentPattern, BinaryExpression, LogicalExpression'(
       node
     ) {
       const leftToken = getChainHeadToken(node)
-      const opToken = tokenStore.getTokenAfter(node.left, isNotRightParen)
+      const opToken = /** @type {Token} */ (tokenStore.getTokenAfter(
+        node.left,
+        isNotRightParen
+      ))
       const rightToken = tokenStore.getTokenAfter(opToken)
       const prevToken = tokenStore.getTokenBefore(leftToken)
       const shouldIndent =
@@ -1264,14 +1290,14 @@ module.exports.defineVisitor = function create(
 
       setOffset([opToken, rightToken], shouldIndent ? 1 : 0, leftToken)
     },
-
+    /** @param {AwaitExpression | RestElement | SpreadElement | UnaryExpression} node */
     'AwaitExpression, RestElement, SpreadElement, UnaryExpression'(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const nextToken = tokenStore.getTokenAfter(firstToken)
 
       setOffset(nextToken, 1, firstToken)
     },
-
+    /** @param {BlockStatement | ClassBody} node */
     'BlockStatement, ClassBody'(node) {
       processNodeList(
         node.body,
@@ -1280,16 +1306,22 @@ module.exports.defineVisitor = function create(
         1
       )
     },
-
+    /** @param {BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement} node */
     'BreakStatement, ContinueStatement, ReturnStatement, ThrowStatement'(node) {
-      if (node.argument != null || node.label != null) {
+      if (
+        ((node.type === 'ReturnStatement' || node.type === 'ThrowStatement') &&
+          node.argument != null) ||
+        ((node.type === 'BreakStatement' ||
+          node.type === 'ContinueStatement') &&
+          node.label != null)
+      ) {
         const firstToken = tokenStore.getFirstToken(node)
         const nextToken = tokenStore.getTokenAfter(firstToken)
 
         setOffset(nextToken, 1, firstToken)
       }
     },
-
+    /** @param {CallExpression} node */
     CallExpression(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const rightToken = tokenStore.getLastToken(node)
@@ -1298,7 +1330,7 @@ module.exports.defineVisitor = function create(
       setOffset(leftToken, 1, firstToken)
       processNodeList(node.arguments, leftToken, rightToken, 1)
     },
-
+    /** @param {CatchClause} node */
     CatchClause(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const bodyToken = tokenStore.getFirstToken(node.body)
@@ -1312,7 +1344,7 @@ module.exports.defineVisitor = function create(
       }
       setOffset(bodyToken, 0, firstToken)
     },
-
+    /** @param {ClassDeclaration | ClassExpression} node */
     'ClassDeclaration, ClassExpression'(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const bodyToken = tokenStore.getFirstToken(node.body)
@@ -1328,16 +1360,19 @@ module.exports.defineVisitor = function create(
       }
       setOffset(bodyToken, 0, firstToken)
     },
-
+    /** @param {ConditionalExpression} node */
     ConditionalExpression(node) {
       const prevToken = tokenStore.getTokenBefore(node)
       const firstToken = tokenStore.getFirstToken(node)
-      const questionToken = tokenStore.getTokenAfter(node.test, isNotRightParen)
+      const questionToken = /** @type {Token} */ (tokenStore.getTokenAfter(
+        node.test,
+        isNotRightParen
+      ))
       const consequentToken = tokenStore.getTokenAfter(questionToken)
-      const colonToken = tokenStore.getTokenAfter(
+      const colonToken = /** @type {Token} */ (tokenStore.getTokenAfter(
         node.consequent,
         isNotRightParen
-      )
+      ))
       const alternateToken = tokenStore.getTokenAfter(colonToken)
       const isFlat =
         prevToken &&
@@ -1355,10 +1390,13 @@ module.exports.defineVisitor = function create(
         setOffset([consequentToken, alternateToken], 1, questionToken)
       }
     },
-
+    /** @param {DoWhileStatement} node */
     DoWhileStatement(node) {
       const doToken = tokenStore.getFirstToken(node)
-      const whileToken = tokenStore.getTokenAfter(node.body, isNotRightParen)
+      const whileToken = /** @type {Token} */ (tokenStore.getTokenAfter(
+        node.body,
+        isNotRightParen
+      ))
       const leftToken = tokenStore.getTokenAfter(whileToken)
       const testToken = tokenStore.getTokenAfter(leftToken)
       const lastToken = tokenStore.getLastToken(node)
@@ -1372,16 +1410,16 @@ module.exports.defineVisitor = function create(
       setOffset(testToken, 1, leftToken)
       setOffset(rightToken, 0, leftToken)
     },
-
+    /** @param {ExportAllDeclaration} node */
     ExportAllDeclaration(node) {
       const tokens = tokenStore.getTokens(node)
-      const firstToken = tokens.shift()
+      const firstToken = /** @type {Token} */ (tokens.shift())
       if (isSemicolon(last(tokens))) {
         tokens.pop()
       }
       setOffset(tokens, 1, firstToken)
     },
-
+    /** @param {ExportDefaultDeclaration} node */
     ExportDefaultDeclaration(node) {
       const exportToken = tokenStore.getFirstToken(node)
       const defaultToken = tokenStore.getFirstToken(node, 1)
@@ -1389,7 +1427,7 @@ module.exports.defineVisitor = function create(
         .firstToken
       setOffset([defaultToken, declarationToken], 1, exportToken)
     },
-
+    /** @param {ExportNamedDeclaration} node */
     ExportNamedDeclaration(node) {
       const exportToken = tokenStore.getFirstToken(node)
       if (node.declaration) {
@@ -1399,7 +1437,10 @@ module.exports.defineVisitor = function create(
       } else {
         // export {foo, bar}; or export {foo, bar} from "mod";
         const leftParenToken = tokenStore.getFirstToken(node, 1)
-        const rightParenToken = tokenStore.getLastToken(node, isRightBrace)
+        const rightParenToken = /** @type {Token} */ (tokenStore.getLastToken(
+          node,
+          isRightBrace
+        ))
         setOffset(leftParenToken, 0, exportToken)
         processNodeList(node.specifiers, leftParenToken, rightParenToken, 1)
 
@@ -1414,18 +1455,21 @@ module.exports.defineVisitor = function create(
         }
       }
     },
-
+    /** @param {ExportSpecifier} node */
     ExportSpecifier(node) {
       const tokens = tokenStore.getTokens(node)
-      const firstToken = tokens.shift()
+      const firstToken = /** @type {Token} */ (tokens.shift())
       setOffset(tokens, 1, firstToken)
     },
-
+    /** @param {ForInStatement | ForOfStatement} node */
     'ForInStatement, ForOfStatement'(node) {
       const forToken = tokenStore.getFirstToken(node)
       const leftParenToken = tokenStore.getTokenAfter(forToken)
       const leftToken = tokenStore.getTokenAfter(leftParenToken)
-      const inToken = tokenStore.getTokenAfter(leftToken, isNotRightParen)
+      const inToken = /** @type {Token} */ (tokenStore.getTokenAfter(
+        leftToken,
+        isNotRightParen
+      ))
       const rightToken = tokenStore.getTokenAfter(inToken)
       const rightParenToken = tokenStore.getTokenBefore(
         node.body,
@@ -1439,7 +1483,7 @@ module.exports.defineVisitor = function create(
       setOffset(rightParenToken, 0, leftParenToken)
       processMaybeBlock(node.body, forToken)
     },
-
+    /** @param {ForStatement} node */
     ForStatement(node) {
       const forToken = tokenStore.getFirstToken(node)
       const leftParenToken = tokenStore.getTokenAfter(forToken)
@@ -1457,7 +1501,7 @@ module.exports.defineVisitor = function create(
       )
       processMaybeBlock(node.body, forToken)
     },
-
+    /** @param {FunctionDeclaration | FunctionExpression} node */
     'FunctionDeclaration, FunctionExpression'(node) {
       const firstToken = tokenStore.getFirstToken(node)
       if (isLeftParen(firstToken)) {
@@ -1503,7 +1547,7 @@ module.exports.defineVisitor = function create(
         setOffset(bodyToken, 0, firstToken)
       }
     },
-
+    /** @param {IfStatement} node */
     IfStatement(node) {
       const ifToken = tokenStore.getFirstToken(node)
       const ifLeftParenToken = tokenStore.getTokenAfter(ifToken)
@@ -1517,21 +1561,22 @@ module.exports.defineVisitor = function create(
       processMaybeBlock(node.consequent, ifToken)
 
       if (node.alternate != null) {
-        const elseToken = tokenStore.getTokenAfter(
+        const elseToken = /** @type {Token} */ (tokenStore.getTokenAfter(
           node.consequent,
           isNotRightParen
-        )
+        ))
 
         setOffset(elseToken, 0, ifToken)
         processMaybeBlock(node.alternate, elseToken)
       }
     },
-
+    /** @param {ImportDeclaration} node */
     ImportDeclaration(node) {
       const firstSpecifier = node.specifiers[0]
       const secondSpecifier = node.specifiers[1]
       const importToken = tokenStore.getFirstToken(node)
       const hasSemi = tokenStore.getLastToken(node).value === ';'
+      /** @type {Token[]} */
       const tokens = [] // tokens to one indent
 
       if (!firstSpecifier) {
@@ -1614,21 +1659,21 @@ module.exports.defineVisitor = function create(
 
       setOffset(tokens, 1, importToken)
     },
-
+    /** @param {ImportSpecifier} node */
     ImportSpecifier(node) {
       if (node.local.range[0] !== node.imported.range[0]) {
         const tokens = tokenStore.getTokens(node)
-        const firstToken = tokens.shift()
+        const firstToken = /** @type {Token} */ (tokens.shift())
         setOffset(tokens, 1, firstToken)
       }
     },
-
+    /** @param {ImportNamespaceSpecifier} node */
     ImportNamespaceSpecifier(node) {
       const tokens = tokenStore.getTokens(node)
-      const firstToken = tokens.shift()
+      const firstToken = /** @type {Token} */ (tokens.shift())
       setOffset(tokens, 1, firstToken)
     },
-
+    /** @param {LabeledStatement} node */
     LabeledStatement(node) {
       const labelToken = tokenStore.getFirstToken(node)
       const colonToken = tokenStore.getTokenAfter(labelToken)
@@ -1636,14 +1681,14 @@ module.exports.defineVisitor = function create(
 
       setOffset([colonToken, bodyToken], 1, labelToken)
     },
-
+    /** @param {MemberExpression | MetaProperty} node */
     'MemberExpression, MetaProperty'(node) {
       const objectToken = tokenStore.getFirstToken(node)
-      if (node.computed) {
-        const leftBracketToken = tokenStore.getTokenBefore(
+      if (node.type === 'MemberExpression' && node.computed) {
+        const leftBracketToken = /** @type {Token} */ (tokenStore.getTokenBefore(
           node.property,
           isLeftBracket
-        )
+        ))
         const propertyToken = tokenStore.getTokenAfter(leftBracketToken)
         const rightBracketToken = tokenStore.getTokenAfter(
           node.property,
@@ -1660,7 +1705,7 @@ module.exports.defineVisitor = function create(
         setOffset([dotToken, propertyToken], 1, objectToken)
       }
     },
-
+    /** @param {MethodDefinition | Property} node */
     'MethodDefinition, Property'(node) {
       const isMethod = node.type === 'MethodDefinition' || node.method === true
       const prefixTokens = getPrefixTokens(node)
@@ -1670,17 +1715,21 @@ module.exports.defineVisitor = function create(
         setOffset(prefixTokens[i], 0, prefixTokens[i - 1])
       }
 
-      let lastKeyToken = null
+      /** @type {Token} */
+      let lastKeyToken
       if (node.computed) {
-        const keyLeftToken = tokenStore.getFirstToken(node, isLeftBracket)
+        const keyLeftToken = /** @type {Token} */ (tokenStore.getFirstToken(
+          node,
+          isLeftBracket
+        ))
         const keyToken = tokenStore.getTokenAfter(keyLeftToken)
-        const keyRightToken = (lastKeyToken = tokenStore.getTokenAfter(
+        const keyRightToken = (lastKeyToken = /** @type {Token} */ (tokenStore.getTokenAfter(
           node.key,
           isRightBracket
-        ))
+        )))
 
         if (hasPrefix) {
-          setOffset(keyLeftToken, 0, last(prefixTokens))
+          setOffset(keyLeftToken, 0, /** @type {Token} */ (last(prefixTokens)))
         }
         setOffset(keyToken, 1, keyLeftToken)
         setOffset(keyRightToken, 0, keyLeftToken)
@@ -1688,7 +1737,7 @@ module.exports.defineVisitor = function create(
         const idToken = (lastKeyToken = tokenStore.getFirstToken(node.key))
 
         if (hasPrefix) {
-          setOffset(idToken, 0, last(prefixTokens))
+          setOffset(idToken, 0, /** @type {Token} */ (last(prefixTokens)))
         }
       }
 
@@ -1696,14 +1745,14 @@ module.exports.defineVisitor = function create(
         const leftParenToken = tokenStore.getTokenAfter(lastKeyToken)
 
         setOffset(leftParenToken, 1, lastKeyToken)
-      } else if (!node.shorthand) {
+      } else if (node.type === 'Property' && !node.shorthand) {
         const colonToken = tokenStore.getTokenAfter(lastKeyToken)
         const valueToken = tokenStore.getTokenAfter(colonToken)
 
         setOffset([colonToken, valueToken], 1, lastKeyToken)
       }
     },
-
+    /** @param {NewExpression} node */
     NewExpression(node) {
       const newToken = tokenStore.getFirstToken(node)
       const calleeToken = tokenStore.getTokenAfter(newToken)
@@ -1718,7 +1767,7 @@ module.exports.defineVisitor = function create(
         processNodeList(node.arguments, leftToken, rightToken, 1)
       }
     },
-
+    /** @param {ObjectExpression | ObjectPattern} node */
     'ObjectExpression, ObjectPattern'(node) {
       processNodeList(
         node.properties,
@@ -1727,11 +1776,11 @@ module.exports.defineVisitor = function create(
         1
       )
     },
-
+    /** @param {SequenceExpression} node */
     SequenceExpression(node) {
       processNodeList(node.expressions, null, null, 0)
     },
-
+    /** @param {SwitchCase} node */
     SwitchCase(node) {
       const caseToken = tokenStore.getFirstToken(node)
 
@@ -1756,15 +1805,15 @@ module.exports.defineVisitor = function create(
         processNodeList(node.consequent, null, null, 0)
       }
     },
-
+    /** @param {SwitchStatement} node */
     SwitchStatement(node) {
       const switchToken = tokenStore.getFirstToken(node)
       const leftParenToken = tokenStore.getTokenAfter(switchToken)
       const discriminantToken = tokenStore.getTokenAfter(leftParenToken)
-      const leftBraceToken = tokenStore.getTokenAfter(
+      const leftBraceToken = /** @type {Token} */ (tokenStore.getTokenAfter(
         node.discriminant,
         isLeftBrace
-      )
+      ))
       const rightParenToken = tokenStore.getTokenBefore(leftBraceToken)
       const rightBraceToken = tokenStore.getLastToken(node)
 
@@ -1779,14 +1828,14 @@ module.exports.defineVisitor = function create(
         options.switchCase
       )
     },
-
+    /** @param {TaggedTemplateExpression} node */
     TaggedTemplateExpression(node) {
       const tagTokens = getFirstAndLastTokens(node.tag, node.range[0])
       const quasiToken = tokenStore.getTokenAfter(tagTokens.lastToken)
 
       setOffset(quasiToken, 1, tagTokens.firstToken)
     },
-
+    /** @param {TemplateLiteral} node */
     TemplateLiteral(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const quasiTokens = node.quasis
@@ -1799,7 +1848,7 @@ module.exports.defineVisitor = function create(
       setOffset(quasiTokens, 0, firstToken)
       setOffset(expressionToken, 1, firstToken)
     },
-
+    /** @param {TryStatement} node */
     TryStatement(node) {
       const tryToken = tokenStore.getFirstToken(node)
       const tryBlockToken = tokenStore.getFirstToken(node.block)
@@ -1819,14 +1868,14 @@ module.exports.defineVisitor = function create(
         setOffset([finallyToken, finallyBlockToken], 0, tryToken)
       }
     },
-
+    /** @param {UpdateExpression} node */
     UpdateExpression(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const nextToken = tokenStore.getTokenAfter(firstToken)
 
       setOffset(nextToken, 1, firstToken)
     },
-
+    /** @param {VariableDeclaration} node */
     VariableDeclaration(node) {
       processNodeList(
         node.declarations,
@@ -1835,7 +1884,7 @@ module.exports.defineVisitor = function create(
         1
       )
     },
-
+    /** @param {VariableDeclarator} node */
     VariableDeclarator(node) {
       if (node.init != null) {
         const idToken = tokenStore.getFirstToken(node)
@@ -1845,7 +1894,7 @@ module.exports.defineVisitor = function create(
         setOffset([eqToken, initToken], 1, idToken)
       }
     },
-
+    /** @param {WhileStatement | WithStatement} node */
     'WhileStatement, WithStatement'(node) {
       const firstToken = tokenStore.getFirstToken(node)
       const leftParenToken = tokenStore.getTokenAfter(firstToken)
@@ -1855,7 +1904,7 @@ module.exports.defineVisitor = function create(
       setOffset(rightParenToken, 0, leftParenToken)
       processMaybeBlock(node.body, firstToken)
     },
-
+    /** @param {YieldExpression} node */
     YieldExpression(node) {
       if (node.argument != null) {
         const yieldToken = tokenStore.getFirstToken(node)
@@ -1866,7 +1915,7 @@ module.exports.defineVisitor = function create(
         }
       }
     },
-
+    /** @param {Statement} node */
     // Process semicolons.
     ':statement'(node) {
       const firstToken = tokenStore.getFirstToken(node)
@@ -1889,7 +1938,7 @@ module.exports.defineVisitor = function create(
         offsets.set(prevToken, info)
       }
     },
-
+    /** @param {Expression | MetaProperty | TemplateLiteral} node */
     // Process parentheses.
     // `:expression` does not match with MetaProperty and TemplateLiteral as a bug: https://github.com/estools/esquery/pull/59
     ':expression, MetaProperty, TemplateLiteral'(node) {
@@ -1906,14 +1955,14 @@ module.exports.defineVisitor = function create(
         rightToken = tokenStore.getTokenAfter(rightToken)
       }
     },
-
+    /** @param {ASTNode} node */
     // Ignore tokens of unknown nodes.
     '*:exit'(node) {
       if (!KNOWN_NODES.has(node.type)) {
         ignore(node)
       }
     },
-
+    /** @param {Program} node */
     // Top-level process.
     Program(node) {
       const firstToken = node.tokens[0]
@@ -1929,13 +1978,15 @@ module.exports.defineVisitor = function create(
         processTopLevelNode(statement, baseIndent)
       }
     },
+    /** @param {VElement} node */
     "VElement[parent.type!='VElement']"(node) {
       processTopLevelNode(node, 0)
     },
-
+    /** @param {Program | VElement} node */
     // Do validation.
     ":matches(Program, VElement[parent.type!='VElement']):exit"(node) {
       let comments = []
+      /** @type {Token[]} */
       let tokensOnSameLine = []
       let isBesideMultilineToken = false
       let lastValidatedToken = null
@@ -1953,7 +2004,8 @@ module.exports.defineVisitor = function create(
           // Comment lines are adjusted to the next code line.
           comments.push(tokensOnSameLine[0])
           isBesideMultilineToken =
-            last(tokensOnSameLine).loc.end.line === token.loc.start.line
+            /** @type {Token} */ (last(tokensOnSameLine)).loc.end.line ===
+            token.loc.start.line
           tokensOnSameLine = [token]
         } else {
           // New line is detected, so validate the tokens.
@@ -1962,7 +2014,8 @@ module.exports.defineVisitor = function create(
             lastValidatedToken = tokensOnSameLine[0]
           }
           isBesideMultilineToken =
-            last(tokensOnSameLine).loc.end.line === token.loc.start.line
+            /** @type {Token} */ (last(tokensOnSameLine)).loc.end.line ===
+            token.loc.start.line
           tokensOnSameLine = [token]
           comments = []
         }
diff --git a/lib/utils/index.js b/lib/utils/index.js
index 6ff8d6f7e..4e1725efa 100644
--- a/lib/utils/index.js
+++ b/lib/utils/index.js
@@ -6,44 +6,91 @@
 'use strict'
 
 /**
- * @typedef {import('vue-eslint-parser').AST.ESLintArrayExpression} ArrayExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintExpression} Expression
- * @typedef {import('vue-eslint-parser').AST.ESLintIdentifier} Identifier
- * @typedef {import('vue-eslint-parser').AST.ESLintLiteral} Literal
- * @typedef {import('vue-eslint-parser').AST.ESLintMemberExpression} MemberExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintMethodDefinition} MethodDefinition
- * @typedef {import('vue-eslint-parser').AST.ESLintObjectExpression} ObjectExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintProperty} Property
- * @typedef {import('vue-eslint-parser').AST.ESLintTemplateLiteral} TemplateLiteral
- * @typedef {import('vue-eslint-parser').AST.ESLintFunctionExpression} FunctionExpression
- * @typedef {import('vue-eslint-parser').AST.ESLintBlockStatement} BlockStatement
- * @typedef {import('vue-eslint-parser').AST.ESLintNode} ESLintNode
- *
- * @typedef {import('vue-eslint-parser').AST.ESLintArrowFunctionExpression | { type: 'ArrowFunctionExpression', body: BlockStatement | Expression } } ArrowFunctionExpression
- */
-
-/**
- * @typedef {import('eslint').Rule.RuleContext} RuleContext
  * @typedef {import('eslint').Rule.RuleModule} RuleModule
- * @typedef {import('vue-eslint-parser').AST.Token} Token
+ * @typedef {import('estree').Position} Position
+ * @typedef {import('eslint').Rule.CodePath} CodePath
+ * @typedef {import('eslint').Rule.CodePathSegment} CodePathSegment
  */
-
 /**
- * @typedef { {key: Literal | null, value: null, node: ArrayExpression['elements'][0], propName: string} } ComponentArrayProp
- * @typedef { {key: Property['key'], value: Expression, node: Property, propName: string} } ComponentObjectProp
+ * @typedef {object} ComponentArrayPropDetectName
+ * @property {'array'} type
+ * @property {Literal | TemplateLiteral} key
+ * @property {string} propName
+ * @property {null} value
+ * @property {Expression | SpreadElement} node
+ *
+ * @typedef {object} ComponentArrayPropUnknownName
+ * @property {'array'} type
+ * @property {null} key
+ * @property {null} propName
+ * @property {null} value
+ * @property {Expression | SpreadElement} node
+ *
+ * @typedef {ComponentArrayPropDetectName | ComponentArrayPropUnknownName} ComponentArrayProp
+ *
+ * @typedef {object} ComponentObjectPropDetectName
+ * @property {'object'} type
+ * @property {Expression} key
+ * @property {string} propName
+ * @property {Expression} value
+ * @property {Property} node
+ *
+ * @typedef {object} ComponentObjectPropUnknownName
+ * @property {'object'} type
+ * @property {null} key
+ * @property {null} propName
+ * @property {Expression} value
+ * @property {Property} node
+ *
+ * @typedef {ComponentObjectPropDetectName | ComponentObjectPropUnknownName} ComponentObjectProp
  */
 /**
- * @typedef { {key: Literal | null, value: null, node: ArrayExpression['elements'][0], emitName: string} } ComponentArrayEmit
- * @typedef { {key: Property['key'], value: Property['value'], node: Property, emitName: string} } ComponentObjectEmit
+ * @typedef {object} ComponentArrayEmitDetectName
+ * @property {'array'} type
+ * @property {Literal | TemplateLiteral} key
+ * @property {string} emitName
+ * @property {null} value
+ * @property {Expression | SpreadElement} node
+ *
+ * @typedef {object} ComponentArrayEmitUnknownName
+ * @property {'array'} type
+ * @property {null} key
+ * @property {null} emitName
+ * @property {null} value
+ * @property {Expression | SpreadElement} node
+ *
+ * @typedef {ComponentArrayEmitDetectName | ComponentArrayEmitUnknownName} ComponentArrayEmit
+ *
+ * @typedef {object} ComponentObjectEmitDetectName
+ * @property {'object'} type
+ * @property {Expression} key
+ * @property {string} emitName
+ * @property {Expression} value
+ * @property {Property} node
+ *
+ * @typedef {object} ComponentObjectEmitUnknownName
+ * @property {'object'} type
+ * @property {null} key
+ * @property {null} emitName
+ * @property {Expression} value
+ * @property {Property} node
+ *
+ * @typedef {ComponentObjectEmitDetectName | ComponentObjectEmitUnknownName} ComponentObjectEmit
  */
 /**
- * @typedef { {key: string, value: BlockStatement} } ComponentComputedProperty
+ * @typedef { {key: string | null, value: BlockStatement | null} } ComponentComputedProperty
  */
 /**
- * @typedef { { name: string, groupName: string, node: Literal | TemplateLiteral } } ComponentArrayPropertyData
- * @typedef { { name: string, groupName: string, node: Identifier | Literal | TemplateLiteral } } ComponentObjectPropertyData
+ * @typedef { 'props' | 'data' | 'computed' | 'setup' | 'watch' | 'methods' } GroupName
+ * @typedef { { type: 'array',  name: string, groupName: GroupName, node: Literal | TemplateLiteral } } ComponentArrayPropertyData
+ * @typedef { { type: 'object', name: string, groupName: GroupName, node: Identifier | Literal | TemplateLiteral } } ComponentObjectPropertyData
  * @typedef { ComponentArrayPropertyData | ComponentObjectPropertyData } ComponentPropertyData
  */
+/**
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').VueObjectType} VueObjectType
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').VueObjectData} VueObjectData
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').VueVisitor} VueVisitor
+ */
 
 // ------------------------------------------------------------------------------
 // Helpers
@@ -52,7 +99,6 @@
 const HTML_ELEMENT_NAMES = new Set(require('./html-elements.json'))
 const SVG_ELEMENT_NAMES = new Set(require('./svg-elements.json'))
 const VOID_ELEMENT_NAMES = new Set(require('./void-elements.json'))
-const assert = require('assert')
 const path = require('path')
 const vueEslintParser = require('vue-eslint-parser')
 const { findVariable } = require('eslint-utils')
@@ -65,11 +111,13 @@ const componentComments = new WeakMap()
 /**
  * Wrap the rule context object to override methods which access to tokens (such as getTokenAfter).
  * @param {RuleContext} context The rule context object.
- * @param {TokenStore} tokenStore The token store object for template.
+ * @param {ParserServices.TokenStore} tokenStore The token store object for template.
+ * @returns {RuleContext}
  */
 function wrapContextToOverrideTokenMethods(context, tokenStore) {
   const eslintSourceCode = context.getSourceCode()
-  let tokensAndComments
+  /** @type {Token[] | null} */
+  let tokensAndComments = null
   function getTokensAndComments() {
     if (tokensAndComments) {
       return tokensAndComments
@@ -83,15 +131,17 @@ function wrapContextToOverrideTokenMethods(context, tokenStore) {
     return tokensAndComments
   }
   const sourceCode = new Proxy(Object.assign({}, eslintSourceCode), {
-    get(object, key) {
+    get(_object, key) {
       if (key === 'tokensAndComments') {
         return getTokensAndComments()
       }
+      // @ts-expect-error
       return key in tokenStore ? tokenStore[key] : eslintSourceCode[key]
     }
   })
 
   return {
+    // @ts-expect-error
     __proto__: context,
     getSourceCode() {
       return sourceCode
@@ -102,6 +152,7 @@ function wrapContextToOverrideTokenMethods(context, tokenStore) {
 /**
  * Wrap the rule context object to override report method to skip the dynamic argument.
  * @param {RuleContext} context The rule context object.
+ * @returns {RuleContext}
  */
 function wrapContextToOverrideReportMethodToSkipDynamicArgument(context) {
   const sourceCode = context.getSourceCode()
@@ -109,6 +160,7 @@ function wrapContextToOverrideReportMethodToSkipDynamicArgument(context) {
   if (!templateBody) {
     return context
   }
+  /** @type {Range[]} */
   const directiveKeyRanges = []
   const traverseNodes = vueEslintParser.AST.traverseNodes
   traverseNodes(templateBody, {
@@ -125,13 +177,12 @@ function wrapContextToOverrideReportMethodToSkipDynamicArgument(context) {
   })
 
   return {
+    // @ts-expect-error
     __proto__: context,
     report(descriptor, ...args) {
       let range = null
       if (descriptor.loc) {
-        const startLoc = isLoc(descriptor.loc.start)
-          ? descriptor.loc.start
-          : descriptor.loc
+        const startLoc = descriptor.loc.start || descriptor.loc
         const endLoc = descriptor.loc.end || startLoc
         range = [
           sourceCode.getIndexFromLoc(startLoc),
@@ -153,15 +204,6 @@ function wrapContextToOverrideReportMethodToSkipDynamicArgument(context) {
       context.report(descriptor, ...args)
     }
   }
-
-  function isLoc(loc) {
-    return (
-      loc &&
-      typeof loc === 'object' &&
-      typeof loc.line === 'number' &&
-      typeof loc.column === 'number'
-    )
-  }
 }
 
 // ------------------------------------------------------------------------------
@@ -175,9 +217,9 @@ module.exports = {
    * this generates a warning.
    *
    * @param {RuleContext} context The rule context to use parser services.
-   * @param {Object} templateBodyVisitor The visitor to traverse the template body.
-   * @param {Object} [scriptVisitor] The visitor to traverse the script.
-   * @returns {Object} The merged visitor.
+   * @param {TemplateListener} templateBodyVisitor The visitor to traverse the template body.
+   * @param {RuleListener} [scriptVisitor] The visitor to traverse the script.
+   * @returns {RuleListener} The merged visitor.
    */
   defineTemplateBodyVisitor,
 
@@ -188,7 +230,7 @@ module.exports = {
    * @param {string[]} [options.categories] The categories of this rule.
    * @param {boolean} [options.skipDynamicArguments] If `true`, skip validation within dynamic arguments.
    * @param {boolean} [options.skipDynamicArgumentsReport] If `true`, skip report within dynamic arguments.
-   * @param {RuleModule["create"]} [options.create] If define, extend core rule.
+   * @param { (context: RuleContext, options: { coreHandlers: RuleListener }) => TemplateListener } [options.create] If define, extend core rule.
    * @returns {RuleModule} The wrapped rule implementation.
    */
   wrapCoreRule(coreRule, options) {
@@ -218,7 +260,11 @@ module.exports = {
 
         // Move `Program` handlers to `VElement[parent.type!='VElement']`
         const coreHandlers = coreRule.create(context)
-        const handlers = Object.assign({}, coreHandlers)
+
+        const handlers = /** @type {TemplateListener} */ (Object.assign(
+          {},
+          coreHandlers
+        ))
         if (handlers.Program) {
           handlers["VElement[parent.type!='VElement']"] = handlers.Program
           delete handlers.Program
@@ -233,8 +279,10 @@ module.exports = {
           let withinDynamicArguments = false
           for (const name of Object.keys(handlers)) {
             const original = handlers[name]
+            /** @param {any[]} args */
             handlers[name] = (...args) => {
               if (withinDynamicArguments) return
+              // @ts-expect-error
               original(...args)
             }
           }
@@ -268,14 +316,19 @@ module.exports = {
     }
   },
 
+  /**
+   * Checks whether the given value is defined.
+   * @template T
+   * @param {T | null | undefined} v
+   * @returns {v is T}
+   */
+  isDef,
   /**
    * Check whether the given node is the root element or not.
-   * @param {ASTNode} node The element node to check.
+   * @param {VElement} node The element node to check.
    * @returns {boolean} `true` if the node is the root element.
    */
   isRootElement(node) {
-    assert(node && node.type === 'VElement')
-
     return (
       node.parent.type === 'VDocumentFragment' ||
       node.parent.parent.type === 'VDocumentFragment'
@@ -284,11 +337,10 @@ module.exports = {
 
   /**
    * Get the previous sibling element of the given element.
-   * @param {ASTNode} node The element node to get the previous sibling element.
-   * @returns {ASTNode|null} The previous sibling element.
+   * @param {VElement} node The element node to get the previous sibling element.
+   * @returns {VElement|null} The previous sibling element.
    */
   prevSibling(node) {
-    assert(node && node.type === 'VElement')
     let prevElement = null
 
     for (const siblingNode of (node.parent && node.parent.children) || []) {
@@ -305,36 +357,33 @@ module.exports = {
 
   /**
    * Check whether the given start tag has specific directive.
-   * @param {ASTNode} node The start tag node to check.
+   * @param {VElement} node The start tag node to check.
    * @param {string} name The attribute name to check.
    * @param {string} [value] The attribute value to check.
    * @returns {boolean} `true` if the start tag has the attribute.
    */
   hasAttribute(node, name, value) {
-    assert(node && node.type === 'VElement')
     return Boolean(this.getAttribute(node, name, value))
   },
 
   /**
    * Check whether the given start tag has specific directive.
-   * @param {ASTNode} node The start tag node to check.
+   * @param {VElement} node The start tag node to check.
    * @param {string} name The directive name to check.
    * @param {string} [argument] The directive argument to check.
    * @returns {boolean} `true` if the start tag has the directive.
    */
   hasDirective(node, name, argument) {
-    assert(node && node.type === 'VElement')
     return Boolean(this.getDirective(node, name, argument))
   },
 
   /**
    * Check whether the given directive attribute has their empty value (`=""`).
-   * @param {ASTNode} node The directive attribute node to check.
+   * @param {VDirective} node The directive attribute node to check.
    * @param {RuleContext} context The rule context to use parser services.
    * @returns {boolean} `true` if the directive attribute has their empty value (`=""`).
    */
   isEmptyValueDirective(node, context) {
-    assert(node && node.type === 'VAttribute')
     if (node.value == null) {
       return false
     }
@@ -359,12 +408,11 @@ module.exports = {
 
   /**
    * Check whether the given directive attribute has their empty expression value (e.g. `=" "`, `="/* &ast;/"`).
-   * @param {ASTNode} node The directive attribute node to check.
+   * @param {VDirective} node The directive attribute node to check.
    * @param {RuleContext} context The rule context to use parser services.
    * @returns {boolean} `true` if the directive attribute has their empty expression value.
    */
   isEmptyExpressionValueDirective(node, context) {
-    assert(node && node.type === 'VAttribute')
     if (node.value == null) {
       return false
     }
@@ -411,51 +459,96 @@ module.exports = {
 
   /**
    * Get the attribute which has the given name.
-   * @param {ASTNode} node The start tag node to check.
+   * @param {VElement} node The start tag node to check.
    * @param {string} name The attribute name to check.
    * @param {string} [value] The attribute value to check.
-   * @returns {ASTNode} The found attribute.
+   * @returns {VAttribute | null} The found attribute.
    */
   getAttribute(node, name, value) {
-    assert(node && node.type === 'VElement')
-    return node.startTag.attributes.find(
-      (a) =>
-        !a.directive &&
-        a.key.name === name &&
-        (value === undefined || (a.value != null && a.value.value === value))
+    return (
+      node.startTag.attributes.find(
+        /**
+         * @param {VAttribute | VDirective} node
+         * @returns {node is VAttribute}
+         */
+        (node) => {
+          return (
+            !node.directive &&
+            node.key.name === name &&
+            (value === undefined ||
+              (node.value != null && node.value.value === value))
+          )
+        }
+      ) || null
     )
   },
 
+  /**
+   * Get the directive list which has the given name.
+   * @param {VElement | VStartTag} node The start tag node to check.
+   * @param {string} name The directive name to check.
+   * @returns {VDirective[]} The array of `v-slot` directives.
+   */
+  getDirectives(node, name) {
+    const attributes =
+      node.type === 'VElement' ? node.startTag.attributes : node.attributes
+    return attributes.filter(
+      /**
+       * @param {VAttribute | VDirective} node
+       * @returns {node is VDirective}
+       */
+      (node) => {
+        return node.directive && node.key.name.name === name
+      }
+    )
+  },
   /**
    * Get the directive which has the given name.
-   * @param {ASTNode} node The start tag node to check.
+   * @param {VElement} node The start tag node to check.
    * @param {string} name The directive name to check.
    * @param {string} [argument] The directive argument to check.
-   * @returns {ASTNode} The found directive.
+   * @returns {VDirective | null} The found directive.
    */
   getDirective(node, name, argument) {
-    assert(node && node.type === 'VElement')
-    return node.startTag.attributes.find(
-      (a) =>
-        a.directive &&
-        a.key.name.name === name &&
-        (argument === undefined ||
-          (a.key.argument && a.key.argument.name) === argument)
+    return (
+      node.startTag.attributes.find(
+        /**
+         * @param {VAttribute | VDirective} node
+         * @returns {node is VDirective}
+         */
+        (node) => {
+          return (
+            node.directive &&
+            node.key.name.name === name &&
+            (argument === undefined ||
+              (node.key.argument &&
+                node.key.argument.type === 'VIdentifier' &&
+                node.key.argument.name) === argument)
+          )
+        }
+      ) || null
     )
   },
 
   /**
    * Returns the list of all registered components
-   * @param {ASTNode} componentObject
-   * @returns {Array} Array of ASTNodes
+   * @param {ObjectExpression} componentObject
+   * @returns { { node: Property, name: string }[] } Array of ASTNodes
    */
   getRegisteredComponents(componentObject) {
     const componentsNode = componentObject.properties.find(
-      (p) =>
-        p.type === 'Property' &&
-        p.key.type === 'Identifier' &&
-        p.key.name === 'components' &&
-        p.value.type === 'ObjectExpression'
+      /**
+       * @param {ESNode} p
+       * @returns {p is (Property & { key: Identifier & {name: 'components'}, value: ObjectExpression })}
+       */
+      (p) => {
+        return (
+          p.type === 'Property' &&
+          p.key.type === 'Identifier' &&
+          p.key.name === 'components' &&
+          p.value.type === 'ObjectExpression'
+        )
+      }
     )
 
     if (!componentsNode) {
@@ -463,22 +556,20 @@ module.exports = {
     }
 
     return componentsNode.value.properties
-      .filter((p) => p.type === 'Property')
+      .filter(isProperty)
       .map((node) => {
         const name = getStaticPropertyName(node)
         return name ? { node, name } : null
       })
-      .filter((comp) => comp != null)
+      .filter(isDef)
   },
 
   /**
    * Check whether the previous sibling element has `if` or `else-if` directive.
-   * @param {ASTNode} node The element node to check.
+   * @param {VElement} node The element node to check.
    * @returns {boolean} `true` if the previous sibling element has `if` or `else-if` directive.
    */
   prevElementHasIf(node) {
-    assert(node && node.type === 'VElement')
-
     const prev = this.prevSibling(node)
     return (
       prev != null &&
@@ -492,12 +583,10 @@ module.exports = {
 
   /**
    * Check whether the given node is a custom component or not.
-   * @param {ASTNode} node The start tag node to check.
+   * @param {VElement} node The start tag node to check.
    * @returns {boolean} `true` if the node is a custom component.
    */
   isCustomComponent(node) {
-    assert(node && node.type === 'VElement')
-
     return (
       (this.isHtmlElementNode(node) &&
         !this.isHtmlWellKnownElementName(node.rawName)) ||
@@ -508,34 +597,28 @@ module.exports = {
 
   /**
    * Check whether the given node is a HTML element or not.
-   * @param {ASTNode} node The node to check.
+   * @param {VElement} node The node to check.
    * @returns {boolean} `true` if the node is a HTML element.
    */
   isHtmlElementNode(node) {
-    assert(node && node.type === 'VElement')
-
     return node.namespace === vueEslintParser.AST.NS.HTML
   },
 
   /**
    * Check whether the given node is a SVG element or not.
-   * @param {ASTNode} node The node to check.
+   * @param {VElement} node The node to check.
    * @returns {boolean} `true` if the name is a SVG element.
    */
   isSvgElementNode(node) {
-    assert(node && node.type === 'VElement')
-
     return node.namespace === vueEslintParser.AST.NS.SVG
   },
 
   /**
    * Check whether the given name is a MathML element or not.
-   * @param {ASTNode} node The node to check.
+   * @param {VElement} node The node to check.
    * @returns {boolean} `true` if the node is a MathML element.
    */
   isMathMLElementNode(node) {
-    assert(node && node.type === 'VElement')
-
     return node.namespace === vueEslintParser.AST.NS.MathML
   },
 
@@ -545,8 +628,6 @@ module.exports = {
    * @returns {boolean} `true` if the name is an well-known element name.
    */
   isHtmlWellKnownElementName(name) {
-    assert(typeof name === 'string')
-
     return HTML_ELEMENT_NAMES.has(name)
   },
 
@@ -556,7 +637,6 @@ module.exports = {
    * @returns {boolean} `true` if the name is an well-known SVG element name.
    */
   isSvgWellKnownElementName(name) {
-    assert(typeof name === 'string')
     return SVG_ELEMENT_NAMES.has(name)
   },
 
@@ -566,22 +646,20 @@ module.exports = {
    * @returns {boolean} `true` if the name is a void element name.
    */
   isHtmlVoidElementName(name) {
-    assert(typeof name === 'string')
-
     return VOID_ELEMENT_NAMES.has(name)
   },
 
   /**
    * Parse member expression node to get array with all of its parts
-   * @param {ASTNode} node MemberExpression
-   * @returns {Array}
+   * @param {ESNode} node MemberExpression
+   * @returns {string[]}
    */
   parseMemberExpression(node) {
     const members = []
-    let memberExpression
 
     if (node.type === 'MemberExpression') {
-      memberExpression = node
+      /** @type {Expression | Super} */
+      let memberExpression = node
 
       while (memberExpression.type === 'MemberExpression') {
         if (memberExpression.property.type === 'Identifier') {
@@ -602,11 +680,16 @@ module.exports = {
 
   /**
    * Gets the property name of a given node.
-   * @param {Property|MethodDefinition|MemberExpression|Literal|TemplateLiteral|Identifier} node - The node to get.
+   * @param {Property|AssignmentProperty|MethodDefinition|MemberExpression} node - The node to get.
    * @return {string|null} The property name if static. Otherwise, null.
    */
   getStaticPropertyName,
-
+  /**
+   * Gets the string of a given node.
+   * @param {Literal|TemplateLiteral} node - The node to get.
+   * @return {string|null} The string if static. Otherwise, null.
+   */
+  getStringLiteralValue,
   /**
    * Get all props by looking at all component's properties
    * @param {ObjectExpression} componentObject Object with component definition
@@ -614,12 +697,19 @@ module.exports = {
    */
   getComponentProps(componentObject) {
     const propsNode = componentObject.properties.find(
-      (p) =>
-        p.type === 'Property' &&
-        p.key.type === 'Identifier' &&
-        p.key.name === 'props' &&
-        (p.value.type === 'ObjectExpression' ||
-          p.value.type === 'ArrayExpression')
+      /**
+       * @param {ESNode} p
+       * @returns {p is (Property & { key: Identifier & {name: 'props'}, value: ObjectExpression | ArrayExpression })}
+       */
+      (p) => {
+        return (
+          p.type === 'Property' &&
+          p.key.type === 'Identifier' &&
+          p.key.name === 'props' &&
+          (p.value.type === 'ObjectExpression' ||
+            p.value.type === 'ArrayExpression')
+        )
+      }
     )
 
     if (!propsNode) {
@@ -627,29 +717,47 @@ module.exports = {
     }
 
     if (propsNode.value.type === 'ObjectExpression') {
-      return propsNode.value.properties
-        .filter((prop) => prop.type === 'Property')
-        .map((prop) => {
+      return propsNode.value.properties.filter(isProperty).map((prop) => {
+        const propName = getStaticPropertyName(prop)
+        if (propName != null) {
           return {
+            type: 'object',
             key: prop.key,
+            propName,
             value: unwrapTypes(prop.value),
-            node: prop,
-            propName: getStaticPropertyName(prop)
+            node: prop
           }
-        })
+        }
+        return {
+          type: 'object',
+          key: null,
+          propName: null,
+          value: unwrapTypes(prop.value),
+          node: prop
+        }
+      })
     } else {
       return propsNode.value.elements
         .filter((prop) => prop)
         .map((prop) => {
-          const key =
-            prop.type === 'Literal' && typeof prop.value === 'string'
-              ? prop
-              : null
+          if (prop.type === 'Literal' || prop.type === 'TemplateLiteral') {
+            const propName = getStringLiteralValue(prop)
+            if (propName != null) {
+              return {
+                type: 'array',
+                key: prop,
+                propName,
+                value: null,
+                node: prop
+              }
+            }
+          }
           return {
-            key,
+            type: 'array',
+            key: null,
+            propName: null,
             value: null,
-            node: prop,
-            propName: key != null ? prop.value : null
+            node: prop
           }
         })
     }
@@ -662,12 +770,19 @@ module.exports = {
    */
   getComponentEmits(componentObject) {
     const emitsNode = componentObject.properties.find(
-      (p) =>
-        p.type === 'Property' &&
-        p.key.type === 'Identifier' &&
-        p.key.name === 'emits' &&
-        (p.value.type === 'ObjectExpression' ||
-          p.value.type === 'ArrayExpression')
+      /**
+       * @param {ESNode} p
+       * @returns {p is (Property & { key: Identifier & {name: 'emits'}, value: ObjectExpression | ArrayExpression })}
+       */
+      (p) => {
+        return (
+          p.type === 'Property' &&
+          p.key.type === 'Identifier' &&
+          p.key.name === 'emits' &&
+          (p.value.type === 'ObjectExpression' ||
+            p.value.type === 'ArrayExpression')
+        )
+      }
     )
 
     if (!emitsNode) {
@@ -675,29 +790,47 @@ module.exports = {
     }
 
     if (emitsNode.value.type === 'ObjectExpression') {
-      return emitsNode.value.properties
-        .filter((prop) => prop.type === 'Property')
-        .map((prop) => {
+      return emitsNode.value.properties.filter(isProperty).map((prop) => {
+        const emitName = getStaticPropertyName(prop)
+        if (emitName != null) {
           return {
+            type: 'object',
             key: prop.key,
+            emitName,
             value: unwrapTypes(prop.value),
-            node: prop,
-            emitName: getStaticPropertyName(prop)
+            node: prop
           }
-        })
+        }
+        return {
+          type: 'object',
+          key: null,
+          emitName: null,
+          value: unwrapTypes(prop.value),
+          node: prop
+        }
+      })
     } else {
       return emitsNode.value.elements
         .filter((prop) => prop)
         .map((prop) => {
-          const key =
-            prop.type === 'Literal' && typeof prop.value === 'string'
-              ? prop
-              : null
+          if (prop.type === 'Literal' || prop.type === 'TemplateLiteral') {
+            const emitName = getStringLiteralValue(prop)
+            if (emitName != null) {
+              return {
+                type: 'array',
+                key: prop,
+                emitName,
+                value: null,
+                node: prop
+              }
+            }
+          }
           return {
-            key,
+            type: 'array',
+            key: null,
+            emitName: null,
             value: null,
-            node: prop,
-            emitName: key != null ? prop.value : null
+            node: prop
           }
         })
     }
@@ -710,11 +843,18 @@ module.exports = {
    */
   getComputedProperties(componentObject) {
     const computedPropertiesNode = componentObject.properties.find(
-      (p) =>
-        p.type === 'Property' &&
-        p.key.type === 'Identifier' &&
-        p.key.name === 'computed' &&
-        p.value.type === 'ObjectExpression'
+      /**
+       * @param {ESNode} p
+       * @returns {p is (Property & { key: Identifier & {name: 'computed'}, value: ObjectExpression })}
+       */
+      (p) => {
+        return (
+          p.type === 'Property' &&
+          p.key.type === 'Identifier' &&
+          p.key.name === 'computed' &&
+          p.value.type === 'ObjectExpression'
+        )
+      }
     )
 
     if (!computedPropertiesNode) {
@@ -722,19 +862,22 @@ module.exports = {
     }
 
     return computedPropertiesNode.value.properties
-      .filter((cp) => cp.type === 'Property')
+      .filter(isProperty)
       .map((cp) => {
         const key = getStaticPropertyName(cp)
         /** @type {Expression} */
-        const propValue = cp.value
+        const propValue = unwrapTypes(cp.value)
         /** @type {BlockStatement | null} */
         let value = null
 
         if (propValue.type === 'FunctionExpression') {
           value = propValue.body
         } else if (propValue.type === 'ObjectExpression') {
-          /** @type { (Property & { value: FunctionExpression }) | undefined} */
           const get = propValue.properties.find(
+            /**
+             * @param {ESNode} p
+             * @returns { p is (Property & { value: FunctionExpression }) }
+             */
             (p) =>
               p.type === 'Property' &&
               p.key.type === 'Identifier' &&
@@ -753,7 +896,7 @@ module.exports = {
   /**
    * Check if current file is a Vue instance or component and call callback
    * @param {RuleContext} context The ESLint rule context object.
-   * @param {Function} cb Callback function
+   * @param { (node: ObjectExpression, type: VueObjectType) => void } cb Callback function
    */
   executeOnVue(context, cb) {
     return compositingVisitors(
@@ -772,17 +915,24 @@ module.exports = {
    * - `onRenderFunctionEnter` ... Event when render function found.
    *
    * @param {RuleContext} context The ESLint rule context object.
-   * @param {Object} visitor The visitor to traverse the Vue Objects.
+   * @param {VueVisitor} visitor The visitor to traverse the Vue Objects.
    */
   defineVueVisitor(context, visitor) {
+    /** @type {VueObjectData | null} */
     let vueStack = null
 
+    /**
+     * @param {string} key
+     * @param {ESNode} node
+     */
     function callVisitor(key, node) {
       if (visitor[key] && vueStack) {
+        // @ts-expect-error
         visitor[key](node, vueStack)
       }
     }
 
+    /** @type {NodeListener} */
     const vueVisitor = {}
     for (const key in visitor) {
       vueVisitor[key] = (node) => callVisitor(key, node)
@@ -799,8 +949,11 @@ module.exports = {
           type,
           parent: vueStack,
           get functional() {
-            /** @type {Property} */
             const functional = node.properties.find(
+              /**
+               * @param {Property | SpreadElement} p
+               * @returns {p is Property}
+               */
               (p) =>
                 p.type === 'Property' &&
                 getStaticPropertyName(p) === 'functional'
@@ -829,6 +982,7 @@ module.exports = {
       }
     }
     if (visitor.onSetupFunctionEnter || visitor.onRenderFunctionEnter) {
+      /** @param { (FunctionExpression | ArrowFunctionExpression) & { parent: Property } } node */
       vueVisitor[
         'Property[value.type=/^(Arrow)?FunctionExpression$/] > :function'
       ] = (node) => {
@@ -858,10 +1012,11 @@ module.exports = {
   /**
    * Check if current file is a Vue instance (new Vue) and call callback
    * @param {RuleContext} context The ESLint rule context object.
-   * @param {Function} cb Callback function
+   * @param { (node: ObjectExpression, type: VueObjectType) => void } cb Callback function
    */
   executeOnVueInstance(context, cb) {
     return {
+      /** @param {ObjectExpression} node */
       'ObjectExpression:exit'(node) {
         const type = getVueObjectType(context, node)
         if (!type || type !== 'instance') return
@@ -873,10 +1028,11 @@ module.exports = {
   /**
    * Check if current file is a Vue component and call callback
    * @param {RuleContext} context The ESLint rule context object.
-   * @param {Function} cb Callback function
+   * @param { (node: ObjectExpression, type: VueObjectType) => void } cb Callback function
    */
   executeOnVueComponent(context, cb) {
     return {
+      /** @param {ObjectExpression} node */
       'ObjectExpression:exit'(node) {
         const type = getVueObjectType(context, node)
         if (
@@ -892,10 +1048,11 @@ module.exports = {
   /**
    * Check call `Vue.component` and call callback.
    * @param {RuleContext} _context The ESLint rule context object.
-   * @param {Function} cb Callback function
+   * @param { (node: CallExpression) => void } cb Callback function
    */
   executeOnCallVueComponent(_context, cb) {
     return {
+      /** @param {Identifier & { parent: MemberExpression & { parent: CallExpression } } } node */
       "CallExpression > MemberExpression > Identifier[name='component']": (
         node
       ) => {
@@ -920,7 +1077,7 @@ module.exports = {
   /**
    * Return generator with all properties
    * @param {ObjectExpression} node Node to check
-   * @param {Set<string>} groups Name of parent group
+   * @param {Set<GroupName>} groups Name of parent group
    * @returns {IterableIterator<ComponentPropertyData>}
    */
   *iterateProperties(node, groups) {
@@ -928,7 +1085,8 @@ module.exports = {
       if (item.type !== 'Property') {
         continue
       }
-      const name = getStaticPropertyName(item)
+
+      const name = /** @type {GroupName | null} */ (getStaticPropertyName(item))
       if (!name || !groups.has(name)) continue
 
       if (item.value.type === 'ArrayExpression') {
@@ -946,16 +1104,15 @@ module.exports = {
   /**
    * Return generator with all elements inside ArrayExpression
    * @param {ArrayExpression} node Node to check
-   * @param {string} groupName Name of parent group
+   * @param {GroupName} groupName Name of parent group
    * @returns {IterableIterator<ComponentArrayPropertyData>}
    */
   *iterateArrayExpression(node, groupName) {
-    assert(node.type === 'ArrayExpression')
     for (const item of node.elements) {
       if (item.type === 'Literal' || item.type === 'TemplateLiteral') {
-        const name = getStaticPropertyName(item)
+        const name = getStringLiteralValue(item)
         if (name) {
-          yield { name, groupName, node: item }
+          yield { type: 'array', name, groupName, node: item }
         }
       }
     }
@@ -964,12 +1121,12 @@ module.exports = {
   /**
    * Return generator with all elements inside ObjectExpression
    * @param {ObjectExpression} node Node to check
-   * @param {string} groupName Name of parent group
+   * @param {GroupName} groupName Name of parent group
    * @returns {IterableIterator<ComponentObjectPropertyData>}
    */
   *iterateObjectExpression(node, groupName) {
-    assert(node.type === 'ObjectExpression')
-    let usedGetter
+    /** @type {Set<Property> | undefined} */
+    let usedGetter = new Set()
     for (const item of node.properties) {
       if (item.type === 'Property') {
         const key = item.key
@@ -982,16 +1139,15 @@ module.exports = {
           if (name) {
             if (item.kind === 'set') {
               // find getter pair
-              if (!usedGetter) {
-                usedGetter = new Set()
-              }
               if (
                 node.properties.some((item2) => {
-                  if (
-                    item2.type === 'Property' &&
-                    item2.kind === 'get' &&
-                    !usedGetter.has(item2)
-                  ) {
+                  if (item2.type === 'Property' && item2.kind === 'get') {
+                    if (!usedGetter) {
+                      usedGetter = new Set()
+                    }
+                    if (usedGetter.has(item2)) {
+                      return false
+                    }
                     const getterName = getStaticPropertyName(item2)
                     if (getterName === name) {
                       usedGetter.add(item2)
@@ -1005,7 +1161,7 @@ module.exports = {
                 continue
               }
             }
-            yield { name, groupName, node: key }
+            yield { type: 'object', name, groupName, node: key }
           }
         }
       }
@@ -1015,11 +1171,10 @@ module.exports = {
   /**
    * Return generator with all elements inside FunctionExpression
    * @param {FunctionExpression} node Node to check
-   * @param {string} groupName Name of parent group
+   * @param {GroupName} groupName Name of parent group
    * @returns {IterableIterator<ComponentObjectPropertyData>}
    */
   *iterateFunctionExpression(node, groupName) {
-    assert(node.type === 'FunctionExpression')
     if (node.body.type === 'BlockStatement') {
       for (const item of node.body.body) {
         if (
@@ -1036,11 +1191,10 @@ module.exports = {
   /**
    * Return generator with all elements inside ArrowFunctionExpression
    * @param {ArrowFunctionExpression} node Node to check
-   * @param {string} groupName Name of parent group
+   * @param {GroupName} groupName Name of parent group
    * @returns {IterableIterator<ComponentObjectPropertyData>}
    */
   *iterateArrowFunctionExpression(node, groupName) {
-    assert(node.type === 'ArrowFunctionExpression')
     const body = node.body
     if (body.type === 'BlockStatement') {
       for (const item of body.body) {
@@ -1060,29 +1214,41 @@ module.exports = {
   /**
    * Find all functions which do not always return values
    * @param {boolean} treatUndefinedAsUnspecified
-   * @param {Function} cb Callback function
+   * @param { (node: ESNode) => void } cb Callback function
    */
   executeOnFunctionsWithoutReturn(treatUndefinedAsUnspecified, cb) {
-    let funcInfo = {
-      funcInfo: null,
-      codePath: null,
-      hasReturn: false,
-      hasReturnValue: false,
-      node: null
-    }
+    /**
+     * @typedef {object} FuncInfo
+     * @property {FuncInfo} funcInfo
+     * @property {CodePath} codePath
+     * @property {boolean} hasReturn
+     * @property {boolean} hasReturnValue
+     * @property {ESNode} node
+     */
 
+    /** @type {FuncInfo} */
+    let funcInfo
+
+    /** @param {CodePathSegment} segment */
     function isReachable(segment) {
       return segment.reachable
     }
 
     function isValidReturn() {
-      if (funcInfo.codePath.currentSegments.some(isReachable)) {
+      if (
+        funcInfo.codePath &&
+        funcInfo.codePath.currentSegments.some(isReachable)
+      ) {
         return false
       }
       return !treatUndefinedAsUnspecified || funcInfo.hasReturnValue
     }
 
     return {
+      /**
+       * @param {CodePath} codePath
+       * @param {ESNode} node
+       */
       onCodePathStart(codePath, node) {
         funcInfo = {
           codePath,
@@ -1095,16 +1261,18 @@ module.exports = {
       onCodePathEnd() {
         funcInfo = funcInfo.funcInfo
       },
+      /** @param {ReturnStatement} node */
       ReturnStatement(node) {
         funcInfo.hasReturn = true
         funcInfo.hasReturnValue = Boolean(node.argument)
       },
+      /** @param {ArrowFunctionExpression} node */
       'ArrowFunctionExpression:exit'(node) {
         if (!isValidReturn() && !node.expression) {
           cb(funcInfo.node)
         }
       },
-      'FunctionExpression:exit'(node) {
+      'FunctionExpression:exit'() {
         if (!isValidReturn()) {
           cb(funcInfo.node)
         }
@@ -1129,7 +1297,7 @@ module.exports = {
   hasInvalidEOF(node) {
     const body = node.templateBody
     if (body == null || body.errors == null) {
-      return
+      return false
     }
     return body.errors.some(
       (error) => typeof error.code === 'string' && error.code.startsWith('eof-')
@@ -1139,10 +1307,11 @@ module.exports = {
   /**
    * Get the chaining nodes of MemberExpression.
    *
-   * @param  {ESLintNode} node The node to parse
-   * @return {[ESLintNode, ...MemberExpression[]]} The chaining nodes
+   * @param  {ESNode} node The node to parse
+   * @return {[ESNode, ...MemberExpression[]]} The chaining nodes
    */
   getMemberChaining(node) {
+    /** @type {MemberExpression[]} */
     const nodes = []
     let n = node
 
@@ -1150,14 +1319,13 @@ module.exports = {
       nodes.push(n)
       n = n.object
     }
-    nodes.push(n)
 
-    return nodes.reverse()
+    return [n, ...nodes.reverse()]
   },
   /**
    * Parse CallExpression or MemberExpression to get simplified version without arguments
    *
-   * @param  {ASTNode} node The node to parse (MemberExpression | CallExpression)
+   * @param  {ESNode} node The node to parse (MemberExpression | CallExpression)
    * @return {String} eg. 'this.asd.qwe().map().filter().test.reduce()'
    */
   parseMemberOrCallExpression(node) {
@@ -1223,6 +1391,32 @@ module.exports = {
     }
     return dp[alen][blen]
   },
+  /**
+   * Checks whether the given node is Property.
+   */
+  isProperty,
+  /**
+   * Checks whether the given node is AssignmentProperty.
+   */
+  isAssignmentProperty,
+  /**
+   * Checks whether the given node is VElement.
+   */
+  isVElement,
+  /**
+   * Finds the property with the given name from the given ObjectExpression node.
+   */
+  findProperty,
+  /**
+   * Finds the assignment property with the given name from the given ObjectPattern node.
+   */
+  findAssignmentProperty,
+  /**
+   * Checks if the given node is a property value.
+   * @param {Property} prop
+   * @param {Expression} node
+   */
+  isPropertyChain,
   /**
    * Unwrap typescript types like "X as F"
    * @template T
@@ -1230,10 +1424,17 @@ module.exports = {
    * @return {T}
    */
   unwrapTypes,
+  /**
+   * Unwrap AssignmentPattern like "(a = 1) => ret"
+   * @param { AssignmentPattern | RestElement | ArrayPattern | ObjectPattern | Identifier } node
+   * @return { RestElement | ArrayPattern | ObjectPattern | Identifier}
+   */
+  unwrapAssignmentPattern,
 
   /**
    * Check whether the given node is `this` or variable that stores `this`.
-   * @param  {ASTNode} node The node to check
+   * @param  {ESNode} node The node to check
+   * @param {RuleContext} context The rule context to use parser services.
    * @returns {boolean} `true` if the given node is `this`.
    */
   isThis(node, context) {
@@ -1259,11 +1460,11 @@ module.exports = {
     if (variable != null && variable.defs.length === 1) {
       const def = variable.defs[0]
       if (
-        def.parent &&
+        def.type === 'Variable' &&
         def.parent.kind === 'const' &&
         def.node.id.type === 'Identifier'
       ) {
-        return (
+        return Boolean(
           def.node && def.node.init && def.node.init.type === 'ThisExpression'
         )
       }
@@ -1273,7 +1474,7 @@ module.exports = {
 
   /**
    * @param {MemberExpression|Identifier} props
-   * @returns { { kind: 'assignment' | 'update' | 'call' , node: Node, pathNodes: MemberExpression[] } }
+   * @returns { { kind: 'assignment' | 'update' | 'call' , node: ESNode, pathNodes: MemberExpression[] } | null }
    */
   findMutating(props) {
     /** @type {MemberExpression[]} */
@@ -1299,7 +1500,9 @@ module.exports = {
         }
       } else if (target.type === 'CallExpression') {
         if (node !== props && target.callee === node) {
-          const callName = getStaticPropertyName(node)
+          const callName = getStaticPropertyName(
+            /** @type {MemberExpression} */ (node)
+          )
           if (
             callName &&
             /^push|pop|shift|unshift|reverse|splice|sort|copyWithin|fill$/u.exec(
@@ -1329,15 +1532,33 @@ module.exports = {
   }
 }
 
+// ------------------------------------------------------------------------------
+// Standard Helpers
+// ------------------------------------------------------------------------------
+
+/**
+ * Checks whether the given value is defined.
+ * @template T
+ * @param {T | null | undefined} v
+ * @returns {v is T}
+ */
+function isDef(v) {
+  return v != null
+}
+
+// ------------------------------------------------------------------------------
+// Rule Helpers
+// ------------------------------------------------------------------------------
+
 /**
  * Register the given visitor to parser services.
  * If the parser service of `vue-eslint-parser` was not found,
  * this generates a warning.
  *
  * @param {RuleContext} context The rule context to use parser services.
- * @param {Object} templateBodyVisitor The visitor to traverse the template body.
- * @param {Object} [scriptVisitor] The visitor to traverse the script.
- * @returns {Object} The merged visitor.
+ * @param {TemplateListener} templateBodyVisitor The visitor to traverse the template body.
+ * @param {RuleListener} [scriptVisitor] The visitor to traverse the script.
+ * @returns {RuleListener} The merged visitor.
  */
 function defineTemplateBodyVisitor(
   context,
@@ -1358,6 +1579,110 @@ function defineTemplateBodyVisitor(
   )
 }
 
+/**
+ * @param {RuleListener} visitor
+ * @param {...RuleListener} visitors
+ * @returns {RuleListener}
+ */
+function compositingVisitors(visitor, ...visitors) {
+  for (const v of visitors) {
+    for (const key in v) {
+      if (visitor[key]) {
+        const o = visitor[key]
+        /** @param {any[]} args */
+        visitor[key] = (...args) => {
+          // @ts-expect-error
+          o(...args)
+          // @ts-expect-error
+          v[key](...args)
+        }
+      } else {
+        visitor[key] = v[key]
+      }
+    }
+  }
+  return visitor
+}
+
+// ------------------------------------------------------------------------------
+// AST Helpers
+// ------------------------------------------------------------------------------
+
+/**
+ * Finds the property with the given name from the given ObjectExpression node.
+ * @param {ObjectExpression} node
+ * @param {string} name
+ * @param { (p: Property) => boolean } [filter]
+ * @returns { (Property) | null}
+ */
+function findProperty(node, name, filter) {
+  const predicate = filter
+    ? /**
+       * @param {Property | SpreadElement} prop
+       * @returns {prop is Property}
+       */
+      (prop) =>
+        prop.type === 'Property' &&
+        getStaticPropertyName(prop) === name &&
+        filter(prop)
+    : /**
+       * @param {Property | SpreadElement} prop
+       * @returns {prop is Property}
+       */
+      (prop) => prop.type === 'Property' && getStaticPropertyName(prop) === name
+  return node.properties.find(predicate) || null
+}
+
+/**
+ * Finds the assignment property with the given name from the given ObjectPattern node.
+ * @param {ObjectPattern} node
+ * @param {string} name
+ * @param { (p: AssignmentProperty) => boolean } [filter]
+ * @returns { (AssignmentProperty) | null}
+ */
+function findAssignmentProperty(node, name, filter) {
+  const predicate = filter
+    ? /**
+       * @param {AssignmentProperty | RestElement} prop
+       * @returns {prop is AssignmentProperty}
+       */
+      (prop) =>
+        prop.type === 'Property' &&
+        getStaticPropertyName(prop) === name &&
+        filter(prop)
+    : /**
+       * @param {AssignmentProperty | RestElement} prop
+       * @returns {prop is AssignmentProperty}
+       */
+      (prop) => prop.type === 'Property' && getStaticPropertyName(prop) === name
+  return node.properties.find(predicate) || null
+}
+
+/**
+ * Checks whether the given node is Property.
+ * @param {Property | SpreadElement} node
+ * @returns {node is Property}
+ */
+function isProperty(node) {
+  return node.type === 'Property'
+}
+/**
+ * Checks whether the given node is AssignmentProperty.
+ * @param {AssignmentProperty | RestElement} node
+ * @returns {node is AssignmentProperty}
+ */
+function isAssignmentProperty(node) {
+  return node.type === 'Property'
+}
+/**
+ * Checks whether the given node is VElement.
+ * @param {VElement | VExpressionContainer | VText} node
+ * @returns {node is VElement}
+ */
+function isVElement(node) {
+  return node.type === 'VElement'
+}
+
 /**
  * Unwrap typescript types like "X as F"
  * @template T
@@ -1365,55 +1690,126 @@ function defineTemplateBodyVisitor(
  * @return {T}
  */
 function unwrapTypes(node) {
-  return !node
-    ? node
-    : node.type === 'TSAsExpression'
-    ? unwrapTypes(node.expression)
-    : node
+  if (!node) {
+    return node
+  }
+  // @ts-expect-error
+  if (node.type === 'TSAsExpression') {
+    // @ts-expect-error
+    return unwrapTypes(node.expression)
+  }
+  return node
+}
+
+/**
+ * Gets the parent node of the given node. This method returns a value ignoring `X as F`.
+ * @param {Expression} node
+ * @returns {ASTNode}
+ */
+function getParent(node) {
+  let parent = node.parent
+  while (parent.type === 'TSAsExpression') {
+    parent = parent.parent
+  }
+  return parent
+}
+
+/**
+ * Checks if the given node is a property value.
+ * @param {Property} prop
+ * @param {Expression} node
+ */
+function isPropertyChain(prop, node) {
+  let value = node
+  while (value.parent.type === 'TSAsExpression') {
+    value = value.parent
+  }
+  return prop === value.parent && prop.value === value
+}
+
+/**
+ * Unwrap AssignmentPattern like "(a = 1) => ret"
+ * @param { AssignmentPattern | RestElement | ArrayPattern | ObjectPattern | Identifier } node
+ * @return { RestElement | ArrayPattern | ObjectPattern | Identifier}
+ */
+function unwrapAssignmentPattern(node) {
+  if (!node) {
+    return node
+  }
+  if (node.type === 'AssignmentPattern') {
+    // @ts-expect-error
+    return unwrapAssignmentPattern(node.left)
+  }
+  return node
 }
 
 /**
  * Gets the property name of a given node.
- * @param {Property|MethodDefinition|MemberExpression|Literal|TemplateLiteral|Identifier} node - The node to get.
+ * @param {Property|AssignmentProperty|MethodDefinition|MemberExpression} node - The node to get.
  * @return {string|null} The property name if static. Otherwise, null.
  */
 function getStaticPropertyName(node) {
-  let prop
-  switch (node && node.type) {
-    case 'Property':
-    case 'MethodDefinition':
-      prop = node.key
-      break
-    case 'MemberExpression':
-      prop = node.property
-      break
-    case 'Literal':
-    case 'TemplateLiteral':
-    case 'Identifier':
-      prop = node
-      break
-    // no default
-  }
+  if (node.type === 'Property' || node.type === 'MethodDefinition') {
+    const key = node.key
 
-  switch (prop && prop.type) {
-    case 'Literal':
-      return String(prop.value)
-    case 'TemplateLiteral':
-      if (prop.expressions.length === 0 && prop.quasis.length === 1) {
-        return prop.quasis[0].value.cooked
+    if (!node.computed) {
+      if (key.type === 'Identifier') {
+        return key.name
       }
-      break
-    case 'Identifier':
-      if (!node.computed) {
-        return prop.name
+    }
+    // @ts-expect-error
+    return getStringLiteralValue(key)
+  } else if (node.type === 'MemberExpression') {
+    const property = node.property
+    if (!node.computed) {
+      if (property.type === 'Identifier') {
+        return property.name
       }
-      break
-    // no default
+      return null
+    }
+    // @ts-expect-error
+    return getStringLiteralValue(property)
   }
+  return null
+}
 
+/**
+ * Gets the string of a given node.
+ * @param {Literal|TemplateLiteral} node - The node to get.
+ * @param {boolean} [stringOnly]
+ * @return {string|null} The string if static. Otherwise, null.
+ */
+function getStringLiteralValue(node, stringOnly) {
+  if (node.type === 'Literal') {
+    if (node.value == null) {
+      if (!stringOnly && node.bigint != null) {
+        return node.bigint
+      }
+      return null
+    }
+    if (typeof node.value === 'string') {
+      return node.value
+    }
+    if (!stringOnly) {
+      return String(node.value)
+    }
+    return null
+  }
+  if (node.type === 'TemplateLiteral') {
+    if (node.expressions.length === 0 && node.quasis.length === 1) {
+      return node.quasis[0].value.cooked
+    }
+  }
   return null
 }
 
+// ------------------------------------------------------------------------------
+// Vue Helpers
+// ------------------------------------------------------------------------------
+
+/**
+ * @param {string} path
+ */
 function isVueFile(path) {
   return path.endsWith('.vue') || path.endsWith('.jsx')
 }
@@ -1422,7 +1818,7 @@ function isVueFile(path) {
  * Check whether the given node is a Vue component based
  * on the filename and default export type
  * export default {} in .vue || .jsx
- * @param {ASTNode} node Node to check
+ * @param {ESNode} node Node to check
  * @param {string} path File name with extension
  * @returns {boolean}
  */
@@ -1437,7 +1833,7 @@ function isVueComponentFile(node, path) {
 /**
  * Check whether given node is Vue component
  * Vue.component('xxx', {}) || component('xxx', {})
- * @param {ASTNode} node Node to check
+ * @param {ESNode} node Node to check
  * @returns {boolean}
  */
 function isVueComponent(node) {
@@ -1448,23 +1844,26 @@ function isVueComponent(node) {
       const calleeObject = unwrapTypes(callee.object)
 
       if (calleeObject.type === 'Identifier') {
-        const propName = getStaticPropertyName(callee.property)
+        const propName = getStaticPropertyName(callee)
         if (calleeObject.name === 'Vue') {
           // for Vue.js 2.x
           // Vue.component('xxx', {}) || Vue.mixin({}) || Vue.extend('xxx', {})
           const isFullVueComponentForVue2 =
+            propName &&
             ['component', 'mixin', 'extend'].includes(propName) &&
             isObjectArgument(node)
 
-          return isFullVueComponentForVue2
+          return Boolean(isFullVueComponentForVue2)
         }
 
         // for Vue.js 3.x
         // app.component('xxx', {}) || app.mixin({})
         const isFullVueComponent =
-          ['component', 'mixin'].includes(propName) && isObjectArgument(node)
+          propName &&
+          ['component', 'mixin'].includes(propName) &&
+          isObjectArgument(node)
 
-        return isFullVueComponent
+        return Boolean(isFullVueComponent)
       }
     }
 
@@ -1492,6 +1891,7 @@ function isVueComponent(node) {
 
   return false
 
+  /** @param {CallExpression} node */
   function isObjectArgument(node) {
     return (
       node.arguments.length > 0 &&
@@ -1503,17 +1903,17 @@ function isVueComponent(node) {
 /**
  * Check whether given node is new Vue instance
  * new Vue({})
- * @param {ASTNode} node Node to check
+ * @param {NewExpression} node Node to check
  * @returns {boolean}
  */
 function isVueInstance(node) {
   const callee = node.callee
-  return (
+  return Boolean(
     node.type === 'NewExpression' &&
-    callee.type === 'Identifier' &&
-    callee.name === 'Vue' &&
-    node.arguments.length &&
-    unwrapTypes(node.arguments[0]).type === 'ObjectExpression'
+      callee.type === 'Identifier' &&
+      callee.name === 'Vue' &&
+      node.arguments.length &&
+      unwrapTypes(node.arguments[0]).type === 'ObjectExpression'
   )
 }
 
@@ -1521,39 +1921,34 @@ function isVueInstance(node) {
  * If the given object is a Vue component or instance, returns the Vue definition type.
  * @param {RuleContext} context The ESLint rule context object.
  * @param {ObjectExpression} node Node to check
- * @returns { 'mark' | 'export' | 'definition' | 'instance' | null } The Vue definition type.
+ * @returns { VueObjectType | null } The Vue definition type.
  */
 function getVueObjectType(context, node) {
   if (node.type !== 'ObjectExpression') {
     return null
   }
-  let parent = node.parent
-  while (parent && parent.type === 'TSAsExpression') {
-    parent = parent.parent
-  }
-  if (parent) {
-    if (parent.type === 'ExportDefaultDeclaration') {
-      // export default {} in .vue || .jsx
-      const filePath = context.getFilename()
-      if (
-        isVueComponentFile(parent, filePath) &&
-        unwrapTypes(parent.declaration) === node
-      ) {
-        return 'export'
-      }
-    } else if (parent.type === 'CallExpression') {
-      // Vue.component('xxx', {}) || component('xxx', {})
-      if (
-        isVueComponent(parent) &&
-        unwrapTypes(parent.arguments.slice(-1)[0]) === node
-      ) {
-        return 'definition'
-      }
-    } else if (parent.type === 'NewExpression') {
-      // new Vue({})
-      if (isVueInstance(parent) && unwrapTypes(parent.arguments[0]) === node) {
-        return 'instance'
-      }
+  const parent = getParent(node)
+  if (parent.type === 'ExportDefaultDeclaration') {
+    // export default {} in .vue || .jsx
+    const filePath = context.getFilename()
+    if (
+      isVueComponentFile(parent, filePath) &&
+      unwrapTypes(parent.declaration) === node
+    ) {
+      return 'export'
+    }
+  } else if (parent.type === 'CallExpression') {
+    // Vue.component('xxx', {}) || component('xxx', {})
+    if (
+      isVueComponent(parent) &&
+      unwrapTypes(parent.arguments.slice(-1)[0]) === node
+    ) {
+      return 'definition'
+    }
+  } else if (parent.type === 'NewExpression') {
+    // new Vue({})
+    if (isVueInstance(parent) && unwrapTypes(parent.arguments[0]) === node) {
+      return 'instance'
     }
   }
   if (
@@ -1583,20 +1978,3 @@ function getComponentComments(context) {
   componentComments.set(context, tokens)
   return tokens
 }
-
-function compositingVisitors(visitor, ...visitors) {
-  for (const v of visitors) {
-    for (const key in v) {
-      if (visitor[key]) {
-        const o = visitor[key]
-        visitor[key] = (node) => {
-          o(node)
-          v[key](node)
-        }
-      } else {
-        visitor[key] = v[key]
-      }
-    }
-  }
-  return visitor
-}
diff --git a/lib/utils/keycode-to-key.js b/lib/utils/keycode-to-key.js
index 6f20a93b2..365ae435d 100644
--- a/lib/utils/keycode-to-key.js
+++ b/lib/utils/keycode-to-key.js
@@ -1,4 +1,5 @@
 // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
+/** @type { { [key: number]: string }  } */
 module.exports = {
   '8': 'backspace',
   '9': 'tab',
diff --git a/package.json b/package.json
index b734f167d..4291451fd 100644
--- a/package.json
+++ b/package.json
@@ -13,6 +13,8 @@
     "cover:report": "nyc report --reporter=html",
     "lint": "eslint . --rulesdir eslint-internal-rules",
     "lint:fix": "eslint . --rulesdir eslint-internal-rules --fix",
+    "pretsc": "node ./tools/setup-eslint-rule-types.js",
+    "tsc": "tsc",
     "preversion": "npm test && npm run update && git add .",
     "version": "npm run lint -- --fix && git add .",
     "update": "node ./tools/update.js",
@@ -51,12 +53,15 @@
     "eslint": "^6.0.0 || ^7.0.0"
   },
   "dependencies": {
+    "@types/semver": "^7.2.0",
     "eslint-utils": "^2.0.0",
     "natural-compare": "^1.4.0",
     "semver": "^7.3.2",
     "vue-eslint-parser": "^7.1.0"
   },
   "devDependencies": {
+    "@types/eslint": "^6.8.1",
+    "@types/natural-compare": "^1.4.0",
     "@types/node": "^13.13.5",
     "@typescript-eslint/parser": "^2.31.0",
     "@vuepress/plugin-pwa": "^1.4.1",
@@ -74,7 +79,7 @@
     "mocha": "^7.1.2",
     "nyc": "^15.0.1",
     "prettier": "^2.0.5",
-    "typescript": "^3.8.3",
+    "typescript": "^3.9.5",
     "vue-eslint-editor": "^1.1.0",
     "vuepress": "^1.4.1"
   },
diff --git a/tests/lib/rules/attributes-order.js b/tests/lib/rules/attributes-order.js
index 423f720c9..a0b930241 100644
--- a/tests/lib/rules/attributes-order.js
+++ b/tests/lib/rules/attributes-order.js
@@ -20,7 +20,6 @@ const tester = new RuleTester({
   parserOptions: { ecmaVersion: 2015 }
 })
 tester.run('attributes-order', rule, {
-
   valid: [
     {
       filename: 'test.vue',
@@ -88,8 +87,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-      `<template>
+      code: `<template>
         <div
           v-model="toggle"
           :bindingProp="foo"
@@ -108,8 +106,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             is="header"
             v-for="item in items"
@@ -126,8 +123,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             is="header"
             v-for="item in items"
@@ -144,8 +140,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             is="header"
             v-for="item in items"
@@ -162,8 +157,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-for="item in items"
             v-if="!visible"
@@ -177,14 +171,17 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code: '<template><div propone="prop" proptwo="prop" propthree="prop"></div></template>'
+      code:
+        '<template><div propone="prop" proptwo="prop" propthree="prop"></div></template>'
     },
     {
       filename: 'test.vue',
-      code: '<template><div propone="prop" proptwo="prop" is="header"></div></template>',
+      code:
+        '<template><div propone="prop" proptwo="prop" is="header"></div></template>',
       options: [
-        { order:
-          ['LIST_RENDERING',
+        {
+          order: [
+            'LIST_RENDERING',
             'CONDITIONALS',
             'RENDER_MODIFIERS',
             'GLOBAL',
@@ -194,15 +191,19 @@ tester.run('attributes-order', rule, {
             'OTHER_ATTR',
             'EVENTS',
             'CONTENT',
-            'DEFINITION']
-        }]
+            'DEFINITION'
+          ]
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code: '<template><div ref="header" is="header" propone="prop" proptwo="prop"></div></template>',
+      code:
+        '<template><div ref="header" is="header" propone="prop" proptwo="prop"></div></template>',
       options: [
-        { order:
-          ['LIST_RENDERING',
+        {
+          order: [
+            'LIST_RENDERING',
             'CONDITIONALS',
             'RENDER_MODIFIERS',
             'GLOBAL',
@@ -212,13 +213,14 @@ tester.run('attributes-order', rule, {
             'OTHER_DIRECTIVES',
             'OTHER_ATTR',
             'EVENTS',
-            'CONTENT']
-        }]
+            'CONTENT'
+          ]
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-if="!visible"
             v-for="item in items"
@@ -234,8 +236,8 @@ tester.run('attributes-order', rule, {
           </div>
         </template>`,
       options: [
-        { order:
-          [
+        {
+          order: [
             'CONDITIONALS',
             'LIST_RENDERING',
             'RENDER_MODIFIERS',
@@ -248,12 +250,12 @@ tester.run('attributes-order', rule, {
             'OTHER_ATTR',
             'OTHER_DIRECTIVES'
           ]
-        }]
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-if="!visible"
             class="content"
@@ -263,8 +265,8 @@ tester.run('attributes-order', rule, {
           </div>
         </template>`,
       options: [
-        { order:
-          [
+        {
+          order: [
             'CONDITIONALS',
             'LIST_RENDERING',
             'RENDER_MODIFIERS',
@@ -275,12 +277,12 @@ tester.run('attributes-order', rule, {
             'CONTENT',
             'GLOBAL'
           ]
-        }]
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             id="uniqueID"
             ref="header"
@@ -296,8 +298,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             a-custom-prop="value"
             :another-custom-prop="value"
@@ -315,8 +316,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             class="foo"
             :class="bar">
@@ -326,8 +326,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'duplicate.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             class="foo"
             class="bar">
@@ -337,8 +336,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'duplicate.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             :class="foo"
             :class="bar">
@@ -348,8 +346,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-if="foo"
             v-show="bar">
@@ -359,8 +356,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-bar="bar"
             v-foo="foo">
@@ -370,8 +366,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-foo.a="a"
             v-foo.b="b">
@@ -386,24 +381,27 @@ tester.run('attributes-order', rule, {
       filename: 'test.vue',
       code: '<template><div v-cloak is="header"></div></template>',
       output: '<template><div is="header" v-cloak></div></template>',
-      errors: [{
-        message: 'Attribute "is" should go before "v-cloak".',
-        type: 'VIdentifier'
-      }]
+      errors: [
+        {
+          message: 'Attribute "is" should go before "v-cloak".',
+          type: 'VIdentifier'
+        }
+      ]
     },
     {
       filename: 'test.vue',
       code: '<template><div id="uniqueID" v-cloak></div></template>',
       output: '<template><div v-cloak id="uniqueID"></div></template>',
-      errors: [{
-        message: 'Attribute "v-cloak" should go before "id".',
-        type: 'VDirectiveKey'
-      }]
+      errors: [
+        {
+          message: 'Attribute "v-cloak" should go before "id".',
+          type: 'VDirectiveKey'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-          `<template>
+      code: `<template>
             <div
               model="baz"
               v-model="toggle"
@@ -411,8 +409,7 @@ tester.run('attributes-order', rule, {
               :id="foo">
             </div>
           </template>`,
-      output:
-          `<template>
+      output: `<template>
             <div
               v-model="toggle"
               model="baz"
@@ -420,19 +417,20 @@ tester.run('attributes-order', rule, {
               propOne="bar">
             </div>
           </template>`,
-      errors: [{
-        message: 'Attribute "v-model" should go before "model".',
-        type: 'VDirectiveKey'
-      },
-      {
-        message: 'Attribute ":id" should go before "propOne".',
-        type: 'VDirectiveKey'
-      }]
+      errors: [
+        {
+          message: 'Attribute "v-model" should go before "model".',
+          type: 'VDirectiveKey'
+        },
+        {
+          message: 'Attribute ":id" should go before "propOne".',
+          type: 'VDirectiveKey'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-          `<template>
+      code: `<template>
             <div
               :bindingProp="foo"
               model="baz"
@@ -441,8 +439,7 @@ tester.run('attributes-order', rule, {
               propOne="bar">
             </div>
           </template>`,
-      output:
-          `<template>
+      output: `<template>
             <div
               :bindingProp="foo"
               model="baz"
@@ -451,70 +448,82 @@ tester.run('attributes-order', rule, {
               propOne="bar">
             </div>
           </template>`,
-      errors: [{
-        message: 'Attribute "v-model" should go before "v-on".',
-        type: 'VDirectiveKey'
-      },
-      {
-        message: 'Attribute "propOne" should go before "v-on".',
-        type: 'VIdentifier'
-      }]
+      errors: [
+        {
+          message: 'Attribute "v-model" should go before "v-on".',
+          type: 'VDirectiveKey'
+        },
+        {
+          message: 'Attribute "propOne" should go before "v-on".',
+          type: 'VIdentifier'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code: '<template><div data-id="foo" aria-test="bar" is="custom" myProp="prop"></div></template>',
-      output: '<template><div data-id="foo" is="custom" aria-test="bar" myProp="prop"></div></template>',
-      errors: [{
-        message: 'Attribute "is" should go before "aria-test".',
-        type: 'VIdentifier'
-      }]
+      code:
+        '<template><div data-id="foo" aria-test="bar" is="custom" myProp="prop"></div></template>',
+      output:
+        '<template><div data-id="foo" is="custom" aria-test="bar" myProp="prop"></div></template>',
+      errors: [
+        {
+          message: 'Attribute "is" should go before "aria-test".',
+          type: 'VIdentifier'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code: '<template><div ref="header" propone="prop" is="header" ></div></template>',
+      code:
+        '<template><div ref="header" propone="prop" is="header" ></div></template>',
       options: [
-        { order:
-            ['LIST_RENDERING',
-              'CONDITIONALS',
-              'RENDER_MODIFIERS',
-              'GLOBAL',
-              'UNIQUE',
-              'TWO_WAY_BINDING',
-              'DEFINITION',
-              'OTHER_DIRECTIVES',
-              'OTHER_ATTR',
-              'EVENTS',
-              'CONTENT']
-        }],
-      output: '<template><div ref="header" is="header" propone="prop" ></div></template>',
-      errors: [{
-        message: 'Attribute "is" should go before "propone".',
-        type: 'VIdentifier'
-      }]
+        {
+          order: [
+            'LIST_RENDERING',
+            'CONDITIONALS',
+            'RENDER_MODIFIERS',
+            'GLOBAL',
+            'UNIQUE',
+            'TWO_WAY_BINDING',
+            'DEFINITION',
+            'OTHER_DIRECTIVES',
+            'OTHER_ATTR',
+            'EVENTS',
+            'CONTENT'
+          ]
+        }
+      ],
+      output:
+        '<template><div ref="header" is="header" propone="prop" ></div></template>',
+      errors: [
+        {
+          message: 'Attribute "is" should go before "propone".',
+          type: 'VIdentifier'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-          `<template>
+      code: `<template>
             <div v-cloak
               is="header">
             </div>
           </template>`,
-      output:
-          `<template>
+      output: `<template>
             <div is="header"
               v-cloak>
             </div>
           </template>`,
-      errors: [{
-        message: 'Attribute "is" should go before "v-cloak".',
-        type: 'VIdentifier'
-      }]
+      errors: [
+        {
+          message: 'Attribute "is" should go before "v-cloak".',
+          type: 'VIdentifier'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-          `<template>
+      code: `<template>
             <div
               v-if="!visible"
               v-for="item in items"
@@ -529,8 +538,7 @@ tester.run('attributes-order', rule, {
               >
             </div>
           </template>`,
-      output:
-          `<template>
+      output: `<template>
             <div
               v-for="item in items"
               v-if="!visible"
@@ -574,8 +582,7 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-          `<template>
+      code: `<template>
             <div
               v-if="!visible"
               v-for="item in items"
@@ -591,23 +598,23 @@ tester.run('attributes-order', rule, {
             </div>
           </template>`,
       options: [
-        { order:
-            [
-              'EVENTS',
-              'TWO_WAY_BINDING',
-              'UNIQUE',
-              'DEFINITION',
-              'CONDITIONALS',
-              'LIST_RENDERING',
-              'RENDER_MODIFIERS',
-              'GLOBAL',
-              'OTHER_ATTR',
-              'OTHER_DIRECTIVES',
-              'CONTENT'
-            ]
-        }],
-      output:
-          `<template>
+        {
+          order: [
+            'EVENTS',
+            'TWO_WAY_BINDING',
+            'UNIQUE',
+            'DEFINITION',
+            'CONDITIONALS',
+            'LIST_RENDERING',
+            'RENDER_MODIFIERS',
+            'GLOBAL',
+            'OTHER_ATTR',
+            'OTHER_DIRECTIVES',
+            'CONTENT'
+          ]
+        }
+      ],
+      output: `<template>
             <div
               v-if="!visible"
               v-for="item in items"
@@ -646,8 +653,7 @@ tester.run('attributes-order', rule, {
       ]
     },
     {
-      code:
-          `<template>
+      code: `<template>
             <div
               class="content"
               v-if="!visible"
@@ -657,21 +663,21 @@ tester.run('attributes-order', rule, {
             </div>
           </template>`,
       options: [
-        { order:
-            [
-              'CONDITIONALS',
-              'LIST_RENDERING',
-              'RENDER_MODIFIERS',
-              'DEFINITION',
-              'EVENTS',
-              'UNIQUE',
-              ['BINDING', 'OTHER_ATTR'],
-              'CONTENT',
-              'GLOBAL'
-            ]
-        }],
-      output:
-          `<template>
+        {
+          order: [
+            'CONDITIONALS',
+            'LIST_RENDERING',
+            'RENDER_MODIFIERS',
+            'DEFINITION',
+            'EVENTS',
+            'UNIQUE',
+            ['BINDING', 'OTHER_ATTR'],
+            'CONTENT',
+            'GLOBAL'
+          ]
+        }
+      ],
+      output: `<template>
             <div
               v-if="!visible"
               class="content"
@@ -688,8 +694,7 @@ tester.run('attributes-order', rule, {
       ]
     },
     {
-      code:
-          `<template>
+      code: `<template>
             <my-component
               v-if="!visible"
               v-model="content"
@@ -697,8 +702,7 @@ tester.run('attributes-order', rule, {
               >
             </my-component>
           </template>`,
-      output:
-          `<template>
+      output: `<template>
             <my-component
               v-if="!visible"
               v-slot="textContent"
@@ -715,219 +719,219 @@ tester.run('attributes-order', rule, {
     },
     {
       filename: 'test.vue',
-      code:
-      `<template>
+      code: `<template>
           <div
             z-prop="Z"
             a-prop="A">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             a-prop="A"
             z-prop="Z">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "a-prop" should go before "z-prop".',
-        type: 'VIdentifier'
-      }]
+      errors: [
+        {
+          message: 'Attribute "a-prop" should go before "z-prop".',
+          type: 'VIdentifier'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-      `<template>
+      code: `<template>
           <div
             :z-prop="Z"
             :a-prop="A">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             :a-prop="A"
             :z-prop="Z">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute ":a-prop" should go before ":z-prop".',
-        type: 'VDirectiveKey'
-      }]
+      errors: [
+        {
+          message: 'Attribute ":a-prop" should go before ":z-prop".',
+          type: 'VDirectiveKey'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             @input="bar"
             @change="foo">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             @change="foo"
             @input="bar">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "@change" should go before "@input".',
-        type: 'VDirectiveKey'
-      }]
+      errors: [
+        {
+          message: 'Attribute "@change" should go before "@input".',
+          type: 'VDirectiveKey'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             z-prop="value"
             boolean-prop>
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             boolean-prop
             z-prop="value">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "boolean-prop" should go before "z-prop".',
-        type: 'VIdentifier'
-      }]
+      errors: [
+        {
+          message: 'Attribute "boolean-prop" should go before "z-prop".',
+          type: 'VIdentifier'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-on:click="functionCall"
             v-on:[c]="functionCall">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             v-on:[c]="functionCall"
             v-on:click="functionCall">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "v-on:[c]" should go before "v-on:click".',
-        type: 'VDirectiveKey'
-      }]
+      errors: [
+        {
+          message: 'Attribute "v-on:[c]" should go before "v-on:click".',
+          type: 'VDirectiveKey'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-text="textContent"
             v-on:click="functionCall">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             v-on:click="functionCall"
             v-text="textContent">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "v-on:click" should go before "v-text".',
-        type: 'VDirectiveKey'
-      }]
+      errors: [
+        {
+          message: 'Attribute "v-on:click" should go before "v-text".',
+          type: 'VDirectiveKey'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             :class="foo"
             class="bar">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             class="bar"
             :class="foo">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "class" should go before ":class".'
-      }]
+      errors: [
+        {
+          message: 'Attribute "class" should go before ":class".'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-show="foo"
             v-if="bar">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             v-if="bar"
             v-show="foo">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "v-if" should go before "v-show".'
-      }]
+      errors: [
+        {
+          message: 'Attribute "v-if" should go before "v-show".'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-foo="foo"
             v-bar="bar">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             v-bar="bar"
             v-foo="foo">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "v-bar" should go before "v-foo".'
-      }]
+      errors: [
+        {
+          message: 'Attribute "v-bar" should go before "v-foo".'
+        }
+      ]
     },
     {
       filename: 'test.vue',
-      code:
-        `<template>
+      code: `<template>
           <div
             v-foo.b="b"
             v-foo.a="a">
           </div>
         </template>`,
       options: [{ alphabetical: true }],
-      output:
-        `<template>
+      output: `<template>
           <div
             v-foo.a="a"
             v-foo.b="b">
           </div>
         </template>`,
-      errors: [{
-        message: 'Attribute "v-foo.a" should go before "v-foo.b".'
-      }]
+      errors: [
+        {
+          message: 'Attribute "v-foo.a" should go before "v-foo.b".'
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/utils/index.js b/tests/lib/utils/index.js
index 32e074ee8..d1b8c076d 100644
--- a/tests/lib/utils/index.js
+++ b/tests/lib/utils/index.js
@@ -162,22 +162,22 @@ describe('getStaticPropertyName', () => {
     const parsed = utils.getStaticPropertyName(node.properties[0])
     assert.ok(parsed === 'computed')
   })
-  it('should parse identifier', () => {
-    node = parse(`const test = { computed: { } }`)
+  // it('should parse identifier', () => {
+  //   node = parse(`const test = { computed: { } }`)
 
-    const parsed = utils.getStaticPropertyName(node.properties[0].key)
-    assert.ok(parsed === 'computed')
-  })
+  //   const parsed = utils.getStaticPropertyName(node.properties[0].key)
+  //   assert.ok(parsed === 'computed')
+  // })
   it('should parse literal', () => {
     node = parse(`const test = { ['computed'] () {} }`)
 
-    const parsed = utils.getStaticPropertyName(node.properties[0].key)
+    const parsed = utils.getStringLiteralValue(node.properties[0].key)
     assert.ok(parsed === 'computed')
   })
   it('should parse template literal', () => {
     node = parse(`const test = { [\`computed\`] () {} }`)
 
-    const parsed = utils.getStaticPropertyName(node.properties[0].key)
+    const parsed = utils.getStringLiteralValue(node.properties[0].key)
     assert.ok(parsed === 'computed')
   })
 })
@@ -360,7 +360,7 @@ describe('getComponentProps', () => {
     assert.notOk(props[1].value)
 
     assert.ok(props[2].node.type === 'TemplateLiteral')
-    assert.notOk(props[2].key)
+    assert.deepEqual(props[2].key, props[2].node)
     assert.notOk(props[2].value)
 
     assert.ok(props[3].node.type === 'Literal')
diff --git a/tools/setup-eslint-rule-types.js b/tools/setup-eslint-rule-types.js
new file mode 100644
index 000000000..d836d025c
--- /dev/null
+++ b/tools/setup-eslint-rule-types.js
@@ -0,0 +1,52 @@
+/**
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const eslint = require('eslint')
+const ruleNames = new Set(new eslint.Linter().getRules().keys())
+
+const TYPINGS_ESLINT_RULES_ROOT = path.resolve(
+  __dirname,
+  '../typings/eslint/lib/rules'
+)
+
+mkdirIfNotExists(TYPINGS_ESLINT_RULES_ROOT)
+
+for (const ruleName of ruleNames) {
+  const filePath = path.join(TYPINGS_ESLINT_RULES_ROOT, `${ruleName}.d.ts`)
+  fs.writeFileSync(
+    filePath,
+    `import { Rule } from '../../index'
+declare const rule: Rule.RuleModule
+export = rule
+`
+  )
+}
+
+fs.readdirSync(TYPINGS_ESLINT_RULES_ROOT)
+  .filter((file) => file.endsWith('.d.ts'))
+  .filter((file) => !ruleNames.has(file.slice(0, -5)))
+  .map((file) => path.join(TYPINGS_ESLINT_RULES_ROOT, file))
+  .forEach((filePath) => fs.unlinkSync(filePath))
+
+function exists(file) {
+  try {
+    fs.statSync(file)
+    return true
+  } catch (err) {
+    if (err.code === 'ENOENT') return false
+  }
+}
+
+function mkdirIfNotExists(dir) {
+  if (exists(dir)) {
+    return
+  }
+  const p = path.dirname(dir)
+  mkdirIfNotExists(p)
+  fs.mkdirSync(dir)
+}
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 000000000..40f2ceeee
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["es2020"],
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "*": ["typings/*"]
+    }
+  },
+  "include": ["lib/**/*", "typings/eslint-plugin-vue/global.d.ts"]
+}
diff --git a/typings/eslint-plugin-vue/global.d.ts b/typings/eslint-plugin-vue/global.d.ts
new file mode 100644
index 000000000..268cbbb18
--- /dev/null
+++ b/typings/eslint-plugin-vue/global.d.ts
@@ -0,0 +1,175 @@
+import * as VAST from './util-types/ast'
+import * as VNODE from './util-types/node'
+import * as parserServices from './util-types/parser-services'
+import * as eslint from 'eslint'
+
+declare global {
+  // **** Rule Helpers ****
+  type RuleModule = eslint.Rule.RuleModule
+  type RuleContext = eslint.Rule.RuleContext
+  namespace Rule {
+    type ReportDescriptor = eslint.Rule.ReportDescriptor
+    type SuggestionReportDescriptor = eslint.Rule.SuggestionReportDescriptor
+  }
+  type SourceCode = eslint.SourceCode
+  namespace SourceCode {
+    type CursorWithSkipOptions = eslint.SourceCode.CursorWithSkipOptions
+    type CursorWithCountOptions = eslint.SourceCode.CursorWithCountOptions
+  }
+  type RuleFixer = eslint.Rule.RuleFixer
+  type Fix = eslint.Rule.Fix
+
+  type NodeListener = eslint.Rule.NodeListener
+  type RuleListener = eslint.Rule.RuleListener
+  type TemplateListener = parserServices.TemplateListener
+  type ParserServices = parserServices.ParserServices
+  namespace ParserServices {
+    type TokenStore = parserServices.ParserServices.TokenStore
+  }
+
+  // **** Node data ****
+
+  type Range = VNODE.Range
+  type Position = VNODE.Position
+  type SourceLocation = VNODE.SourceLocation
+  type Token = VNODE.Token
+  type Comment = VNODE.Comment
+  type HTMLComment = VNODE.HTMLComment
+  type HTMLBogusComment = VNODE.HTMLBogusComment
+
+  type NodeListenerMap = VAST.NodeListenerMap
+  type VNodeListenerMap = VAST.VNodeListenerMap
+
+  // **** AST nodes ****
+
+  type ASTNode = VAST.ASTNode
+  type ESNode = VAST.ESNode
+  type VNode = VAST.VNode
+  type TSNode = VAST.TSNode
+  type JSXNode = VAST.JSXNode
+
+  // ---- Vue Template Nodes ----
+
+  type VAttribute = VAST.VAttribute
+  type VDirective = VAST.VDirective
+  type VDirectiveKey = VAST.VDirectiveKey
+  type VDocumentFragment = VAST.VDocumentFragment
+  type VElement = VAST.VElement
+  type VRootElement = VAST.VRootElement
+  type VEndTag = VAST.VEndTag
+  type VExpressionContainer = VAST.VExpressionContainer
+  type VIdentifier = VAST.VIdentifier
+  type VLiteral = VAST.VLiteral
+  type VStartTag = VAST.VStartTag
+  type VText = VAST.VText
+  type VForExpression = VAST.VForExpression
+  type VOnExpression = VAST.VOnExpression
+  type VSlotScopeExpression = VAST.VSlotScopeExpression
+  type VFilterSequenceExpression = VAST.VFilterSequenceExpression
+  type VFilter = VAST.VFilter
+
+  // ---- ES Nodes ----
+
+  type Identifier = VAST.Identifier
+  type Literal = VAST.Literal
+  type Program = VAST.Program
+  type SwitchCase = VAST.SwitchCase
+  type CatchClause = VAST.CatchClause
+  type VariableDeclarator = VAST.VariableDeclarator
+  type Statement = VAST.Statement
+  type ExpressionStatement = VAST.ExpressionStatement
+  type BlockStatement = VAST.BlockStatement
+  type EmptyStatement = VAST.EmptyStatement
+  type DebuggerStatement = VAST.DebuggerStatement
+  type WithStatement = VAST.WithStatement
+  type ReturnStatement = VAST.ReturnStatement
+  type LabeledStatement = VAST.LabeledStatement
+  type BreakStatement = VAST.BreakStatement
+  type ContinueStatement = VAST.ContinueStatement
+  type IfStatement = VAST.IfStatement
+  type SwitchStatement = VAST.SwitchStatement
+  type ThrowStatement = VAST.ThrowStatement
+  type TryStatement = VAST.TryStatement
+  type WhileStatement = VAST.WhileStatement
+  type DoWhileStatement = VAST.DoWhileStatement
+  type ForStatement = VAST.ForStatement
+  type ForInStatement = VAST.ForInStatement
+  type ForOfStatement = VAST.ForOfStatement
+  type Declaration = VAST.Declaration
+  type FunctionDeclaration = VAST.FunctionDeclaration
+  type VariableDeclaration = VAST.VariableDeclaration
+  type ClassDeclaration = VAST.ClassDeclaration
+  type Expression = VAST.Expression
+  type ThisExpression = VAST.ThisExpression
+  type ArrayExpression = VAST.ArrayExpression
+  type ObjectExpression = VAST.ObjectExpression
+  type FunctionExpression = VAST.FunctionExpression
+  type ArrowFunctionExpression = VAST.ArrowFunctionExpression
+  type YieldExpression = VAST.YieldExpression
+  type UnaryExpression = VAST.UnaryExpression
+  type UpdateExpression = VAST.UpdateExpression
+  type BinaryExpression = VAST.BinaryExpression
+  type AssignmentExpression = VAST.AssignmentExpression
+  type LogicalExpression = VAST.LogicalExpression
+  type MemberExpression = VAST.MemberExpression
+  type ConditionalExpression = VAST.ConditionalExpression
+  type CallExpression = VAST.CallExpression
+  type NewExpression = VAST.NewExpression
+  type SequenceExpression = VAST.SequenceExpression
+  type TemplateLiteral = VAST.TemplateLiteral
+  type TaggedTemplateExpression = VAST.TaggedTemplateExpression
+  type ClassExpression = VAST.ClassExpression
+  type MetaProperty = VAST.MetaProperty
+  type AwaitExpression = VAST.AwaitExpression
+  type Property = VAST.Property
+  type AssignmentProperty = VAST.AssignmentProperty
+  type Super = VAST.Super
+  type TemplateElement = VAST.TemplateElement
+  type SpreadElement = VAST.SpreadElement
+  type Pattern = VAST.Pattern
+  type ObjectPattern = VAST.ObjectPattern
+  type ArrayPattern = VAST.ArrayPattern
+  type RestElement = VAST.RestElement
+  type AssignmentPattern = VAST.AssignmentPattern
+  type ClassBody = VAST.ClassBody
+  type MethodDefinition = VAST.MethodDefinition
+  type ModuleDeclaration = VAST.ModuleDeclaration
+  type ImportDeclaration = VAST.ImportDeclaration
+  type ExportNamedDeclaration = VAST.ExportNamedDeclaration
+  type ExportDefaultDeclaration = VAST.ExportDefaultDeclaration
+  type ExportAllDeclaration = VAST.ExportAllDeclaration
+  type ModuleSpecifier = VAST.ModuleSpecifier
+  type ImportSpecifier = VAST.ImportSpecifier
+  type ImportDefaultSpecifier = VAST.ImportDefaultSpecifier
+  type ImportNamespaceSpecifier = VAST.ImportNamespaceSpecifier
+  type ExportSpecifier = VAST.ExportSpecifier
+
+  // ---- TS Nodes ----
+
+  type TSAsExpression = VAST.TSAsExpression
+
+  // ---- JSX Nodes ----
+
+  type JSXAttribute = VAST.JSXAttribute
+  type JSXClosingElement = VAST.JSXClosingElement
+  type JSXClosingFragment = VAST.JSXClosingFragment
+  type JSXElement = VAST.JSXElement
+  type JSXEmptyExpression = VAST.JSXEmptyExpression
+  type JSXExpressionContainer = VAST.JSXExpressionContainer
+  type JSXFragment = VAST.JSXFragment
+  type JSXIdentifier = VAST.JSXIdentifier
+  type JSXOpeningElement = VAST.JSXOpeningElement
+  type JSXOpeningFragment = VAST.JSXOpeningFragment
+  type JSXSpreadAttribute = VAST.JSXSpreadAttribute
+  type JSXSpreadChild = VAST.JSXSpreadChild
+  type JSXMemberExpression = VAST.JSXMemberExpression
+  type JSXText = VAST.JSXText
+
+  // **** Variables ****
+
+  type VVariable = VAST.VVariable
+  type VReference = VAST.VReference
+
+  type Variable = eslint.Scope.Variable
+  type Reference = eslint.Scope.Reference
+}
diff --git a/typings/eslint-plugin-vue/util-types/ast/ast.ts b/typings/eslint-plugin-vue/util-types/ast/ast.ts
new file mode 100644
index 000000000..dc55396eb
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/ast/ast.ts
@@ -0,0 +1,265 @@
+import * as ES from './es-ast'
+import * as V from './v-ast'
+import * as TS from './ts-ast'
+import * as JSX from './jsx-ast'
+
+export type ASTNode = ES.ESNode | V.VNode | TS.TSNode | JSX.JSXNode
+
+export type ParamNode = never // You specify the node type in JSDoc.
+
+export type VNodeListenerMap = {
+  VAttribute: V.VAttribute | V.VDirective
+  'VAttribute:exit': V.VAttribute | V.VDirective
+  'VAttribute[directive=false]': V.VAttribute
+  'VAttribute[directive=false]:exit': V.VAttribute
+  "VAttribute[directive=true][key.name.name='bind']": V.VDirective
+  "VAttribute[directive=true][key.name.name='bind']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='cloak']": V.VDirective
+  "VAttribute[directive=true][key.name.name='cloak']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='else-if']": V.VDirective
+  "VAttribute[directive=true][key.name.name='else-if']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='else']": V.VDirective
+  "VAttribute[directive=true][key.name.name='else']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='for']": V.VDirective
+  "VAttribute[directive=true][key.name.name='for']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='html']": V.VDirective
+  "VAttribute[directive=true][key.name.name='html']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='if']": V.VDirective
+  "VAttribute[directive=true][key.name.name='if']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='model']": V.VDirective
+  "VAttribute[directive=true][key.name.name='model']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='on']": V.VDirective
+  "VAttribute[directive=true][key.name.name='on']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='once']": V.VDirective
+  "VAttribute[directive=true][key.name.name='once']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='pre']": V.VDirective
+  "VAttribute[directive=true][key.name.name='pre']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='show']": V.VDirective
+  "VAttribute[directive=true][key.name.name='show']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='slot']": V.VDirective
+  "VAttribute[directive=true][key.name.name='slot']:exit": V.VDirective
+  "VAttribute[directive=true][key.name.name='text']": V.VDirective
+  "VAttribute[directive=true][key.name.name='text']:exit": V.VDirective
+  'VAttribute[value!=null]':
+    | (V.VAttribute & { value: VLiteral })
+    | (V.VDirective & { value: VExpressionContainer })
+  // VDirective: V.VDirective
+  // 'VDirective:exit': V.VDirective
+  VDirectiveKey: V.VDirectiveKey
+  'VDirectiveKey:exit': V.VDirectiveKey
+  VElement: V.VElement
+  'VElement:exit': V.VElement
+  VEndTag: V.VEndTag
+  'VEndTag:exit': V.VEndTag
+  VExpressionContainer: V.VExpressionContainer
+  'VExpressionContainer:exit': V.VExpressionContainer
+  VIdentifier: V.VIdentifier
+  'VIdentifier:exit': V.VIdentifier
+  VLiteral: V.VLiteral
+  'VLiteral:exit': V.VLiteral
+  VStartTag: V.VStartTag
+  'VStartTag:exit': V.VStartTag
+  VText: V.VText
+  'VText:exit': V.VText
+  VForExpression: V.VForExpression
+  'VForExpression:exit': V.VForExpression
+  VOnExpression: V.VOnExpression
+  'VOnExpression:exit': V.VOnExpression
+  VSlotScopeExpression: V.VSlotScopeExpression
+  'VSlotScopeExpression:exit': V.VSlotScopeExpression
+  VFilterSequenceExpression: V.VFilterSequenceExpression
+  'VFilterSequenceExpression:exit': V.VFilterSequenceExpression
+  VFilter: V.VFilter
+  'VFilter:exit': V.VFilter
+} & ESNodeListenerMap
+export type NodeListenerMap = {
+  JSXAttribute: JSX.JSXAttribute
+  'JSXAttribute:exit': JSX.JSXAttribute
+  JSXClosingElement: JSX.JSXClosingElement
+  'JSXClosingElement:exit': JSX.JSXClosingElement
+  JSXClosingFragment: JSX.JSXClosingFragment
+  'JSXClosingFragment:exit': JSX.JSXClosingFragment
+  JSXElement: JSX.JSXElement
+  'JSXElement:exit': JSX.JSXElement
+  JSXEmptyExpression: JSX.JSXEmptyExpression
+  'JSXEmptyExpression:exit': JSX.JSXEmptyExpression
+  JSXExpressionContainer: JSX.JSXExpressionContainer
+  'JSXExpressionContainer:exit': JSX.JSXExpressionContainer
+  JSXFragment: JSX.JSXFragment
+  'JSXFragment:exit': JSX.JSXFragment
+  JSXIdentifier: JSX.JSXIdentifier
+  'JSXIdentifier:exit': JSX.JSXIdentifier
+  JSXOpeningElement: JSX.JSXOpeningElement
+  'JSXOpeningElement:exit': JSX.JSXOpeningElement
+  JSXOpeningFragment: JSX.JSXOpeningFragment
+  'JSXOpeningFragment:exit': JSX.JSXOpeningFragment
+  JSXSpreadAttribute: JSX.JSXSpreadAttribute
+  'JSXSpreadAttribute:exit': JSX.JSXSpreadAttribute
+  JSXSpreadChild: JSX.JSXSpreadChild
+  'JSXSpreadChild:exit': JSX.JSXSpreadChild
+  JSXMemberExpression: JSX.JSXMemberExpression
+  'JSXMemberExpression:exit': JSX.JSXMemberExpression
+  JSXText: JSX.JSXText
+  'JSXText:exit': JSX.JSXText
+} & ESNodeListenerMap
+export type ESNodeListenerMap = {
+  Identifier: ES.Identifier
+  'Identifier:exit': ES.Identifier
+  Literal: ES.Literal
+  'Literal:exit': ES.Literal
+  Program: ES.Program
+  'Program:exit': ES.Program
+  SwitchCase: ES.SwitchCase
+  'SwitchCase:exit': ES.SwitchCase
+  CatchClause: ES.CatchClause
+  'CatchClause:exit': ES.CatchClause
+  VariableDeclarator: ES.VariableDeclarator
+  'VariableDeclarator:exit': ES.VariableDeclarator
+  ':statement': ES.Statement
+  ':statement:exit': ES.Statement
+  ExpressionStatement: ES.ExpressionStatement
+  'ExpressionStatement:exit': ES.ExpressionStatement
+  BlockStatement: ES.BlockStatement
+  'BlockStatement:exit': ES.BlockStatement
+  EmptyStatement: ES.EmptyStatement
+  'EmptyStatement:exit': ES.EmptyStatement
+  DebuggerStatement: ES.DebuggerStatement
+  'DebuggerStatement:exit': ES.DebuggerStatement
+  WithStatement: ES.WithStatement
+  'WithStatement:exit': ES.WithStatement
+  ReturnStatement: ES.ReturnStatement
+  'ReturnStatement:exit': ES.ReturnStatement
+  LabeledStatement: ES.LabeledStatement
+  'LabeledStatement:exit': ES.LabeledStatement
+  BreakStatement: ES.BreakStatement
+  'BreakStatement:exit': ES.BreakStatement
+  ContinueStatement: ES.ContinueStatement
+  'ContinueStatement:exit': ES.ContinueStatement
+  IfStatement: ES.IfStatement
+  'IfStatement:exit': ES.IfStatement
+  SwitchStatement: ES.SwitchStatement
+  'SwitchStatement:exit': ES.SwitchStatement
+  ThrowStatement: ES.ThrowStatement
+  'ThrowStatement:exit': ES.ThrowStatement
+  TryStatement: ES.TryStatement
+  'TryStatement:exit': ES.TryStatement
+  WhileStatement: ES.WhileStatement
+  'WhileStatement:exit': ES.WhileStatement
+  DoWhileStatement: ES.DoWhileStatement
+  'DoWhileStatement:exit': ES.DoWhileStatement
+  ForStatement: ES.ForStatement
+  'ForStatement:exit': ES.ForStatement
+  ForInStatement: ES.ForInStatement
+  'ForInStatement:exit': ES.ForInStatement
+  ForOfStatement: ES.ForOfStatement
+  'ForOfStatement:exit': ES.ForOfStatement
+  ':declaration': ES.Declaration
+  ':declaration:exit': ES.Declaration
+  FunctionDeclaration: ES.FunctionDeclaration
+  'FunctionDeclaration:exit': ES.FunctionDeclaration
+  VariableDeclaration: ES.VariableDeclaration
+  'VariableDeclaration:exit': ES.VariableDeclaration
+  ClassDeclaration: ES.ClassDeclaration
+  'ClassDeclaration:exit': ES.ClassDeclaration
+  ':expression': ES.Expression
+  ':expression:exit': ES.Expression
+  ThisExpression: ES.ThisExpression
+  'ThisExpression:exit': ES.ThisExpression
+  ArrayExpression: ES.ArrayExpression
+  'ArrayExpression:exit': ES.ArrayExpression
+  ObjectExpression: ES.ObjectExpression
+  'ObjectExpression:exit': ES.ObjectExpression
+  ':function':
+    | ES.FunctionExpression
+    | ES.ArrowFunctionExpression
+    | ES.FunctionDeclaration
+  ':function:exit':
+    | ES.FunctionExpression
+    | ES.ArrowFunctionExpression
+    | ES.FunctionDeclaration
+  FunctionExpression: ES.FunctionExpression
+  'FunctionExpression:exit': ES.FunctionExpression
+  ArrowFunctionExpression: ES.ArrowFunctionExpression
+  'ArrowFunctionExpression:exit': ES.ArrowFunctionExpression
+  YieldExpression: ES.YieldExpression
+  'YieldExpression:exit': ES.YieldExpression
+  UnaryExpression: ES.UnaryExpression
+  'UnaryExpression:exit': ES.UnaryExpression
+  UpdateExpression: ES.UpdateExpression
+  'UpdateExpression:exit': ES.UpdateExpression
+  BinaryExpression: ES.BinaryExpression
+  'BinaryExpression:exit': ES.BinaryExpression
+  AssignmentExpression: ES.AssignmentExpression
+  'AssignmentExpression:exit': ES.AssignmentExpression
+  LogicalExpression: ES.LogicalExpression
+  'LogicalExpression:exit': ES.LogicalExpression
+  MemberExpression: ES.MemberExpression
+  'MemberExpression:exit': ES.MemberExpression
+  ConditionalExpression: ES.ConditionalExpression
+  'ConditionalExpression:exit': ES.ConditionalExpression
+  CallExpression: ES.CallExpression
+  'CallExpression:exit': ES.CallExpression
+  NewExpression: ES.NewExpression
+  'NewExpression:exit': ES.NewExpression
+  SequenceExpression: ES.SequenceExpression
+  'SequenceExpression:exit': ES.SequenceExpression
+  TemplateLiteral: ES.TemplateLiteral
+  'TemplateLiteral:exit': ES.TemplateLiteral
+  TaggedTemplateExpression: ES.TaggedTemplateExpression
+  'TaggedTemplateExpression:exit': ES.TaggedTemplateExpression
+  ClassExpression: ES.ClassExpression
+  'ClassExpression:exit': ES.ClassExpression
+  MetaProperty: ES.MetaProperty
+  'MetaProperty:exit': ES.MetaProperty
+  AwaitExpression: ES.AwaitExpression
+  'AwaitExpression:exit': ES.AwaitExpression
+  Property: ES.Property | ES.AssignmentProperty
+  'Property:exit': ES.Property | ES.AssignmentProperty
+  'ObjectExpression>Property': ES.Property
+  'ObjectExpression>Property:exit': ES.Property
+  'ObjectExpression > Property': ES.Property
+  'ObjectExpression > Property:exit': ES.Property
+  'ObjectPattern>Property': ES.AssignmentProperty
+  'ObjectPattern>Property:exit': ES.AssignmentProperty
+  'ObjectPattern > Property': ES.AssignmentProperty
+  'ObjectPattern > Property:exit': ES.AssignmentProperty
+  Super: ES.Super
+  'Super:exit': ES.Super
+  TemplateElement: ES.TemplateElement
+  'TemplateElement:exit': ES.TemplateElement
+  SpreadElement: ES.SpreadElement
+  'SpreadElement:exit': ES.SpreadElement
+  ':pattern': ES.Pattern
+  ':pattern:exit': ES.Pattern
+  ObjectPattern: ES.ObjectPattern
+  'ObjectPattern:exit': ES.ObjectPattern
+  ArrayPattern: ES.ArrayPattern
+  'ArrayPattern:exit': ES.ArrayPattern
+  RestElement: ES.RestElement
+  'RestElement:exit': ES.RestElement
+  AssignmentPattern: ES.AssignmentPattern
+  'AssignmentPattern:exit': ES.AssignmentPattern
+  ClassBody: ES.ClassBody
+  'ClassBody:exit': ES.ClassBody
+  MethodDefinition: ES.MethodDefinition
+  'MethodDefinition:exit': ES.MethodDefinition
+  ImportDeclaration: ES.ImportDeclaration
+  'ImportDeclaration:exit': ES.ImportDeclaration
+  ExportNamedDeclaration: ES.ExportNamedDeclaration
+  'ExportNamedDeclaration:exit': ES.ExportNamedDeclaration
+  ExportDefaultDeclaration: ES.ExportDefaultDeclaration
+  'ExportDefaultDeclaration:exit': ES.ExportDefaultDeclaration
+  ExportAllDeclaration: ES.ExportAllDeclaration
+  'ExportAllDeclaration:exit': ES.ExportAllDeclaration
+  ImportSpecifier: ES.ImportSpecifier
+  'ImportSpecifier:exit': ES.ImportSpecifier
+  ImportDefaultSpecifier: ES.ImportDefaultSpecifier
+  'ImportDefaultSpecifier:exit': ES.ImportDefaultSpecifier
+  ImportNamespaceSpecifier: ES.ImportNamespaceSpecifier
+  'ImportNamespaceSpecifier:exit': ES.ImportNamespaceSpecifier
+  ExportSpecifier: ES.ExportSpecifier
+  'ExportSpecifier:exit': ES.ExportSpecifier
+
+  TSAsExpression: TS.TSAsExpression
+  'TSAsExpression:exit': TS.TSAsExpression
+}
diff --git a/typings/eslint-plugin-vue/util-types/ast/es-ast.ts b/typings/eslint-plugin-vue/util-types/ast/es-ast.ts
new file mode 100644
index 000000000..efc81f169
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/ast/es-ast.ts
@@ -0,0 +1,519 @@
+/**
+ * @see https://github.com/estree/estree
+ */
+import { BaseNode, HasParentNode } from '../node'
+import { Token } from '../node'
+import { ParseError } from '../errors'
+import * as V from './v-ast'
+import * as TS from './ts-ast'
+import * as JSX from './jsx-ast'
+
+export type ESNode =
+  | Identifier
+  | Literal
+  | Program
+  | SwitchCase
+  | CatchClause
+  | VariableDeclarator
+  | Statement
+  | Expression
+  | Property
+  | AssignmentProperty
+  | Super
+  | TemplateElement
+  | SpreadElement
+  | Pattern
+  | ClassBody
+  | MethodDefinition
+  | ModuleDeclaration
+  | ModuleSpecifier
+
+export interface Program extends BaseNode {
+  type: 'Program'
+  sourceType: 'script' | 'module'
+  body: (Statement | ModuleDeclaration)[]
+  templateBody?: V.VRootElement
+  tokens: Token[]
+  comments: Token[]
+  errors: ParseError[]
+  parent: null
+}
+export type Statement =
+  | ExpressionStatement
+  | BlockStatement
+  | EmptyStatement
+  | DebuggerStatement
+  | WithStatement
+  | ReturnStatement
+  | LabeledStatement
+  | BreakStatement
+  | ContinueStatement
+  | IfStatement
+  | SwitchStatement
+  | ThrowStatement
+  | TryStatement
+  | WhileStatement
+  | DoWhileStatement
+  | ForStatement
+  | ForInStatement
+  | ForOfStatement
+  | Declaration
+export interface EmptyStatement extends HasParentNode {
+  type: 'EmptyStatement'
+}
+export interface BlockStatement extends HasParentNode {
+  type: 'BlockStatement'
+  body: Statement[]
+}
+export interface ExpressionStatement extends HasParentNode {
+  type: 'ExpressionStatement'
+  expression: Expression
+}
+export interface IfStatement extends HasParentNode {
+  type: 'IfStatement'
+  test: Expression
+  consequent: Statement
+  alternate: Statement | null
+}
+export interface SwitchStatement extends HasParentNode {
+  type: 'SwitchStatement'
+  discriminant: Expression
+  cases: SwitchCase[]
+}
+export interface SwitchCase extends HasParentNode {
+  type: 'SwitchCase'
+  test: Expression | null
+  consequent: Statement[]
+}
+export interface WhileStatement extends HasParentNode {
+  type: 'WhileStatement'
+  test: Expression
+  body: Statement
+}
+export interface DoWhileStatement extends HasParentNode {
+  type: 'DoWhileStatement'
+  body: Statement
+  test: Expression
+}
+export interface ForStatement extends HasParentNode {
+  type: 'ForStatement'
+  init: VariableDeclaration | Expression | null
+  test: Expression | null
+  update: Expression | null
+  body: Statement
+}
+export interface ForInStatement extends HasParentNode {
+  type: 'ForInStatement'
+  left: VariableDeclaration | Pattern
+  right: Expression
+  body: Statement
+}
+export interface ForOfStatement extends HasParentNode {
+  type: 'ForOfStatement'
+  left: VariableDeclaration | Pattern
+  right: Expression
+  body: Statement
+}
+export interface LabeledStatement extends HasParentNode {
+  type: 'LabeledStatement'
+  label: Identifier
+  body: Statement
+}
+export interface BreakStatement extends HasParentNode {
+  type: 'BreakStatement'
+  label: Identifier | null
+}
+export interface ContinueStatement extends HasParentNode {
+  type: 'ContinueStatement'
+  label: Identifier | null
+}
+export interface ReturnStatement extends HasParentNode {
+  type: 'ReturnStatement'
+  argument: Expression | null
+}
+export interface ThrowStatement extends HasParentNode {
+  type: 'ThrowStatement'
+  argument: Expression
+}
+export interface TryStatement extends HasParentNode {
+  type: 'TryStatement'
+  block: BlockStatement
+  handler: CatchClause | null
+  finalizer: BlockStatement | null
+}
+export interface CatchClause extends HasParentNode {
+  type: 'CatchClause'
+  param: Pattern
+  body: BlockStatement
+}
+export interface WithStatement extends HasParentNode {
+  type: 'WithStatement'
+  object: Expression
+  body: Statement
+}
+export interface DebuggerStatement extends HasParentNode {
+  type: 'DebuggerStatement'
+}
+export type Declaration =
+  | FunctionDeclaration
+  | VariableDeclaration
+  | ClassDeclaration
+export interface FunctionDeclaration extends HasParentNode {
+  type: 'FunctionDeclaration'
+  async: boolean
+  generator: boolean
+  id: Identifier | null
+  params: _FunctionParameter[]
+  body: BlockStatement
+}
+export interface VariableDeclaration extends HasParentNode {
+  type: 'VariableDeclaration'
+  kind: 'var' | 'let' | 'const'
+  declarations: VariableDeclarator[]
+}
+export interface VariableDeclarator extends HasParentNode {
+  type: 'VariableDeclarator'
+  id: Pattern
+  init: Expression | null
+}
+export interface ClassDeclaration extends HasParentNode {
+  type: 'ClassDeclaration'
+  id: Identifier | null
+  superClass: Expression | null
+  body: ClassBody
+}
+export interface ClassBody extends HasParentNode {
+  type: 'ClassBody'
+  body: MethodDefinition[]
+}
+export interface MethodDefinition extends HasParentNode {
+  type: 'MethodDefinition'
+  kind: 'constructor' | 'method' | 'get' | 'set'
+  computed: boolean
+  static: boolean
+  key: Expression
+  value: FunctionExpression
+}
+export type ModuleDeclaration =
+  | ImportDeclaration
+  | ExportNamedDeclaration
+  | ExportDefaultDeclaration
+  | ExportAllDeclaration
+export type ModuleSpecifier =
+  | ImportSpecifier
+  | ImportDefaultSpecifier
+  | ImportNamespaceSpecifier
+  | ExportSpecifier
+export interface ImportDeclaration extends HasParentNode {
+  type: 'ImportDeclaration'
+  specifiers: (
+    | ImportSpecifier
+    | ImportDefaultSpecifier
+    | ImportNamespaceSpecifier
+  )[]
+  source: Literal
+}
+export interface ImportSpecifier extends HasParentNode {
+  type: 'ImportSpecifier'
+  imported: Identifier
+  local: Identifier
+}
+export interface ImportDefaultSpecifier extends HasParentNode {
+  type: 'ImportDefaultSpecifier'
+  local: Identifier
+}
+export interface ImportNamespaceSpecifier extends HasParentNode {
+  type: 'ImportNamespaceSpecifier'
+  local: Identifier
+}
+export interface ExportNamedDeclaration extends HasParentNode {
+  type: 'ExportNamedDeclaration'
+  declaration?: Declaration | null
+  specifiers: ExportSpecifier[]
+  source?: Literal | null
+}
+export interface ExportSpecifier extends HasParentNode {
+  type: 'ExportSpecifier'
+  exported: Identifier
+}
+export interface ExportDefaultDeclaration extends HasParentNode {
+  type: 'ExportDefaultDeclaration'
+  declaration: Declaration | Expression
+}
+export interface ExportAllDeclaration extends HasParentNode {
+  type: 'ExportAllDeclaration'
+  source: Literal
+}
+export type Expression =
+  | ThisExpression
+  | ArrayExpression
+  | ObjectExpression
+  | FunctionExpression
+  | ArrowFunctionExpression
+  | YieldExpression
+  | Literal
+  | UnaryExpression
+  | UpdateExpression
+  | BinaryExpression
+  | AssignmentExpression
+  | LogicalExpression
+  | MemberExpression
+  | ConditionalExpression
+  | CallExpression
+  | NewExpression
+  | SequenceExpression
+  | TemplateLiteral
+  | TaggedTemplateExpression
+  | ClassExpression
+  | MetaProperty
+  | Identifier
+  | AwaitExpression
+  | JSX.JSXElement
+  | JSX.JSXFragment
+  | TS.TSAsExpression
+
+export interface Identifier extends HasParentNode {
+  type: 'Identifier'
+  name: string
+}
+export interface Literal extends HasParentNode {
+  type: 'Literal'
+  value: string | boolean | null | number | RegExp | BigInt
+  regex?: {
+    pattern: string
+    flags: string
+  }
+  bigint?: string
+}
+export interface ThisExpression extends HasParentNode {
+  type: 'ThisExpression'
+}
+export interface ArrayExpression extends HasParentNode {
+  type: 'ArrayExpression'
+  elements: (Expression | SpreadElement)[]
+}
+export interface ObjectExpression extends HasParentNode {
+  type: 'ObjectExpression'
+  properties: (Property | SpreadElement)[]
+}
+export interface Property extends HasParentNode {
+  type: 'Property'
+  kind: 'init' | 'get' | 'set'
+  method: boolean
+  shorthand: boolean
+  computed: boolean
+  key: Expression
+  value: Expression
+  parent: ObjectExpression
+}
+export interface FunctionExpression extends HasParentNode {
+  type: 'FunctionExpression'
+  async: boolean
+  generator: boolean
+  id: Identifier | null
+  params: _FunctionParameter[]
+  body: BlockStatement
+}
+
+interface ArrowFunctionExpressionHasBlock extends HasParentNode {
+  type: 'ArrowFunctionExpression'
+  async: boolean
+  generator: boolean
+  id: Identifier | null
+  params: _FunctionParameter[]
+  body: BlockStatement
+  expression: false
+}
+
+interface ArrowFunctionExpressionNoBlock extends HasParentNode {
+  type: 'ArrowFunctionExpression'
+  async: boolean
+  generator: boolean
+  id: Identifier | null
+  params: _FunctionParameter[]
+  body: Expression
+  expression: true
+}
+
+export type ArrowFunctionExpression =
+  | ArrowFunctionExpressionNoBlock
+  | ArrowFunctionExpressionHasBlock
+
+export interface SequenceExpression extends HasParentNode {
+  type: 'SequenceExpression'
+  expressions: Expression[]
+}
+export interface UnaryExpression extends HasParentNode {
+  type: 'UnaryExpression'
+  operator: '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete'
+  prefix: boolean
+  argument: Expression
+}
+export interface BinaryExpression extends HasParentNode {
+  type: 'BinaryExpression'
+  operator:
+    | '=='
+    | '!='
+    | '==='
+    | '!=='
+    | '<'
+    | '<='
+    | '>'
+    | '>='
+    | '<<'
+    | '>>'
+    | '>>>'
+    | '+'
+    | '-'
+    | '*'
+    | '/'
+    | '%'
+    | '**'
+    | '|'
+    | '^'
+    | '&'
+    | 'in'
+    | 'instanceof'
+  left: Expression
+  right: Expression
+}
+export interface AssignmentExpression extends HasParentNode {
+  type: 'AssignmentExpression'
+  operator:
+    | '='
+    | '+='
+    | '-='
+    | '*='
+    | '/='
+    | '%='
+    | '**='
+    | '<<='
+    | '>>='
+    | '>>>='
+    | '|='
+    | '^='
+    | '&='
+  left: Pattern
+  right: Expression
+}
+export interface UpdateExpression extends HasParentNode {
+  type: 'UpdateExpression'
+  operator: '++' | '--'
+  argument: Expression
+  prefix: boolean
+}
+export interface LogicalExpression extends HasParentNode {
+  type: 'LogicalExpression'
+  operator: '||' | '&&'
+  left: Expression
+  right: Expression
+}
+export interface ConditionalExpression extends HasParentNode {
+  type: 'ConditionalExpression'
+  test: Expression
+  alternate: Expression
+  consequent: Expression
+}
+export interface CallExpression extends HasParentNode {
+  type: 'CallExpression'
+  callee: Expression | Super
+  arguments: (Expression | SpreadElement)[]
+}
+export interface Super extends HasParentNode {
+  type: 'Super'
+}
+export interface NewExpression extends HasParentNode {
+  type: 'NewExpression'
+  callee: Expression
+  arguments: (Expression | SpreadElement)[]
+}
+export interface MemberExpression extends HasParentNode {
+  type: 'MemberExpression'
+  computed: boolean
+  object: Expression | Super
+  property: Expression
+}
+export interface YieldExpression extends HasParentNode {
+  type: 'YieldExpression'
+  delegate: boolean
+  argument: Expression | null
+}
+export interface AwaitExpression extends HasParentNode {
+  type: 'AwaitExpression'
+  argument: Expression
+}
+export interface TemplateLiteral extends HasParentNode {
+  type: 'TemplateLiteral'
+  quasis: TemplateElement[]
+  expressions: Expression[]
+}
+export interface TaggedTemplateExpression extends HasParentNode {
+  type: 'TaggedTemplateExpression'
+  tag: Expression
+  quasi: TemplateLiteral
+}
+export interface TemplateElement extends HasParentNode {
+  type: 'TemplateElement'
+  tail: boolean
+  value: {
+    cooked: string
+    raw: string
+  }
+}
+export interface ClassExpression extends HasParentNode {
+  type: 'ClassExpression'
+  id: Identifier | null
+  superClass: Expression | null
+  body: ClassBody
+}
+export interface MetaProperty extends HasParentNode {
+  type: 'MetaProperty'
+  meta: Identifier
+  property: Identifier
+}
+export type Pattern =
+  | Identifier
+  | ObjectPattern
+  | ArrayPattern
+  | RestElement
+  | AssignmentPattern
+  | MemberExpression
+export interface ObjectPattern extends HasParentNode {
+  type: 'ObjectPattern'
+  properties: (AssignmentProperty | RestElement)[]
+}
+export interface AssignmentProperty extends HasParentNode {
+  type: 'Property'
+  kind: 'init'
+  method: false
+  shorthand: boolean
+  computed: boolean
+  key: Expression
+  value: Pattern
+  parent: ObjectPattern
+}
+export interface ArrayPattern extends HasParentNode {
+  type: 'ArrayPattern'
+  elements: Pattern[]
+}
+export interface RestElement extends HasParentNode {
+  type: 'RestElement'
+  argument: Pattern
+}
+export interface SpreadElement extends HasParentNode {
+  type: 'SpreadElement'
+  argument: Expression
+}
+export interface AssignmentPattern extends HasParentNode {
+  type: 'AssignmentPattern'
+  left: Pattern
+  right: Expression
+}
+
+export type _FunctionParameter =
+  | AssignmentPattern
+  | RestElement
+  | ArrayPattern
+  | ObjectPattern
+  | Identifier
+// | TSParameterProperty;
diff --git a/typings/eslint-plugin-vue/util-types/ast/index.ts b/typings/eslint-plugin-vue/util-types/ast/index.ts
new file mode 100644
index 000000000..5372ff3ea
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/ast/index.ts
@@ -0,0 +1,5 @@
+export * from './ast'
+export * from './es-ast'
+export * from './v-ast'
+export * from './ts-ast'
+export * from './jsx-ast'
diff --git a/typings/eslint-plugin-vue/util-types/ast/jsx-ast.ts b/typings/eslint-plugin-vue/util-types/ast/jsx-ast.ts
new file mode 100644
index 000000000..4f1b04af0
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/ast/jsx-ast.ts
@@ -0,0 +1,106 @@
+/**
+ * @see https://github.com/facebook/jsx/blob/master/AST.md
+ * @see https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/typescript-estree/src/ts-estree/ts-estree.ts
+ */
+import { HasParentNode } from '../node'
+import * as ES from './es-ast'
+
+export type JSXNode =
+  | JSXAttribute
+  | JSXClosingElement
+  | JSXClosingFragment
+  | JSXElement
+  | JSXEmptyExpression
+  | JSXExpressionContainer
+  | JSXFragment
+  | JSXIdentifier
+  | JSXOpeningElement
+  | JSXOpeningFragment
+  | JSXSpreadAttribute
+  | JSXSpreadChild
+  | JSXMemberExpression
+  | JSXText
+
+export type JSXChild = JSXElement | JSXExpression | JSXFragment | JSXText
+export type JSXExpression =
+  | JSXEmptyExpression
+  | JSXSpreadChild
+  | JSXExpressionContainer
+export type JSXTagNameExpression = JSXIdentifier | JSXMemberExpression
+
+export interface JSXAttribute extends HasParentNode {
+  type: 'JSXAttribute'
+  name: JSXIdentifier
+  value: ES.Literal | JSXExpression | null
+}
+
+export interface JSXClosingElement extends HasParentNode {
+  type: 'JSXClosingElement'
+  name: JSXTagNameExpression
+}
+
+export interface JSXClosingFragment extends HasParentNode {
+  type: 'JSXClosingFragment'
+}
+
+export interface JSXElement extends HasParentNode {
+  type: 'JSXElement'
+  openingElement: JSXOpeningElement
+  closingElement: JSXClosingElement | null
+  children: JSXChild[]
+}
+
+export interface JSXEmptyExpression extends HasParentNode {
+  type: 'JSXEmptyExpression'
+}
+
+export interface JSXExpressionContainer extends HasParentNode {
+  type: 'JSXExpressionContainer'
+  expression: ES.Expression | JSXEmptyExpression
+}
+
+export interface JSXFragment extends HasParentNode {
+  type: 'JSXFragment'
+  openingFragment: JSXOpeningFragment
+  closingFragment: JSXClosingFragment
+  children: JSXChild[]
+}
+
+export interface JSXIdentifier extends HasParentNode {
+  type: 'JSXIdentifier'
+  name: string
+}
+
+export interface JSXMemberExpression extends HasParentNode {
+  type: 'JSXMemberExpression'
+  object: JSXTagNameExpression
+  property: JSXIdentifier
+}
+
+export interface JSXOpeningElement extends HasParentNode {
+  type: 'JSXOpeningElement'
+  // typeParameters?: TSTypeParameterInstantiation;
+  selfClosing: boolean
+  name: JSXTagNameExpression
+  attributes: JSXAttribute[]
+}
+
+export interface JSXOpeningFragment extends HasParentNode {
+  type: 'JSXOpeningFragment'
+}
+
+export interface JSXSpreadAttribute extends HasParentNode {
+  type: 'JSXSpreadAttribute'
+  argument: ES.Expression
+}
+
+export interface JSXSpreadChild extends HasParentNode {
+  type: 'JSXSpreadChild'
+  expression: ES.Expression | JSXEmptyExpression
+}
+
+export interface JSXText extends HasParentNode {
+  type: 'JSXText'
+  value: string
+  raw: string
+}
diff --git a/typings/eslint-plugin-vue/util-types/ast/ts-ast.ts b/typings/eslint-plugin-vue/util-types/ast/ts-ast.ts
new file mode 100644
index 000000000..28dc29fe2
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/ast/ts-ast.ts
@@ -0,0 +1,11 @@
+/**
+ * @see https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/typescript-estree/src/ts-estree/ts-estree.ts
+ */
+import { HasParentNode } from '../node'
+import * as ES from './es-ast'
+export type TSNode = TSAsExpression
+
+export interface TSAsExpression extends HasParentNode {
+  type: 'TSAsExpression'
+  expression: ES.Expression
+}
diff --git a/typings/eslint-plugin-vue/util-types/ast/v-ast.ts b/typings/eslint-plugin-vue/util-types/ast/v-ast.ts
new file mode 100644
index 000000000..b7c5446dc
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/ast/v-ast.ts
@@ -0,0 +1,174 @@
+/**
+ * @see https://github.com/mysticatea/vue-eslint-parser/blob/master/docs/ast.md
+ */
+import { HasParentNode, BaseNode } from '../node'
+import { Token, HTMLComment, HTMLBogusComment, Comment } from '../node'
+import { ParseError } from '../errors'
+import * as ES from './es-ast'
+
+export type NS = {
+  HTML: 'http://www.w3.org/1999/xhtml'
+  MathML: 'http://www.w3.org/1998/Math/MathML'
+  SVG: 'http://www.w3.org/2000/svg'
+  XLink: 'http://www.w3.org/1999/xlink'
+  XML: 'http://www.w3.org/XML/1998/namespace'
+  XMLNS: 'http://www.w3.org/2000/xmlns/'
+}
+export type Namespace =
+  | NS['HTML']
+  | NS['MathML']
+  | NS['SVG']
+  | NS['XLink']
+  | NS['XML']
+  | NS['XMLNS']
+export interface VVariable {
+  id: ES.Identifier
+  kind: 'v-for' | 'scope'
+  references: VReference[]
+}
+export interface VReference {
+  id: ES.Identifier
+  mode: 'rw' | 'r' | 'w'
+  variable: VVariable | null
+}
+export interface VForExpression extends HasParentNode {
+  type: 'VForExpression'
+  parent: VExpressionContainer
+  left: ES.Pattern[]
+  right: ES.Expression
+}
+export interface VOnExpression extends HasParentNode {
+  type: 'VOnExpression'
+  parent: VExpressionContainer
+  body: ES.Statement[]
+}
+export interface VSlotScopeExpression extends HasParentNode {
+  type: 'VSlotScopeExpression'
+  parent: VExpressionContainer
+  params: ES._FunctionParameter[]
+}
+export interface VFilterSequenceExpression extends HasParentNode {
+  type: 'VFilterSequenceExpression'
+  parent: VExpressionContainer
+  expression: ES.Expression
+  filters: VFilter[]
+}
+export interface VFilter extends HasParentNode {
+  type: 'VFilter'
+  parent: VFilterSequenceExpression
+  callee: ES.Identifier
+  arguments: (ES.Expression | ES.SpreadElement)[]
+}
+export type VNode =
+  | VAttribute
+  | VDirective
+  | VDirectiveKey
+  | VElement
+  | VEndTag
+  | VExpressionContainer
+  | VIdentifier
+  | VLiteral
+  | VStartTag
+  | VText
+  | VDocumentFragment
+  | VForExpression
+  | VOnExpression
+  | VSlotScopeExpression
+  | VFilterSequenceExpression
+  | VFilter
+
+export interface VText extends HasParentNode {
+  type: 'VText'
+  parent: VDocumentFragment | VElement
+  value: string
+}
+export interface VExpressionContainer extends HasParentNode {
+  type: 'VExpressionContainer'
+  parent: VDocumentFragment | VElement | VDirective | VDirectiveKey
+  expression:
+    | ES.Expression
+    | VFilterSequenceExpression
+    | VForExpression
+    | VOnExpression
+    | VSlotScopeExpression
+    | null
+  references: VReference[]
+}
+export interface VIdentifier extends HasParentNode {
+  type: 'VIdentifier'
+  parent: VAttribute | VDirectiveKey
+  name: string
+  rawName: string
+}
+export interface VDirectiveKey extends HasParentNode {
+  type: 'VDirectiveKey'
+  parent: VAttribute
+  name: VIdentifier
+  argument: VExpressionContainer | VIdentifier | null
+  modifiers: VIdentifier[]
+}
+export interface VLiteral extends HasParentNode {
+  type: 'VLiteral'
+  parent: VAttribute
+  value: string
+}
+export interface VAttribute extends HasParentNode {
+  type: 'VAttribute'
+  parent: VStartTag
+  directive: false
+  key: VIdentifier
+  value: VLiteral | null
+}
+export interface VDirective extends HasParentNode {
+  type: 'VAttribute'
+  parent: VStartTag
+  directive: true
+  key: VDirectiveKey
+  value: VExpressionContainer | null
+}
+export interface VStartTag extends HasParentNode {
+  type: 'VStartTag'
+  parent: VElement
+  selfClosing: boolean
+  attributes: (VAttribute | VDirective)[]
+}
+export interface VEndTag extends HasParentNode {
+  type: 'VEndTag'
+  parent: VElement
+}
+interface HasConcreteInfo {
+  tokens: Token[]
+  comments: (HTMLComment | HTMLBogusComment | Comment)[]
+  errors: ParseError[]
+}
+export interface VRootElement extends HasParentNode, HasConcreteInfo {
+  type: 'VElement'
+  parent: VDocumentFragment
+  namespace: Namespace
+  name: string
+  rawName: string
+  startTag: VStartTag
+  children: (VElement | VText | VExpressionContainer)[]
+  endTag: VEndTag | null
+  variables: VVariable[]
+}
+
+interface VChildElement extends HasParentNode {
+  type: 'VElement'
+  parent: VRootElement | VElement
+  namespace: Namespace
+  name: string
+  rawName: string
+  startTag: VStartTag
+  children: (VElement | VText | VExpressionContainer)[]
+  endTag: VEndTag | null
+  variables: VVariable[]
+}
+
+export type VElement = VChildElement | VRootElement
+
+export interface VDocumentFragment extends BaseNode, HasConcreteInfo {
+  type: 'VDocumentFragment'
+  parent: null
+  children: (VElement | VText | VExpressionContainer)[]
+}
diff --git a/typings/eslint-plugin-vue/util-types/errors.ts b/typings/eslint-plugin-vue/util-types/errors.ts
new file mode 100644
index 000000000..213e80388
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/errors.ts
@@ -0,0 +1,43 @@
+export interface ParseError extends SyntaxError {
+  code?: VParseErrorCode
+  index: number
+  lineNumber: number
+  column: number
+}
+type VParseErrorCode =
+  | 'abrupt-closing-of-empty-comment'
+  | 'absence-of-digits-in-numeric-character-reference'
+  | 'cdata-in-html-content'
+  | 'character-reference-outside-unicode-range'
+  | 'control-character-in-input-stream'
+  | 'control-character-reference'
+  | 'eof-before-tag-name'
+  | 'eof-in-cdata'
+  | 'eof-in-comment'
+  | 'eof-in-tag'
+  | 'incorrectly-closed-comment'
+  | 'incorrectly-opened-comment'
+  | 'invalid-first-character-of-tag-name'
+  | 'missing-attribute-value'
+  | 'missing-end-tag-name'
+  | 'missing-semicolon-after-character-reference'
+  | 'missing-whitespace-between-attributes'
+  | 'nested-comment'
+  | 'noncharacter-character-reference'
+  | 'noncharacter-in-input-stream'
+  | 'null-character-reference'
+  | 'surrogate-character-reference'
+  | 'surrogate-in-input-stream'
+  | 'unexpected-character-in-attribute-name'
+  | 'unexpected-character-in-unquoted-attribute-value'
+  | 'unexpected-equals-sign-before-attribute-name'
+  | 'unexpected-null-character'
+  | 'unexpected-question-mark-instead-of-tag-name'
+  | 'unexpected-solidus-in-tag'
+  | 'unknown-named-character-reference'
+  | 'end-tag-with-attributes'
+  | 'duplicate-attribute'
+  | 'end-tag-with-trailing-solidus'
+  | 'non-void-html-element-start-tag-with-trailing-solidus'
+  | 'x-invalid-end-tag'
+  | 'x-invalid-namespace'
diff --git a/typings/eslint-plugin-vue/util-types/node/index.ts b/typings/eslint-plugin-vue/util-types/node/index.ts
new file mode 100644
index 000000000..b51b688cf
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/node/index.ts
@@ -0,0 +1,3 @@
+export * from './locations'
+export * from './tokens'
+export * from './node'
diff --git a/typings/eslint-plugin-vue/util-types/node/locations.ts b/typings/eslint-plugin-vue/util-types/node/locations.ts
new file mode 100644
index 000000000..78a4e6411
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/node/locations.ts
@@ -0,0 +1,13 @@
+export interface Position {
+  line: number
+  column: number
+}
+export interface SourceLocation {
+  start: Position
+  end: Position
+}
+export type Range = [number, number]
+export interface HasLocation {
+  range: Range
+  loc: SourceLocation
+}
diff --git a/typings/eslint-plugin-vue/util-types/node/node.ts b/typings/eslint-plugin-vue/util-types/node/node.ts
new file mode 100644
index 000000000..93dee902d
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/node/node.ts
@@ -0,0 +1,11 @@
+import { HasLocation } from './locations'
+import * as VAST from '../ast'
+
+export interface BaseNode extends HasLocation {
+  type: string
+  parent: VAST.ASTNode | null
+}
+
+export interface HasParentNode extends BaseNode {
+  parent: VAST.ASTNode
+}
diff --git a/typings/eslint-plugin-vue/util-types/node/tokens.ts b/typings/eslint-plugin-vue/util-types/node/tokens.ts
new file mode 100644
index 000000000..fd765281f
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/node/tokens.ts
@@ -0,0 +1,17 @@
+import { HasLocation } from './locations'
+export interface Token extends HasLocation {
+  type: string
+  value: string
+}
+export interface Comment extends Token {
+  type: 'Line' | 'Block'
+  value: string
+}
+export interface HTMLComment extends Token {
+  type: 'HTMLComment'
+  value: string
+}
+export interface HTMLBogusComment extends Token {
+  type: 'HTMLBogusComment'
+  value: string
+}
diff --git a/typings/eslint-plugin-vue/util-types/parser-services.ts b/typings/eslint-plugin-vue/util-types/parser-services.ts
new file mode 100644
index 000000000..c2e68464a
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/parser-services.ts
@@ -0,0 +1,122 @@
+import * as VNODE from './node'
+import * as VAST from './ast'
+import * as eslint from 'eslint'
+
+type TemplateListenerBase = {
+  [T in keyof VAST.VNodeListenerMap]?: (node: VAST.VNodeListenerMap[T]) => void
+}
+export interface TemplateListener
+  extends TemplateListenerBase,
+    eslint.Rule.NodeListener {
+  [key: string]: ((node: VAST.ParamNode) => void) | undefined
+}
+
+export interface ParserServices {
+  getTemplateBodyTokenStore: () => ParserServices.TokenStore
+  defineTemplateBodyVisitor?: (
+    templateBodyVisitor: TemplateListener,
+    scriptVisitor?: eslint.Rule.RuleListener
+  ) => eslint.Rule.RuleListener
+  getDocumentFragment?: () => VAST.VDocumentFragment
+}
+export namespace ParserServices {
+  export interface TokenStore {
+    getTokenByRangeStart(
+      offset: number,
+      options?: { includeComments: boolean }
+    ): VNODE.Token | null
+    getFirstToken(node: VNODE.HasLocation): VNODE.Token
+    getFirstToken(node: VNODE.HasLocation, options: number): VNODE.Token
+    getFirstToken(
+      node: VNODE.HasLocation,
+      options: eslint.SourceCode.CursorWithSkipOptions
+    ): VNODE.Token | null
+    getLastToken(node: VNODE.HasLocation): VNODE.Token
+    getLastToken(node: VNODE.HasLocation, options: number): VNODE.Token
+    getLastToken(
+      node: VNODE.HasLocation,
+      options: eslint.SourceCode.CursorWithSkipOptions
+    ): VNODE.Token | null
+    getTokenBefore(node: VNODE.HasLocation): VNODE.Token
+    getTokenBefore(node: VNODE.HasLocation, options: number): VNODE.Token
+    getTokenBefore(
+      node: VNODE.HasLocation,
+      options: { includeComments: boolean }
+    ): VNODE.Token
+    getTokenBefore(
+      node: VNODE.HasLocation,
+      options: eslint.SourceCode.CursorWithSkipOptions
+    ): VNODE.Token | null
+    getTokenAfter(node: VNODE.HasLocation): VNODE.Token
+    getTokenAfter(node: VNODE.HasLocation, options: number): VNODE.Token
+    getTokenAfter(
+      node: VNODE.HasLocation,
+      options: { includeComments: boolean }
+    ): VNODE.Token
+    getTokenAfter(
+      node: VNODE.HasLocation,
+      options: eslint.SourceCode.CursorWithSkipOptions
+    ): VNODE.Token | null
+    getFirstTokenBetween(
+      left: VNODE.HasLocation,
+      right: VNODE.HasLocation,
+      options?: eslint.SourceCode.CursorWithSkipOptions
+    ): VNODE.Token | null
+    getLastTokenBetween(
+      left: VNODE.HasLocation,
+      right: VNODE.HasLocation,
+      options?: eslint.SourceCode.CursorWithSkipOptions
+    ): VNODE.Token | null
+    getTokenOrCommentBefore(
+      node: VNODE.HasLocation,
+      skip?: number
+    ): VNODE.Token | null
+    getTokenOrCommentAfter(
+      node: VNODE.HasLocation,
+      skip?: number
+    ): VNODE.Token | null
+    getFirstTokens(
+      node: VNODE.HasLocation,
+      options?: eslint.SourceCode.CursorWithCountOptions
+    ): VNODE.Token[]
+    getLastTokens(
+      node: VNODE.HasLocation,
+      options?: eslint.SourceCode.CursorWithCountOptions
+    ): VNODE.Token[]
+    getTokensBefore(
+      node: VNODE.HasLocation,
+      options?: eslint.SourceCode.CursorWithCountOptions
+    ): VNODE.Token[]
+    getTokensAfter(
+      node: VNODE.HasLocation,
+      options?: eslint.SourceCode.CursorWithCountOptions
+    ): VNODE.Token[]
+    getFirstTokensBetween(
+      left: VNODE.HasLocation,
+      right: VNODE.HasLocation,
+      options?: eslint.SourceCode.CursorWithCountOptions
+    ): VNODE.Token[]
+    getLastTokensBetween(
+      left: VNODE.HasLocation,
+      right: VNODE.HasLocation,
+      options?: eslint.SourceCode.CursorWithCountOptions
+    ): VNODE.Token[]
+    getTokens(
+      node: VNODE.HasLocation,
+      beforeCount?: eslint.SourceCode.CursorWithCountOptions,
+      afterCount?: number
+    ): VNODE.Token[]
+    getTokensBetween(
+      left: VNODE.HasLocation,
+      right: VNODE.HasLocation,
+      padding?: eslint.SourceCode.CursorWithCountOptions
+    ): VNODE.Token[]
+    commentsExistBetween(
+      left: VNODE.HasLocation,
+      right: VNODE.HasLocation
+    ): boolean
+    getCommentsBefore(nodeOrToken: VNODE.HasLocation): VNODE.Token[]
+    getCommentsAfter(nodeOrToken: VNODE.HasLocation): VNODE.Token[]
+    getCommentsInside(node: VNODE.HasLocation): VNODE.Token[]
+  }
+}
diff --git a/typings/eslint-plugin-vue/util-types/utils.ts b/typings/eslint-plugin-vue/util-types/utils.ts
new file mode 100644
index 000000000..6888e9a41
--- /dev/null
+++ b/typings/eslint-plugin-vue/util-types/utils.ts
@@ -0,0 +1,29 @@
+import * as VAST from './ast'
+export type VueObjectType = 'mark' | 'export' | 'definition' | 'instance'
+export type VueObjectData = {
+  node: ObjectExpression
+  type: VueObjectType
+  parent: VueObjectData | null
+  functional: boolean
+}
+type VueVisitorBase = {
+  [T in keyof NodeListenerMap]?: (
+    node: NodeListenerMap[T],
+    obj: VueObjectData
+  ) => void
+}
+export interface VueVisitor extends VueVisitorBase {
+  onVueObjectEnter?(node: ObjectExpression, obj: VueObjectData): void
+  onVueObjectExit?(node: ObjectExpression, obj: VueObjectData): void
+  onSetupFunctionEnter?(
+    node: (FunctionExpression | ArrowFunctionExpression) & { parent: Property },
+    obj: VueObjectData
+  ): void
+  onRenderFunctionEnter?(
+    node: (FunctionExpression | ArrowFunctionExpression) & { parent: Property },
+    obj: VueObjectData
+  ): void
+  [query: string]:
+    | ((node: VAST.ParamNode, obj: VueObjectData) => void)
+    | undefined
+}
diff --git a/typings/eslint-utils/index.d.ts b/typings/eslint-utils/index.d.ts
new file mode 100644
index 000000000..884fc60cd
--- /dev/null
+++ b/typings/eslint-utils/index.d.ts
@@ -0,0 +1,72 @@
+import * as VAST from '../eslint-plugin-vue/util-types/ast'
+import { ParserServices } from '../eslint-plugin-vue/util-types/parser-services'
+import eslint from 'eslint'
+
+export function findVariable(
+  initialScope: eslint.Scope.Scope,
+  nameOrNode: VAST.Identifier | string
+): eslint.Scope.Variable
+
+export function isParenthesized(
+  num: number,
+  node: VAST.ESNode,
+  sourceCode: eslint.SourceCode | ParserServices.TokenStore
+): boolean
+export function isParenthesized(
+  node: VAST.ESNode,
+  sourceCode: eslint.SourceCode | ParserServices.TokenStore
+): boolean
+
+export namespace TYPES {
+  type TraceKind = {
+    [ReferenceTracker.READ]?: boolean
+    [ReferenceTracker.CALL]?: boolean
+    [ReferenceTracker.CONSTRUCT]?: boolean
+    [ReferenceTracker.ESM]?: boolean
+  }
+  type TraceMap = {
+    [key: string]: TraceKind & TraceMap
+  }
+}
+
+export class ReferenceTracker {
+  constructor(
+    globalScope: eslint.Scope.Scope,
+    options?: {
+      mode?: 'legacy' | 'strict'
+      globalObjectNames?: ('global' | 'globalThis' | 'self' | 'window')[]
+    }
+  )
+
+  iterateGlobalReferences(
+    traceMap: TYPES.TraceMap
+  ): IterableIterator<{
+    node: VAST.ESNode
+    path: string[]
+    type: symbol
+    info: any
+  }>
+  iterateCjsReferences(
+    traceMap: TYPES.TraceMap
+  ): IterableIterator<{
+    node: VAST.ESNode
+    path: string[]
+    type: symbol
+    info: any
+  }>
+  iterateEsmReferences(
+    traceMap: TYPES.TraceMap
+  ): IterableIterator<{
+    node: VAST.ESNode
+    path: string[]
+    type: symbol
+    info: any
+  }>
+}
+
+export namespace ReferenceTracker {
+  const READ: unique symbol
+  const CALL: unique symbol
+  const CONSTRUCT: unique symbol
+  const ESM: unique symbol
+}
diff --git a/typings/eslint/index.d.ts b/typings/eslint/index.d.ts
new file mode 100644
index 000000000..653abebda
--- /dev/null
+++ b/typings/eslint/index.d.ts
@@ -0,0 +1,420 @@
+import {
+  Rule as ESLintRule,
+  RuleTester as ESLintRuleTester,
+  Linter as ESLintLinter
+} from '../../node_modules/@types/eslint'
+import * as VAST from '../eslint-plugin-vue/util-types/ast'
+import * as VNODE from '../eslint-plugin-vue/util-types/node'
+import * as parserServices from '../eslint-plugin-vue/util-types/parser-services'
+
+export namespace AST {
+  type Token = VNODE.Token
+  type Range = VNODE.Range
+  type SourceLocation = VNODE.SourceLocation
+  type Program = VAST.Program
+}
+export namespace Scope {
+  interface ScopeManager {
+    scopes: Scope[]
+    globalScope: Scope | null
+    acquire(node: VAST.ESNode | VAST.Program, inner?: boolean): Scope | null
+    getDeclaredVariables(node: VAST.ESNode): Variable[]
+  }
+  interface Scope {
+    type:
+      | 'block'
+      | 'catch'
+      | 'class'
+      | 'for'
+      | 'function'
+      | 'function-expression-name'
+      | 'global'
+      | 'module'
+      | 'switch'
+      | 'with'
+      | 'TDZ'
+    isStrict: boolean
+    upper: Scope | null
+    childScopes: Scope[]
+    variableScope: Scope
+    block: VAST.ESNode
+    variables: Variable[]
+    set: Map<string, Variable>
+    references: Reference[]
+    through: Reference[]
+    functionExpressionScope: boolean
+  }
+  interface Variable {
+    name: string
+    identifiers: VAST.Identifier[]
+    references: Reference[]
+    defs: Definition[]
+  }
+  interface Reference {
+    identifier: VAST.Identifier
+    from: Scope
+    resolved: Variable | null
+    writeExpr: VAST.ESNode | null
+    init: boolean
+    isWrite(): boolean
+    isRead(): boolean
+    isWriteOnly(): boolean
+    isReadOnly(): boolean
+    isReadWrite(): boolean
+  }
+  type DefinitionType =
+    | { type: 'CatchClause'; node: VAST.CatchClause; parent: null }
+    | {
+        type: 'ClassName'
+        node: VAST.ClassDeclaration | VAST.ClassExpression
+        parent: null
+      }
+    | {
+        type: 'FunctionName'
+        node: VAST.FunctionDeclaration | VAST.FunctionExpression
+        parent: null
+      }
+    | { type: 'ImplicitGlobalVariable'; node: VAST.Program; parent: null }
+    | {
+        type: 'ImportBinding'
+        node:
+          | VAST.ImportSpecifier
+          | VAST.ImportDefaultSpecifier
+          | VAST.ImportNamespaceSpecifier
+        parent: VAST.ImportDeclaration
+      }
+    | {
+        type: 'Parameter'
+        node:
+          | VAST.FunctionDeclaration
+          | VAST.FunctionExpression
+          | VAST.ArrowFunctionExpression
+        parent: null
+      }
+    | { type: 'TDZ'; node: any; parent: null }
+    | {
+        type: 'Variable'
+        node: VAST.VariableDeclarator
+        parent: VAST.VariableDeclaration
+      }
+  type Definition = DefinitionType & { name: VAST.Identifier }
+}
+
+export class SourceCode /*extends ESLintSourceCode*/ {
+  text: string
+  ast: AST.Program
+  lines: string[]
+  hasBOM: boolean
+  parserServices: SourceCode.ParserServices
+  scopeManager: Scope.ScopeManager
+  visitorKeys: SourceCode.VisitorKeys
+
+  static splitLines(text: string): string[]
+
+  getText(
+    node?: VNODE.HasLocation,
+    beforeCount?: number,
+    afterCount?: number
+  ): string
+  getLines(): string[]
+  getAllComments(): VNODE.Comment[]
+  getComments(
+    node: VAST.ESNode
+  ): { leading: VNODE.Comment[]; trailing: VNODE.Comment[] }
+  getJSDocComment(node: VAST.ESNode): AST.Token | null
+  getNodeByRangeIndex(index: number): VAST.ESNode | VAST.JSXNode
+  isSpaceBetweenTokens(first: AST.Token, second: AST.Token): boolean
+  getLocFromIndex(index: number): VNODE.Position
+  getIndexFromLoc(location: VNODE.Position): number
+
+  getTokenByRangeStart(
+    offset: number,
+    options?: { includeComments?: boolean }
+  ): AST.Token | null
+  getFirstToken(node: VNODE.HasLocation): AST.Token
+  getFirstToken(node: VNODE.HasLocation, options: number): AST.Token
+  getFirstToken(
+    node: VNODE.HasLocation,
+    options: SourceCode.CursorWithSkipOptions
+  ): AST.Token | null
+  getFirstTokens(
+    node: VNODE.HasLocation,
+    options?: SourceCode.CursorWithCountOptions
+  ): AST.Token[]
+  getLastToken(node: VNODE.HasLocation): AST.Token
+  getLastToken(node: VNODE.HasLocation, options: number): AST.Token
+  getLastToken(
+    node: VNODE.HasLocation,
+    optionss: SourceCode.CursorWithSkipOptions
+  ): AST.Token | null
+  getLastTokens(
+    node: VNODE.HasLocation,
+    options?: SourceCode.CursorWithCountOptions
+  ): AST.Token[]
+  getTokenBefore(node: VNODE.HasLocation): AST.Token
+  getTokenBefore(node: VNODE.HasLocation, options: number): AST.Token
+  getTokenBefore(
+    node: VNODE.HasLocation,
+    options: { includeComments: boolean }
+  ): AST.Token
+  getTokenBefore(
+    node: VNODE.HasLocation,
+    options?: SourceCode.CursorWithSkipOptions
+  ): AST.Token | null
+  getTokensBefore(
+    node: VNODE.HasLocation,
+    options?: SourceCode.CursorWithCountOptions
+  ): AST.Token[]
+  getTokenAfter(node: VNODE.HasLocation): AST.Token
+  getTokenAfter(node: VNODE.HasLocation, options: number): AST.Token
+  getTokenAfter(
+    node: VNODE.HasLocation,
+    options: { includeComments: boolean }
+  ): AST.Token
+  getTokenAfter(
+    node: VNODE.HasLocation,
+    options: SourceCode.CursorWithSkipOptions
+  ): AST.Token | null
+  getTokensAfter(
+    node: VNODE.HasLocation,
+    options?: SourceCode.CursorWithCountOptions
+  ): AST.Token[]
+  getFirstTokenBetween(
+    left: VNODE.HasLocation,
+    right: VNODE.HasLocation,
+    options?: SourceCode.CursorWithSkipOptions
+  ): AST.Token | null
+  getFirstTokensBetween(
+    left: VNODE.HasLocation,
+    right: VNODE.HasLocation,
+    options?: SourceCode.CursorWithCountOptions
+  ): AST.Token[]
+  getLastTokenBetween(
+    left: VNODE.HasLocation,
+    right: VNODE.HasLocation,
+    options?: SourceCode.CursorWithSkipOptions
+  ): AST.Token | null
+  getLastTokensBetween(
+    left: VNODE.HasLocation,
+    right: VNODE.HasLocation,
+    options?: SourceCode.CursorWithCountOptions
+  ): AST.Token[]
+  getTokensBetween(
+    left: VNODE.HasLocation,
+    right: VNODE.HasLocation,
+    padding?:
+      | number
+      | SourceCode.FilterPredicate
+      | SourceCode.CursorWithCountOptions
+  ): AST.Token[]
+  getTokens(
+    node: VNODE.HasLocation,
+    beforeCount?: number,
+    afterCount?: number
+  ): AST.Token[]
+  getTokens(
+    node: VNODE.HasLocation,
+    options: SourceCode.FilterPredicate | SourceCode.CursorWithCountOptions
+  ): AST.Token[]
+  commentsExistBetween(
+    left: VNODE.HasLocation,
+    right: VNODE.HasLocation
+  ): boolean
+  getCommentsBefore(nodeOrToken: VNODE.HasLocation): VNODE.Comment[]
+  getCommentsAfter(nodeOrToken: VNODE.HasLocation): VNODE.Comment[]
+  getCommentsInside(node: VNODE.HasLocation): VNODE.Comment[]
+}
+export namespace SourceCode {
+  interface Config {
+    text: string
+    ast: AST.Program
+    parserServices?: ParserServices
+    scopeManager?: Scope.ScopeManager
+    visitorKeys?: VisitorKeys
+  }
+
+  type ParserServices = parserServices.ParserServices
+
+  interface VisitorKeys {
+    [nodeType: string]: string[]
+  }
+
+  type FilterPredicate = (tokenOrComment: AST.Token) => boolean
+
+  type CursorWithSkipOptions =
+    | number
+    | FilterPredicate
+    | {
+        includeComments?: boolean
+        filter?: FilterPredicate
+        skip?: number
+      }
+
+  type CursorWithCountOptions =
+    | number
+    | FilterPredicate
+    | {
+        includeComments?: boolean
+        filter?: FilterPredicate
+        count?: number
+      }
+}
+
+export namespace Rule {
+  interface RuleModule /*extends ESLintRule.RuleModule*/ {
+    meta: RuleMetaData
+    create(context: RuleContext): Rule.RuleListener
+  }
+
+  type NodeTypes = VAST.ESNode['type']
+
+  type NodeListenerBase = {
+    [T in keyof VAST.NodeListenerMap]?: (node: VAST.NodeListenerMap[T]) => void
+  }
+  interface NodeListener extends NodeListenerBase {
+    [key: string]: ((node: VAST.ParamNode) => void) | undefined
+  }
+
+  interface RuleListener extends NodeListenerBase {
+    onCodePathStart?(codePath: CodePath, node: VAST.ParamNode): void
+    onCodePathEnd?(codePath: CodePath, node: VAST.ParamNode): void
+    onCodePathSegmentStart?(
+      segment: CodePathSegment,
+      node: VAST.ParamNode
+    ): void
+    onCodePathSegmentEnd?(segment: CodePathSegment, node: VAST.ParamNode): void
+    onCodePathSegmentLoop?(
+      fromSegment: CodePathSegment,
+      toSegment: CodePathSegment,
+      node: VAST.ParamNode
+    ): void
+    [key: string]:
+      | ((codePath: CodePath, node: VAST.ParamNode) => void)
+      | ((segment: CodePathSegment, node: VAST.ParamNode) => void)
+      | ((
+          fromSegment: CodePathSegment,
+          toSegment: CodePathSegment,
+          node: VAST.ParamNode
+        ) => void)
+      | ((node: VAST.ParamNode) => void)
+      | undefined
+  }
+  interface CodePath extends ESLintRule.CodePath {}
+  interface CodePathSegment extends ESLintRule.CodePathSegment {}
+
+  interface RuleMetaData extends ESLintRule.RuleMetaData {
+    docs: Required<ESLintRule.RuleMetaData>['docs']
+  }
+
+  interface RuleContext {
+    id: string
+    options: ESLintRule.RuleContext['options']
+    settings: { [name: string]: any }
+    parserPath: string
+    parserOptions: any
+    parserServices: parserServices.ParserServices
+
+    getAncestors(): VAST.ESNode[]
+
+    getDeclaredVariables(node: VAST.ESNode): Scope.Variable[]
+    getFilename(): string
+    getScope(): Scope.Scope
+    getSourceCode(): SourceCode
+    markVariableAsUsed(name: string): boolean
+    report(descriptor: ReportDescriptor): void
+  }
+
+  type ReportDescriptor =
+    | ReportDescriptor1
+    | ReportDescriptor2
+    | ReportDescriptor3
+    | ReportDescriptor4
+
+  type SuggestionReportDescriptor =
+    | SuggestionReportDescriptor1
+    | SuggestionReportDescriptor2
+
+  interface RuleFixer {
+    insertTextAfter(nodeOrToken: VNODE.HasLocation, text: string): Fix
+    insertTextAfterRange(range: AST.Range, text: string): Fix
+    insertTextBefore(nodeOrToken: VNODE.HasLocation, text: string): Fix
+    insertTextBeforeRange(range: AST.Range, text: string): Fix
+    remove(nodeOrToken: VNODE.HasLocation): Fix
+    removeRange(range: AST.Range): Fix
+    replaceText(nodeOrToken: VNODE.HasLocation, text: string): Fix
+    replaceTextRange(range: AST.Range, text: string): Fix
+  }
+
+  interface Fix {
+    range: AST.Range
+    text: string
+  }
+}
+
+export class RuleTester extends ESLintRuleTester {}
+
+export namespace Linter {
+  type LintMessage = ESLintLinter.LintMessage
+  type LintOptions = ESLintLinter.LintOptions
+}
+
+interface ReportDescriptorOptionsBase {
+  data?: {
+    [key: string]: string | number
+  }
+  fix?:
+    | null
+    | ((
+        fixer: Rule.RuleFixer
+      ) => null | Rule.Fix | IterableIterator<Rule.Fix> | Rule.Fix[])
+}
+
+interface SuggestionReportDescriptor1 extends ReportDescriptorOptionsBase {
+  desc: string
+}
+
+interface SuggestionReportDescriptor2 extends ReportDescriptorOptionsBase {
+  messageId: string
+}
+interface ReportDescriptorOptions extends ReportDescriptorOptionsBase {
+  suggest?: Rule.SuggestionReportDescriptor[] | null
+}
+
+interface ReportSourceLocation1 {
+  start: VNODE.Position
+  end: VNODE.Position
+  line?: undefined
+  column?: undefined
+}
+
+interface ReportSourceLocation2 extends VNODE.Position {
+  start?: undefined
+  end?: undefined
+}
+
+type ReportSourceLocation = ReportSourceLocation1 | ReportSourceLocation2
+
+interface ReportDescriptor1 extends ReportDescriptorOptions {
+  message: string
+  messageId?: string
+  node: VNODE.HasLocation
+  loc?: ReportSourceLocation
+}
+interface ReportDescriptor2 extends ReportDescriptorOptions {
+  message: string
+  messageId?: string
+  node?: VNODE.HasLocation
+  loc: ReportSourceLocation
+}
+interface ReportDescriptor3 extends ReportDescriptorOptions {
+  message?: string
+  messageId: string
+  node: VNODE.HasLocation
+  loc?: ReportSourceLocation
+}
+interface ReportDescriptor4 extends ReportDescriptorOptions {
+  message?: string
+  messageId: string
+  node?: VNODE.HasLocation
+  loc: ReportSourceLocation
+}
diff --git a/typings/vue-eslint-parser/index.d.ts b/typings/vue-eslint-parser/index.d.ts
new file mode 100644
index 000000000..7343902cf
--- /dev/null
+++ b/typings/vue-eslint-parser/index.d.ts
@@ -0,0 +1,14 @@
+import { VisitorKeys } from 'eslint-visitor-keys'
+import * as VAST from '../eslint-plugin-vue/util-types/ast'
+export namespace AST {
+  function getFallbackKeys(node: VAST.ASTNode): string[]
+  export interface Visitor {
+    visitorKeys?: VisitorKeys
+    enterNode(node: VAST.ASTNode, parent: VAST.ASTNode | null): void
+    leaveNode(node: VAST.ASTNode, parent: VAST.ASTNode | null): void
+  }
+  export function traverseNodes(node: VAST.ASTNode, visitor: Visitor): void
+  export { getFallbackKeys }
+
+  export const NS: VAST.NS
+}