diff --git a/docs/.vuepress/components/eslint-code-block.vue b/docs/.vuepress/components/eslint-code-block.vue
index 381d9985f..3c37c9234 100644
--- a/docs/.vuepress/components/eslint-code-block.vue
+++ b/docs/.vuepress/components/eslint-code-block.vue
@@ -135,6 +135,7 @@ export default {
       linter.defineRule(`vue/${ruleId}`, rules[ruleId])
     }
     linter.defineRule('no-undef', coreRules['no-undef'])
+    linter.defineRule('no-unused-vars', coreRules['no-unused-vars'])
 
     linter.defineParser('vue-eslint-parser', { parseForESLint })
   }
diff --git a/docs/README.md b/docs/README.md
index e19258040..10a5d0d55 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -15,7 +15,7 @@ This plugin allows us to check the `<template>` and `<script>` of `.vue` files w
 ESLint editor integrations are useful to check your code in real-time.
 
 :::warning Status of Vue.js 3.x supports
-This plugin supports the basic syntax of Vue.js 3.0, but the Vue.js 3.0 experimental features `<script setup>` and `<style vars>` are not yet supported. Follow [#1248](https://github.com/vuejs/eslint-plugin-vue/issues/1248) for more details.
+This plugin supports the basic syntax of Vue.js 3.0 and `<script setup>`, but the Vue.js 3.0 experimental feature CSS variable injection is not yet supported. Follow [#1248](https://github.com/vuejs/eslint-plugin-vue/issues/1248) for more details.
 :::
 
 ## :traffic_light: Versioning policy
diff --git a/docs/rules/README.md b/docs/rules/README.md
index a93d5a640..3577668f4 100644
--- a/docs/rules/README.md
+++ b/docs/rules/README.md
@@ -24,8 +24,8 @@ Enforce all the rules in this category, as well as all higher priority rules, wi
 | Rule ID | Description |    |
 |:--------|:------------|:---|
 | [vue/comment-directive](./comment-directive.md) | support comment-directives in `<template>` |  |
-| [vue/experimental-script-setup-vars](./experimental-script-setup-vars.md) | prevent variables defined in `<script setup>` to be marked as undefined |  |
 | [vue/jsx-uses-vars](./jsx-uses-vars.md) | prevent variables used in JSX to be marked as unused |  |
+| [vue/script-setup-uses-vars](./script-setup-uses-vars.md) | prevent `<script setup>` variables used in `<template>` to be marked as unused |  |
 
 ## Priority A: Essential (Error Prevention) <badge text="for Vue.js 3.x" vertical="middle">for Vue.js 3.x</badge>
 
@@ -301,6 +301,7 @@ For example:
 | [vue/no-deprecated-v-is](./no-deprecated-v-is.md) | disallow deprecated `v-is` directive (in Vue.js 3.1.0+) | :wrench: |
 | [vue/no-duplicate-attr-inheritance](./no-duplicate-attr-inheritance.md) | enforce `inheritAttrs` to be set to `false` when using `v-bind="$attrs"` |  |
 | [vue/no-empty-component-block](./no-empty-component-block.md) | disallow the `<template>` `<script>` `<style>` block to be empty |  |
+| [vue/no-export-in-script-setup](./no-export-in-script-setup.md) | disallow `export` in `<script setup>` |  |
 | [vue/no-invalid-model-keys](./no-invalid-model-keys.md) | require valid keys in model option |  |
 | [vue/no-multiple-objects-in-class](./no-multiple-objects-in-class.md) | disallow to pass multiple objects into array to class |  |
 | [vue/no-potential-component-option-typo](./no-potential-component-option-typo.md) | disallow a potential typo in your component property |  |
@@ -331,6 +332,8 @@ For example:
 | [vue/v-for-delimiter-style](./v-for-delimiter-style.md) | enforce `v-for` directive's delimiter style | :wrench: |
 | [vue/v-on-event-hyphenation](./v-on-event-hyphenation.md) | enforce v-on event naming style on custom components in template | :wrench: |
 | [vue/v-on-function-call](./v-on-function-call.md) | enforce or forbid parentheses after method calls without arguments in `v-on` directives | :wrench: |
+| [vue/valid-define-emits](./valid-define-emits.md) | enforce valid `defineEmits` compiler macro |  |
+| [vue/valid-define-props](./valid-define-props.md) | enforce valid `defineProps` compiler macro |  |
 | [vue/valid-next-tick](./valid-next-tick.md) | enforce valid `nextTick` function calls | :wrench: |
 
 ### Extension Rules
@@ -379,5 +382,6 @@ The following rules extend the rules provided by ESLint itself and apply them to
 
 | Rule ID | Replaced by |
 |:--------|:------------|
+| [vue/experimental-script-setup-vars](./experimental-script-setup-vars.md) | (no replacement) |
 | [vue/name-property-casing](./name-property-casing.md) | [vue/component-definition-name-casing](./component-definition-name-casing.md) |
 | [vue/no-confusing-v-for-v-if](./no-confusing-v-for-v-if.md) | [vue/no-use-v-if-with-v-for](./no-use-v-if-with-v-for.md) |
diff --git a/docs/rules/experimental-script-setup-vars.md b/docs/rules/experimental-script-setup-vars.md
index 9608384a1..14735e5e3 100644
--- a/docs/rules/experimental-script-setup-vars.md
+++ b/docs/rules/experimental-script-setup-vars.md
@@ -9,7 +9,7 @@ since: v7.0.0
 
 > prevent variables defined in `<script setup>` to be marked as undefined
 
-- :gear: This rule is included in all of `"plugin:vue/base"`, `"plugin:vue/essential"`, `"plugin:vue/vue3-essential"`, `"plugin:vue/strongly-recommended"`, `"plugin:vue/vue3-strongly-recommended"`, `"plugin:vue/recommended"` and `"plugin:vue/vue3-recommended"`.
+- :warning: This rule was **deprecated**.
 
 :::warning
 This rule is an experimental rule. It may be removed without notice.
@@ -19,6 +19,10 @@ This rule will find variables defined in `<script setup="args">` and mark them a
 
 This rule only has an effect when the `no-undef` rule is enabled.
 
+:::warning
+`<script setup="args">` syntax wasn't rejected by Vue's RFC. Check out the [new syntax](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0040-script-setup.md).
+:::
+
 ## :book: Rule Details
 
 Without this rule this code triggers warning:
diff --git a/docs/rules/jsx-uses-vars.md b/docs/rules/jsx-uses-vars.md
index eaad85593..a21279b10 100644
--- a/docs/rules/jsx-uses-vars.md
+++ b/docs/rules/jsx-uses-vars.md
@@ -38,6 +38,11 @@ After turning on, `HelloWorld` is being marked as used and `no-unused-vars` rule
 
 If you are not using JSX or if you do not use the `no-unused-vars` rule then you can disable this rule.
 
+## :couple: Related Rules
+
+- [vue/script-setup-uses-vars](./script-setup-uses-vars.md)
+- [no-unused-vars](https://eslint.org/docs/rules/no-unused-vars)
+
 ## :rocket: Version
 
 This rule was introduced in eslint-plugin-vue v2.0.0
diff --git a/docs/rules/no-export-in-script-setup.md b/docs/rules/no-export-in-script-setup.md
new file mode 100644
index 000000000..709131f64
--- /dev/null
+++ b/docs/rules/no-export-in-script-setup.md
@@ -0,0 +1,58 @@
+---
+pageClass: rule-details
+sidebarDepth: 0
+title: vue/no-export-in-script-setup
+description: disallow `export` in `<script setup>`
+since: v7.13.0
+---
+# vue/no-export-in-script-setup
+
+> disallow `export` in `<script setup>`
+
+## :book: Rule Details
+
+This rule warns ES module exports in `<script setup>`.
+
+The previous version of `<script setup>` RFC used `export` to define variables used in templates, but the new `<script setup>` RFC has been updated to define without using `export`.
+See [Vue RFCs - 0040-script-setup] for more details.
+
+<eslint-code-block :rules="{'vue/no-export-in-script-setup': ['error']}">
+
+```vue
+<script setup>
+/* ✓ GOOD */
+let msg = 'Hello!'
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/no-export-in-script-setup': ['error']}">
+
+```vue
+<script setup>
+/* ✗ BAD */
+export let msg = 'Hello!'
+</script>
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :books: Further Reading
+
+- [Vue RFCs - 0040-script-setup]
+
+[Vue RFCs - 0040-script-setup]: https://github.com/vuejs/rfcs/blob/master/active-rfcs/0040-script-setup.md
+
+## :rocket: Version
+
+This rule was introduced in eslint-plugin-vue v7.13.0
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/no-export-in-script-setup.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/no-export-in-script-setup.js)
diff --git a/docs/rules/no-unsupported-features.md b/docs/rules/no-unsupported-features.md
index 3d29d0c7f..48e222a99 100644
--- a/docs/rules/no-unsupported-features.md
+++ b/docs/rules/no-unsupported-features.md
@@ -32,6 +32,7 @@ The `"ignores"` option accepts an array of the following strings.
   - Vue.js 3.1.0+
     - `"is-attribute-with-vue-prefix"` ... [`is` attribute with `vue:` prefix](https://v3.vuejs.org/api/special-attributes.html#is)
   - Vue.js 3.0.0+
+    - `"script-setup"` ... [`<script setup>`][Vue RFCs - 0040-script-setup]
     - `"v-model-argument"` ... [argument on `v-model`][Vue RFCs - 0005-replace-v-bind-sync-with-v-model-argument]
     - `"v-model-custom-modifiers"` ... [custom modifiers on `v-model`][Vue RFCs - 0011-v-model-api-change]
     - `"v-is"` ... [v-is](https://v3.vuejs.org/api/directives.html#v-is) directive.
@@ -105,6 +106,7 @@ The `"ignores"` option accepts an array of the following strings.
 - [Vue RFCs - 0003-dynamic-directive-arguments]
 - [Vue RFCs - 0005-replace-v-bind-sync-with-v-model-argument]
 - [Vue RFCs - 0011-v-model-api-change]
+- [Vue RFCs - 0040-script-setup]
 - [Vue RFCs - v-bind .prop shorthand proposal]
 
 [Vue RFCs - 0001-new-slot-syntax]: https://github.com/vuejs/rfcs/blob/master/active-rfcs/0001-new-slot-syntax.md
@@ -112,6 +114,7 @@ The `"ignores"` option accepts an array of the following strings.
 [Vue RFCs - 0003-dynamic-directive-arguments]: https://github.com/vuejs/rfcs/blob/master/active-rfcs/0003-dynamic-directive-arguments.md
 [Vue RFCs - 0005-replace-v-bind-sync-with-v-model-argument]: https://github.com/vuejs/rfcs/blob/master/active-rfcs/0005-replace-v-bind-sync-with-v-model-argument.md
 [Vue RFCs - 0011-v-model-api-change]: https://github.com/vuejs/rfcs/blob/master/active-rfcs/0011-v-model-api-change.md
+[Vue RFCs - 0040-script-setup]: https://github.com/vuejs/rfcs/blob/master/active-rfcs/0040-script-setup.md
 
 [Vue RFCs - v-bind .prop shorthand proposal]: https://github.com/vuejs/rfcs/pull/18
 
diff --git a/docs/rules/script-setup-uses-vars.md b/docs/rules/script-setup-uses-vars.md
new file mode 100644
index 000000000..42de582bd
--- /dev/null
+++ b/docs/rules/script-setup-uses-vars.md
@@ -0,0 +1,68 @@
+---
+pageClass: rule-details
+sidebarDepth: 0
+title: vue/script-setup-uses-vars
+description: prevent `<script setup>` variables used in `<template>` to be marked as unused
+since: v7.13.0
+---
+# vue/script-setup-uses-vars
+
+> prevent `<script setup>` variables used in `<template>` to be marked as unused
+
+- :gear: This rule is included in all of `"plugin:vue/base"`, `"plugin:vue/essential"`, `"plugin:vue/vue3-essential"`, `"plugin:vue/strongly-recommended"`, `"plugin:vue/vue3-strongly-recommended"`, `"plugin:vue/recommended"` and `"plugin:vue/vue3-recommended"`.
+
+ESLint `no-unused-vars` rule does not detect variables in `<script setup>` used in `<template>`.
+This rule will find variables in `<script setup>` used in `<template>` and mark them as used.
+
+This rule only has an effect when the `no-unused-vars` rule is enabled.
+
+## :book: Rule Details
+
+Without this rule this code triggers warning:
+
+<eslint-code-block :rules="{'vue/script-setup-uses-vars': ['error'], 'no-unused-vars': ['error']}">
+
+```vue
+<script setup>
+  // imported components are also directly usable in template
+  import Foo from './Foo.vue'
+  import { ref } from 'vue'
+
+  // write Composition API code just like in a normal setup()
+  // but no need to manually return everything
+  const count = ref(0)
+  const inc = () => {
+    count.value++
+  }
+</script>
+
+<template>
+  <Foo :count="count" @click="inc" />
+</template>
+```
+
+</eslint-code-block>
+
+After turning on, `Foo` is being marked as used and `no-unused-vars` rule doesn't report an issue.
+
+## :mute: When Not To Use It
+
+If you are not using `<script setup>` or if you do not use the `no-unused-vars` rule then you can disable this rule.
+
+## :couple: Related Rules
+
+- [vue/jsx-uses-vars](./jsx-uses-vars.md)
+- [no-unused-vars](https://eslint.org/docs/rules/no-unused-vars)
+
+## :books: Further Reading
+
+- [Vue RFCs - 0040-script-setup](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0040-script-setup.md)
+
+## :rocket: Version
+
+This rule was introduced in eslint-plugin-vue v7.13.0
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/script-setup-uses-vars.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/script-setup-uses-vars.js)
diff --git a/docs/rules/valid-define-emits.md b/docs/rules/valid-define-emits.md
new file mode 100644
index 000000000..8d27d1c63
--- /dev/null
+++ b/docs/rules/valid-define-emits.md
@@ -0,0 +1,136 @@
+---
+pageClass: rule-details
+sidebarDepth: 0
+title: vue/valid-define-emits
+description: enforce valid `defineEmits` compiler macro
+since: v7.13.0
+---
+# vue/valid-define-emits
+
+> enforce valid `defineEmits` compiler macro
+
+This rule checks whether `defineEmits` compiler macro is valid.
+
+## :book: Rule Details
+
+This rule reports `defineEmits` compiler macros in the following cases:
+
+- `defineEmits` are referencing locally declared variables.
+- `defineEmits` has both a literal type and an argument. e.g. `defineEmits<(e: 'foo')=>void>(['bar'])`
+- `defineEmits` has been called multiple times.
+- Custom events are defined in both `defineEmits` and `export default {}`.
+- Custom events are not defined in either `defineEmits` or `export default {}`.
+
+<eslint-code-block :rules="{'vue/valid-define-emits': ['error']}">
+
+```vue
+<script setup>
+  /* ✓ GOOD */
+  defineEmits({ notify: null })
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/valid-define-emits': ['error']}">
+
+```vue
+<script setup>
+  /* ✓ GOOD */
+  defineEmits(['notify'])
+</script>
+```
+
+</eslint-code-block>
+
+```vue
+<script setup lang="ts">
+  /* ✓ GOOD */
+  defineEmits<(e: 'notify')=>void>()
+</script>
+```
+
+<eslint-code-block :rules="{'vue/valid-define-emits': ['error']}">
+
+```vue
+<script>
+  const def = { notify: null }
+</script>
+<script setup>
+  /* ✓ GOOD */
+  defineEmits(def)
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/valid-define-emits': ['error']}">
+
+```vue
+<script setup>
+  /* ✗ BAD */
+  const def = { notify: null }
+  defineEmits(def)
+</script>
+```
+
+</eslint-code-block>
+
+```vue
+<script setup lang="ts">
+  /* ✗ BAD */
+  defineEmits<(e: 'notify')=>void>({ submit: null })
+</script>
+```
+
+<eslint-code-block :rules="{'vue/valid-define-emits': ['error']}">
+
+```vue
+<script setup>
+  /* ✗ BAD */
+  defineEmits({ notify: null })
+  defineEmits({ submit: null })
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/valid-define-emits': ['error']}">
+
+```vue
+<script>
+  export default {
+    emits: { notify: null }
+  }
+</script>
+<script setup>
+  /* ✗ BAD */
+  defineEmits({ submit: null })
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/valid-define-emits': ['error']}">
+
+```vue
+<script setup>
+  /* ✗ BAD */
+  defineEmits()
+</script>
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :rocket: Version
+
+This rule was introduced in eslint-plugin-vue v7.13.0
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/valid-define-emits.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/valid-define-emits.js)
diff --git a/docs/rules/valid-define-props.md b/docs/rules/valid-define-props.md
new file mode 100644
index 000000000..91265eb6a
--- /dev/null
+++ b/docs/rules/valid-define-props.md
@@ -0,0 +1,136 @@
+---
+pageClass: rule-details
+sidebarDepth: 0
+title: vue/valid-define-props
+description: enforce valid `defineProps` compiler macro
+since: v7.13.0
+---
+# vue/valid-define-props
+
+> enforce valid `defineProps` compiler macro
+
+This rule checks whether `defineProps` compiler macro is valid.
+
+## :book: Rule Details
+
+This rule reports `defineProps` compiler macros in the following cases:
+
+- `defineProps` are referencing locally declared variables.
+- `defineProps` has both a literal type and an argument. e.g. `defineProps<{/*props*/}>({/*props*/})`
+- `defineProps` has been called multiple times.
+- Props are defined in both `defineProps` and `export default {}`.
+- Props are not defined in either `defineProps` or `export default {}`.
+
+<eslint-code-block :rules="{'vue/valid-define-props': ['error']}">
+
+```vue
+<script setup>
+  /* ✓ GOOD */
+  defineProps({ msg: String })
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/valid-define-props': ['error']}">
+
+```vue
+<script setup>
+  /* ✓ GOOD */
+  defineProps(['msg'])
+</script>
+```
+
+</eslint-code-block>
+
+```vue
+<script setup lang="ts">
+  /* ✓ GOOD */
+  defineProps<{ msg?:string }>()
+</script>
+```
+
+<eslint-code-block :rules="{'vue/valid-define-props': ['error']}">
+
+```vue
+<script>
+  const def = { msg: String }
+</script>
+<script setup>
+  /* ✓ GOOD */
+  defineProps(def)
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/valid-define-props': ['error']}">
+
+```vue
+<script setup>
+  /* ✗ BAD */
+  const def = { msg: String }
+  defineProps(def)
+</script>
+```
+
+</eslint-code-block>
+
+```vue
+<script setup lang="ts">
+  /* ✗ BAD */
+  defineProps<{ msg?:string }>({ msg: String })
+</script>
+```
+
+<eslint-code-block :rules="{'vue/valid-define-props': ['error']}">
+
+```vue
+<script setup>
+  /* ✗ BAD */
+  defineProps({ msg: String })
+  defineProps({ count: Number })
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/valid-define-props': ['error']}">
+
+```vue
+<script>
+  export default {
+    props: { msg: String }
+  }
+</script>
+<script setup>
+  /* ✗ BAD */
+  defineProps({ count: Number })
+</script>
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/valid-define-props': ['error']}">
+
+```vue
+<script setup>
+  /* ✗ BAD */
+  defineProps()
+</script>
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :rocket: Version
+
+This rule was introduced in eslint-plugin-vue v7.13.0
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/valid-define-props.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/valid-define-props.js)
diff --git a/docs/user-guide/README.md b/docs/user-guide/README.md
index 45a3b72ac..f6dc47456 100644
--- a/docs/user-guide/README.md
+++ b/docs/user-guide/README.md
@@ -72,7 +72,7 @@ By default all rules from **base** and **essential** categories report ESLint er
 :::
 
 :::warning Status of Vue.js 3.x supports
-This plugin supports the basic syntax of Vue.js 3.0, but the Vue.js 3.0 experimental features `<script setup>` and `<style vars>` are not yet supported. Follow [#1248](https://github.com/vuejs/eslint-plugin-vue/issues/1248) for more details.
+This plugin supports the basic syntax of Vue.js 3.0 and `<script setup>`, but the Vue.js 3.0 experimental feature CSS variable injection is not yet supported. Follow [#1248](https://github.com/vuejs/eslint-plugin-vue/issues/1248) for more details.
 :::
 
 ### Running ESLint from the command line
@@ -103,6 +103,8 @@ If you want to use custom parsers such as [babel-eslint](https://www.npmjs.com/p
   }
 ```
 
+The `parserOptions.parser` option can also specify an object to specify multiple parsers. See [vue-eslint-parser README](https://github.com/vuejs/vue-eslint-parser#readme) for more details.
+
 ### How does ESLint detect components?
 
 All component-related rules are applied to code that passes any of the following checks:
@@ -333,3 +335,84 @@ Note that you cannot use angle-bracket type assertion style (`var x = <foo>bar;`
 You need to turn off Vetur's template validation by adding `vetur.validation.template: false` to your `.vscode/settings.json`.
 
 See also: "[Visual Studio Code](#editor-integrations)" section and [Vetur - Linting](https://vuejs.github.io/vetur/guide/linting-error.html#linting).
+
+### Does not work well with `<script setup>`
+
+#### The variables used in the `<template>` are warned by `no-unused-vars` rule
+
+You must use [vue/script-setup-uses-vars](../rules/script-setup-uses-vars.md) rule.  
+In your configuration, use the rule set provided by `eslint-plugin-vue` or enable it rule.
+
+Example **.eslintrc.js**:
+
+```js
+module.exports = {
+  // Use the rule set.
+  extends: ['plugin:vue/base'],
+  rules: {
+    // Enable vue/script-setup-uses-vars rule
+    'vue/script-setup-uses-vars': 'error',
+  }
+}
+```
+
+#### Compiler macros such as `defineProps` and `defineEmits` are warned by `no-undef` rule
+
+You need to define [global variables](https://eslint.org/docs/user-guide/configuring/language-options#using-configuration-files-1) in your ESLint configuration file.  
+If you don't want to define global variables, use `import { defineProps, defineEmits } from 'vue'`.
+
+Example **.eslintrc.js**:
+
+```js
+module.exports = {
+  globals: {
+    defineProps: "readonly",
+    defineEmits: "readonly",
+    defineExpose: "readonly",
+    withDefaults: "readonly"
+  }
+}
+```
+
+See also [ESLint - Specifying Globals > Using configuration files](https://eslint.org/docs/user-guide/configuring/language-options#using-configuration-files-1).
+
+#### Parsing error with Top Level `await`
+
+##### Using ESLint <= v7.x
+
+The parser `espree` that comes with `ESLint` v7.x doesn't understand the syntax of ES2022, so it can't parse the Top Level `await` either.  
+However, `espree` v8+ can understand the syntax of ES2022 and parse the Top Level `await`.  
+You install `espree` v8+ and specify `"espree"` and ES2022 in your configuration, the parser will be able to parse it.
+
+```js
+module.exports = {
+  parser: 'vue-eslint-parser',
+  parserOptions: {
+    parser: 'espree', // <-
+    ecmaVersion: 2022, // <-
+    sourceType: 'module'
+  },
+}
+```
+
+However, note that the AST generated by `espree` v8+ may not work well with some rules of `ESLint` v7.x.
+
+<!--
+##### Using ESLint >= v8.x
+
+You need to specify `2022` for `parserOptions.ecmaVersion`.
+
+```js
+module.exports = {
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: 'module'
+  },
+}
+```
+-->
+
+#### Other Problems
+
+Try searching for existing issues.
+If it does not exist, you should open a new issue and share your repository to reproduce the issue.
diff --git a/lib/configs/base.js b/lib/configs/base.js
index eb129643f..5b1135b41 100644
--- a/lib/configs/base.js
+++ b/lib/configs/base.js
@@ -16,7 +16,7 @@ module.exports = {
   plugins: ['vue'],
   rules: {
     'vue/comment-directive': 'error',
-    'vue/experimental-script-setup-vars': 'error',
-    'vue/jsx-uses-vars': 'error'
+    'vue/jsx-uses-vars': 'error',
+    'vue/script-setup-uses-vars': 'error'
   }
 }
diff --git a/lib/index.js b/lib/index.js
index 313cc6930..8bf6cad45 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -81,6 +81,7 @@ module.exports = {
     'no-duplicate-attributes': require('./rules/no-duplicate-attributes'),
     'no-empty-component-block': require('./rules/no-empty-component-block'),
     'no-empty-pattern': require('./rules/no-empty-pattern'),
+    'no-export-in-script-setup': require('./rules/no-export-in-script-setup'),
     'no-extra-parens': require('./rules/no-extra-parens'),
     'no-invalid-model-keys': require('./rules/no-invalid-model-keys'),
     'no-irregular-whitespace': require('./rules/no-irregular-whitespace'),
@@ -155,6 +156,7 @@ module.exports = {
     'return-in-computed-property': require('./rules/return-in-computed-property'),
     'return-in-emits-validator': require('./rules/return-in-emits-validator'),
     'script-indent': require('./rules/script-indent'),
+    'script-setup-uses-vars': require('./rules/script-setup-uses-vars'),
     'singleline-html-element-content-newline': require('./rules/singleline-html-element-content-newline'),
     'sort-keys': require('./rules/sort-keys'),
     'space-in-parens': require('./rules/space-in-parens'),
@@ -170,6 +172,8 @@ module.exports = {
     'v-on-function-call': require('./rules/v-on-function-call'),
     'v-on-style': require('./rules/v-on-style'),
     'v-slot-style': require('./rules/v-slot-style'),
+    'valid-define-emits': require('./rules/valid-define-emits'),
+    'valid-define-props': require('./rules/valid-define-props'),
     'valid-next-tick': require('./rules/valid-next-tick'),
     'valid-template-root': require('./rules/valid-template-root'),
     'valid-v-bind-sync': require('./rules/valid-v-bind-sync'),
diff --git a/lib/rules/custom-event-name-casing.js b/lib/rules/custom-event-name-casing.js
index 39d9436e7..f59fa9c2a 100644
--- a/lib/rules/custom-event-name-casing.js
+++ b/lib/rules/custom-event-name-casing.js
@@ -13,6 +13,10 @@ const utils = require('../utils')
 const casing = require('../utils/casing')
 const { toRegExp } = require('../utils/regexp')
 
+/**
+ * @typedef {import('../utils').VueObjectData} VueObjectData
+ */
+
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
@@ -103,7 +107,7 @@ module.exports = {
   },
   /** @param {RuleContext} context */
   create(context) {
-    /** @type {Map<ObjectExpression, {contextReferenceIds:Set<Identifier>,emitReferenceIds:Set<Identifier>}>} */
+    /** @type {Map<ObjectExpression|Program, {contextReferenceIds:Set<Identifier>,emitReferenceIds:Set<Identifier>}>} */
     const setupContexts = new Map()
     const options =
       context.options.length === 1 && typeof context.options[0] !== 'string'
@@ -143,6 +147,46 @@ module.exports = {
       })
     }
 
+    const programNode = context.getSourceCode().ast
+
+    const callVisitor = {
+      /**
+       * @param {CallExpression} node
+       * @param {VueObjectData} [info]
+       */
+      CallExpression(node, info) {
+        const nameLiteralNode = getNameParamNode(node)
+        if (!nameLiteralNode) {
+          // cannot check
+          return
+        }
+
+        // verify setup context
+        const setupContext = setupContexts.get(info ? info.node : programNode)
+        if (setupContext) {
+          const { contextReferenceIds, emitReferenceIds } = setupContext
+          if (
+            node.callee.type === 'Identifier' &&
+            emitReferenceIds.has(node.callee)
+          ) {
+            // verify setup(props,{emit}) {emit()}
+            verify(nameLiteralNode)
+          } else {
+            const emit = getCalleeMemberNode(node)
+            if (
+              emit &&
+              emit.name === 'emit' &&
+              emit.member.object.type === 'Identifier' &&
+              contextReferenceIds.has(emit.member.object)
+            ) {
+              // verify setup(props,context) {context.emit()}
+              verify(nameLiteralNode)
+            }
+          }
+        }
+      }
+    }
+
     return utils.defineTemplateBodyVisitor(
       context,
       {
@@ -159,6 +203,36 @@ module.exports = {
         }
       },
       utils.compositingVisitors(
+        utils.defineScriptSetupVisitor(context, {
+          onDefineEmitsEnter(node) {
+            if (
+              !node.parent ||
+              node.parent.type !== 'VariableDeclarator' ||
+              node.parent.init !== node
+            ) {
+              return
+            }
+
+            const emitParam = node.parent.id
+            if (emitParam.type !== 'Identifier') {
+              return
+            }
+            // const emit = defineEmits()
+            const variable = findVariable(context.getScope(), emitParam)
+            if (!variable) {
+              return
+            }
+            const emitReferenceIds = new Set()
+            for (const reference of variable.references) {
+              emitReferenceIds.add(reference.identifier)
+            }
+            setupContexts.set(programNode, {
+              contextReferenceIds: new Set(),
+              emitReferenceIds
+            })
+          },
+          ...callVisitor
+        }),
         utils.defineVueVisitor(context, {
           onSetupFunctionEnter(node, { node: vueNode }) {
             const contextParam = utils.skipDefaultParamValue(node.params[1])
@@ -207,37 +281,7 @@ module.exports = {
               emitReferenceIds
             })
           },
-          CallExpression(node, { node: vueNode }) {
-            const nameLiteralNode = getNameParamNode(node)
-            if (!nameLiteralNode) {
-              // cannot check
-              return
-            }
-
-            // verify setup context
-            const setupContext = setupContexts.get(vueNode)
-            if (setupContext) {
-              const { contextReferenceIds, emitReferenceIds } = setupContext
-              if (
-                node.callee.type === 'Identifier' &&
-                emitReferenceIds.has(node.callee)
-              ) {
-                // verify setup(props,{emit}) {emit()}
-                verify(nameLiteralNode)
-              } else {
-                const emit = getCalleeMemberNode(node)
-                if (
-                  emit &&
-                  emit.name === 'emit' &&
-                  emit.member.object.type === 'Identifier' &&
-                  contextReferenceIds.has(emit.member.object)
-                ) {
-                  // verify setup(props,context) {context.emit()}
-                  verify(nameLiteralNode)
-                }
-              }
-            }
-          },
+          ...callVisitor,
           onVueObjectExit(node) {
             setupContexts.delete(node)
           }
diff --git a/lib/rules/experimental-script-setup-vars.js b/lib/rules/experimental-script-setup-vars.js
index d215a27b9..b7fa2a810 100644
--- a/lib/rules/experimental-script-setup-vars.js
+++ b/lib/rules/experimental-script-setup-vars.js
@@ -21,9 +21,10 @@ module.exports = {
     docs: {
       description:
         'prevent variables defined in `<script setup>` to be marked as undefined', // eslint-disable-line consistent-docs-description
-      categories: ['base'],
+      categories: undefined,
       url: 'https://eslint.vuejs.org/rules/experimental-script-setup-vars.html'
     },
+    deprecated: true,
     schema: []
   },
   /**
diff --git a/lib/rules/no-async-in-computed-properties.js b/lib/rules/no-async-in-computed-properties.js
index b12fa3407..b405c0475 100644
--- a/lib/rules/no-async-in-computed-properties.js
+++ b/lib/rules/no-async-in-computed-properties.js
@@ -8,6 +8,7 @@ const utils = require('../utils')
 
 /**
  * @typedef {import('../utils').VueObjectData} VueObjectData
+ * @typedef {import('../utils').VueVisitor} VueVisitor
  * @typedef {import('../utils').ComponentComputedProperty} ComponentComputedProperty
  */
 
@@ -97,11 +98,16 @@ module.exports = {
 
     /**
      * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
-     * @param {VueObjectData} data
+     * @param {VueObjectData|undefined} [info]
      */
-    function onFunctionEnter(node, { node: vueNode }) {
+    function onFunctionEnter(node, info) {
       if (node.async) {
-        verify(node, node.body, 'async', computedPropertiesMap.get(vueNode))
+        verify(
+          node,
+          node.body,
+          'async',
+          info ? computedPropertiesMap.get(info.node) : null
+        )
       }
 
       scopeStack = {
@@ -118,10 +124,10 @@ module.exports = {
      * @param {ESNode} node
      * @param {BlockStatement | Expression} targetBody
      * @param {keyof expressionTypes} type
-     * @param {ComponentComputedProperty[]} computedProperties
+     * @param {ComponentComputedProperty[]|undefined|null} computedProperties
      */
-    function verify(node, targetBody, type, computedProperties = []) {
-      for (const cp of computedProperties) {
+    function verify(node, targetBody, type, computedProperties) {
+      for (const cp of computedProperties || []) {
         if (
           cp.value &&
           node.loc.start.line >= cp.value.loc.start.line &&
@@ -158,7 +164,74 @@ module.exports = {
         }
       }
     }
-    return Object.assign(
+    const nodeVisitor = {
+      ':function': onFunctionEnter,
+      ':function:exit': onFunctionExit,
+
+      /**
+       * @param {NewExpression} node
+       * @param {VueObjectData|undefined} [info]
+       */
+      NewExpression(node, info) {
+        if (!scopeStack) {
+          return
+        }
+        if (
+          node.callee.type === 'Identifier' &&
+          node.callee.name === 'Promise'
+        ) {
+          verify(
+            node,
+            scopeStack.body,
+            'new',
+            info ? computedPropertiesMap.get(info.node) : null
+          )
+        }
+      },
+
+      /**
+       * @param {CallExpression} node
+       * @param {VueObjectData|undefined} [info]
+       */
+      CallExpression(node, info) {
+        if (!scopeStack) {
+          return
+        }
+        if (isPromise(node)) {
+          verify(
+            node,
+            scopeStack.body,
+            'promise',
+            info ? computedPropertiesMap.get(info.node) : null
+          )
+        } else if (isTimedFunction(node)) {
+          verify(
+            node,
+            scopeStack.body,
+            'timed',
+            info ? computedPropertiesMap.get(info.node) : null
+          )
+        }
+      },
+
+      /**
+       * @param {AwaitExpression} node
+       * @param {VueObjectData|undefined} [info]
+       */
+      AwaitExpression(node, info) {
+        if (!scopeStack) {
+          return
+        }
+        verify(
+          node,
+          scopeStack.body,
+          'await',
+          info ? computedPropertiesMap.get(info.node) : null
+        )
+      }
+    }
+
+    return utils.compositingVisitors(
       {
         Program() {
           const tracker = new ReferenceTracker(context.getScope())
@@ -181,63 +254,14 @@ module.exports = {
           }
         }
       },
-      utils.defineVueVisitor(context, {
-        onVueObjectEnter(node) {
-          computedPropertiesMap.set(node, utils.getComputedProperties(node))
-        },
-        ':function': onFunctionEnter,
-        ':function:exit': onFunctionExit,
-
-        NewExpression(node, { node: vueNode }) {
-          if (!scopeStack) {
-            return
-          }
-          if (
-            node.callee.type === 'Identifier' &&
-            node.callee.name === 'Promise'
-          ) {
-            verify(
-              node,
-              scopeStack.body,
-              'new',
-              computedPropertiesMap.get(vueNode)
-            )
-          }
-        },
-
-        CallExpression(node, { node: vueNode }) {
-          if (!scopeStack) {
-            return
-          }
-          if (isPromise(node)) {
-            verify(
-              node,
-              scopeStack.body,
-              'promise',
-              computedPropertiesMap.get(vueNode)
-            )
-          } else if (isTimedFunction(node)) {
-            verify(
-              node,
-              scopeStack.body,
-              'timed',
-              computedPropertiesMap.get(vueNode)
-            )
-          }
-        },
-
-        AwaitExpression(node, { node: vueNode }) {
-          if (!scopeStack) {
-            return
-          }
-          verify(
-            node,
-            scopeStack.body,
-            'await',
-            computedPropertiesMap.get(vueNode)
-          )
-        }
-      })
+      utils.isScriptSetup(context)
+        ? utils.defineScriptSetupVisitor(context, nodeVisitor)
+        : utils.defineVueVisitor(context, {
+            onVueObjectEnter(node) {
+              computedPropertiesMap.set(node, utils.getComputedProperties(node))
+            },
+            ...nodeVisitor
+          })
     )
   }
 }
diff --git a/lib/rules/no-boolean-default.js b/lib/rules/no-boolean-default.js
index e278e3011..6b1f44e74 100644
--- a/lib/rules/no-boolean-default.js
+++ b/lib/rules/no-boolean-default.js
@@ -9,6 +9,7 @@ const utils = require('../utils')
 /**
  * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
  * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ * @typedef {import('../utils').ComponentTypeProp} ComponentTypeProp
  */
 
 // ------------------------------------------------------------------------------
@@ -29,31 +30,10 @@ function isBooleanProp(prop) {
 }
 
 /**
- * @typedef {ComponentObjectProp & { value : ObjectExpression }} ObjectExpressionProp
+ * @param {ObjectExpression} propDefValue
  */
-
-/**
- * @param {(ComponentArrayProp | ComponentObjectProp)[]} props
- * @returns {ObjectExpressionProp[]}
- */
-function getBooleanProps(props) {
-  return props.filter(
-    /**
-     * @param {ComponentArrayProp | ComponentObjectProp} prop
-     * @returns {prop is ObjectExpressionProp}
-     */
-    (prop) =>
-      prop.value != null &&
-      prop.value.type === 'ObjectExpression' &&
-      prop.value.properties.some(isBooleanProp)
-  )
-}
-
-/**
- * @param {ObjectExpressionProp} propDef
- */
-function getDefaultNode(propDef) {
-  return utils.findProperty(propDef.value, 'default')
+function getDefaultNode(propDefValue) {
+  return utils.findProperty(propDefValue, 'default')
 }
 
 module.exports = {
@@ -73,42 +53,78 @@ module.exports = {
   },
   /** @param {RuleContext} context */
   create(context) {
-    return utils.executeOnVueComponent(context, (obj) => {
-      const props = utils.getComponentProps(obj)
-      const booleanProps = getBooleanProps(props)
-
-      if (!booleanProps.length) return
-
-      const booleanType = context.options[0] || 'no-default'
-
-      booleanProps.forEach((propDef) => {
-        const defaultNode = getDefaultNode(propDef)
+    const booleanType = context.options[0] || 'no-default'
+    /**
+     * @param {ComponentArrayProp | ComponentObjectProp | ComponentTypeProp} prop
+     * @param { { [key: string]: Expression | undefined } } [withDefaultsExpressions]
+     */
+    function processProp(prop, withDefaultsExpressions) {
+      if (prop.type === 'object') {
+        if (prop.value.type !== 'ObjectExpression') {
+          return
+        }
+        if (!prop.value.properties.some(isBooleanProp)) {
+          return
+        }
+        const defaultNode = getDefaultNode(prop.value)
+        if (!defaultNode) {
+          return
+        }
+        verifyDefaultExpression(defaultNode.value)
+      } else if (prop.type === 'type') {
+        if (prop.types.length !== 1 || prop.types[0] !== 'Boolean') {
+          return
+        }
+        const defaultNode =
+          withDefaultsExpressions && withDefaultsExpressions[prop.propName]
         if (!defaultNode) {
           return
         }
+        verifyDefaultExpression(defaultNode)
+      }
+    }
+    /**
+     * @param {(ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]} props
+     * @param { { [key: string]: Expression | undefined } } [withDefaultsExpressions]
+     */
+    function processProps(props, withDefaultsExpressions) {
+      for (const prop of props) {
+        processProp(prop, withDefaultsExpressions)
+      }
+    }
+
+    /**
+     * @param {Expression} defaultNode
+     */
+    function verifyDefaultExpression(defaultNode) {
+      switch (booleanType) {
+        case 'no-default':
+          context.report({
+            node: defaultNode,
+            message:
+              'Boolean prop should not set a default (Vue defaults it to false).'
+          })
+          break
 
-        switch (booleanType) {
-          case 'no-default':
+        case 'default-false':
+          if (defaultNode.type !== 'Literal' || defaultNode.value !== false) {
             context.report({
               node: defaultNode,
-              message:
-                'Boolean prop should not set a default (Vue defaults it to false).'
+              message: 'Boolean prop should only be defaulted to false.'
             })
-            break
-
-          case 'default-false':
-            if (
-              defaultNode.value.type !== 'Literal' ||
-              defaultNode.value.value !== false
-            ) {
-              context.report({
-                node: defaultNode,
-                message: 'Boolean prop should only be defaulted to false.'
-              })
-            }
-            break
+          }
+          break
+      }
+    }
+    return utils.compositingVisitors(
+      utils.executeOnVueComponent(context, (obj) => {
+        processProps(utils.getComponentProps(obj))
+      }),
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(node, props) {
+          processProps(props, utils.getWithDefaultsPropExpressions(node))
         }
       })
-    })
+    )
   }
 }
diff --git a/lib/rules/no-export-in-script-setup.js b/lib/rules/no-export-in-script-setup.js
new file mode 100644
index 000000000..fcd7f316d
--- /dev/null
+++ b/lib/rules/no-export-in-script-setup.js
@@ -0,0 +1,41 @@
+/**
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const utils = require('../utils')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow `export` in `<script setup>`',
+      // TODO Switch in the major version.
+      // categories: ['vue3-essential'],
+      categories: undefined,
+      url: 'https://eslint.vuejs.org/rules/no-export-in-script-setup.html'
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      forbidden: '`<script setup>` cannot contain ES module exports.'
+    }
+  },
+  /** @param {RuleContext} context */
+  create(context) {
+    /** @param {ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration} node */
+    function report(node) {
+      context.report({
+        node,
+        messageId: 'forbidden'
+      })
+    }
+
+    return utils.defineScriptSetupVisitor(context, {
+      ExportAllDeclaration: report,
+      ExportDefaultDeclaration: report,
+      ExportNamedDeclaration: report
+    })
+  }
+}
diff --git a/lib/rules/no-lifecycle-after-await.js b/lib/rules/no-lifecycle-after-await.js
index 7688d5b70..aba61794d 100644
--- a/lib/rules/no-lifecycle-after-await.js
+++ b/lib/rules/no-lifecycle-after-await.js
@@ -41,26 +41,34 @@ module.exports = {
   /** @param {RuleContext} context */
   create(context) {
     /**
-     * @typedef {object} SetupFunctionData
-     * @property {Property} setupProperty
+     * @typedef {object} SetupScopeData
      * @property {boolean} afterAwait
+     * @property {[number,number]} range
      */
     /**
      * @typedef {object} ScopeStack
      * @property {ScopeStack | null} upper
-     * @property {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression} functionNode
+     * @property {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression | Program} scopeNode
      */
     /** @type {Set<ESNode>} */
     const lifecycleHookCallNodes = new Set()
-    /** @type {Map<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, SetupFunctionData>} */
-    const setupFunctions = new Map()
+    /** @type {Map<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression | Program, SetupScopeData>} */
+    const setupScopes = new Map()
 
     /** @type {ScopeStack | null} */
     let scopeStack = null
 
-    return Object.assign(
+    return utils.compositingVisitors(
       {
-        Program() {
+        /**
+         * @param {Program} node
+         */
+        Program(node) {
+          scopeStack = {
+            upper: scopeStack,
+            scopeNode: node
+          }
+
           const tracker = new ReferenceTracker(context.getScope())
           const traceMap = {
             /** @type {TraceMap} */
@@ -77,37 +85,41 @@ module.exports = {
           for (const { node } of tracker.iterateEsmReferences(traceMap)) {
             lifecycleHookCallNodes.add(node)
           }
-        }
-      },
-      utils.defineVueVisitor(context, {
+        },
+        /**
+         * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
+         */
         ':function'(node) {
           scopeStack = {
             upper: scopeStack,
-            functionNode: node
+            scopeNode: node
           }
         },
-        onSetupFunctionEnter(node) {
-          setupFunctions.set(node, {
-            setupProperty: node.parent,
-            afterAwait: false
-          })
+        ':function:exit'() {
+          scopeStack = scopeStack && scopeStack.upper
         },
-        AwaitExpression() {
+        /** @param {AwaitExpression} node */
+        AwaitExpression(node) {
           if (!scopeStack) {
             return
           }
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData) {
+          const setupScope = setupScopes.get(scopeStack.scopeNode)
+          if (!setupScope || !utils.inRange(setupScope.range, node)) {
             return
           }
-          setupFunctionData.afterAwait = true
+          setupScope.afterAwait = true
         },
+        /** @param {CallExpression} node */
         CallExpression(node) {
           if (!scopeStack) {
             return
           }
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData || !setupFunctionData.afterAwait) {
+          const setupScope = setupScopes.get(scopeStack.scopeNode)
+          if (
+            !setupScope ||
+            !setupScope.afterAwait ||
+            !utils.inRange(setupScope.range, node)
+          ) {
             return
           }
 
@@ -121,11 +133,34 @@ module.exports = {
               messageId: 'forbidden'
             })
           }
+        }
+      },
+      (() => {
+        const scriptSetup = utils.getScriptSetupElement(context)
+        if (!scriptSetup) {
+          return {}
+        }
+        return {
+          /**
+           * @param {Program} node
+           */
+          Program(node) {
+            setupScopes.set(node, {
+              afterAwait: false,
+              range: scriptSetup.range
+            })
+          }
+        }
+      })(),
+      utils.defineVueVisitor(context, {
+        onSetupFunctionEnter(node) {
+          setupScopes.set(node, {
+            afterAwait: false,
+            range: node.range
+          })
         },
-        ':function:exit'(node) {
-          scopeStack = scopeStack && scopeStack.upper
-
-          setupFunctions.delete(node)
+        onSetupFunctionExit(node) {
+          setupScopes.delete(node)
         }
       })
     )
diff --git a/lib/rules/no-mutating-props.js b/lib/rules/no-mutating-props.js
index b8eeb17e4..70559026b 100644
--- a/lib/rules/no-mutating-props.js
+++ b/lib/rules/no-mutating-props.js
@@ -26,9 +26,9 @@ module.exports = {
   },
   /** @param {RuleContext} context */
   create(context) {
-    /** @type {Map<ObjectExpression, Set<string>>} */
+    /** @type {Map<ObjectExpression|CallExpression, Set<string>>} */
     const propsMap = new Map()
-    /** @type { { type: 'export' | 'mark' | 'definition', object: ObjectExpression } | null } */
+    /** @type { { type: 'export' | 'mark' | 'definition', object: ObjectExpression } | { type: 'setup', object: CallExpression } | null } */
     let vueObjectData = null
 
     /**
@@ -123,7 +123,7 @@ module.exports = {
      * @param {string[]} path
      * @returns {Generator<{ node: Identifier, path: string[] }>}
      */
-    function* iterateParamProperties(param, path) {
+    function* iteratePatternProperties(param, path) {
       if (!param) {
         return
       }
@@ -133,28 +133,105 @@ module.exports = {
           path
         }
       } else if (param.type === 'RestElement') {
-        yield* iterateParamProperties(param.argument, path)
+        yield* iteratePatternProperties(param.argument, path)
       } else if (param.type === 'AssignmentPattern') {
-        yield* iterateParamProperties(param.left, path)
+        yield* iteratePatternProperties(param.left, path)
       } else if (param.type === 'ObjectPattern') {
         for (const prop of param.properties) {
           if (prop.type === 'Property') {
             const name = getPropertyNameText(prop)
-            yield* iterateParamProperties(prop.value, [...path, name])
+            yield* iteratePatternProperties(prop.value, [...path, name])
           } else if (prop.type === 'RestElement') {
-            yield* iterateParamProperties(prop.argument, path)
+            yield* iteratePatternProperties(prop.argument, path)
           }
         }
       } else if (param.type === 'ArrayPattern') {
         for (let index = 0; index < param.elements.length; index++) {
           const element = param.elements[index]
-          yield* iterateParamProperties(element, [...path, `${index}`])
+          yield* iteratePatternProperties(element, [...path, `${index}`])
         }
       }
     }
 
-    return Object.assign(
+    /**
+     * @param {Identifier} prop
+     * @param {string[]} path
+     */
+    function verifyPropVariable(prop, path) {
+      const variable = findVariable(context.getScope(), prop)
+      if (!variable) {
+        return
+      }
+
+      for (const reference of variable.references) {
+        if (!reference.isRead()) {
+          continue
+        }
+        const id = reference.identifier
+
+        const invalid = utils.findMutating(id)
+        if (!invalid) {
+          continue
+        }
+        let name
+        if (path.length === 0) {
+          if (invalid.pathNodes.length === 0) {
+            continue
+          }
+          const mem = invalid.pathNodes[0]
+          name = getPropertyNameText(mem)
+        } else {
+          if (invalid.pathNodes.length === 0 && invalid.kind !== 'call') {
+            continue
+          }
+          name = path[0]
+        }
+
+        report(invalid.node, name)
+      }
+    }
+
+    return utils.compositingVisitors(
       {},
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(node, props) {
+          const propsSet = new Set(
+            props.map((p) => p.propName).filter(utils.isDef)
+          )
+          propsMap.set(node, propsSet)
+          vueObjectData = {
+            type: 'setup',
+            object: node
+          }
+
+          let target = node
+          if (
+            target.parent &&
+            target.parent.type === 'CallExpression' &&
+            target.parent.arguments[0] === target &&
+            target.parent.callee.type === 'Identifier' &&
+            target.parent.callee.name === 'withDefaults'
+          ) {
+            target = target.parent
+          }
+
+          if (
+            !target.parent ||
+            target.parent.type !== 'VariableDeclarator' ||
+            target.parent.init !== target
+          ) {
+            return
+          }
+
+          for (const { node: prop, path } of iteratePatternProperties(
+            target.parent.id,
+            []
+          )) {
+            verifyPropVariable(prop, path)
+            propsSet.add(prop.name)
+          }
+        }
+      }),
       utils.defineVueVisitor(context, {
         onVueObjectEnter(node) {
           propsMap.set(
@@ -169,7 +246,9 @@ module.exports = {
         },
         onVueObjectExit(node, { type }) {
           if (
-            (!vueObjectData || vueObjectData.type !== 'export') &&
+            (!vueObjectData ||
+              (vueObjectData.type !== 'export' &&
+                vueObjectData.type !== 'setup')) &&
             type !== 'instance'
           ) {
             vueObjectData = {
@@ -191,41 +270,11 @@ module.exports = {
             // cannot check
             return
           }
-          for (const { node: prop, path } of iterateParamProperties(
+          for (const { node: prop, path } of iteratePatternProperties(
             propsParam,
             []
           )) {
-            const variable = findVariable(context.getScope(), prop)
-            if (!variable) {
-              continue
-            }
-
-            for (const reference of variable.references) {
-              if (!reference.isRead()) {
-                continue
-              }
-              const id = reference.identifier
-
-              const invalid = utils.findMutating(id)
-              if (!invalid) {
-                continue
-              }
-              let name
-              if (path.length === 0) {
-                if (invalid.pathNodes.length === 0) {
-                  continue
-                }
-                const mem = invalid.pathNodes[0]
-                name = getPropertyNameText(mem)
-              } else {
-                if (invalid.pathNodes.length === 0 && invalid.kind !== 'call') {
-                  continue
-                }
-                name = path[0]
-              }
-
-              report(invalid.node, name)
-            }
+            verifyPropVariable(prop, path)
           }
         },
         /** @param {(Identifier | ThisExpression) & { parent: MemberExpression } } node */
diff --git a/lib/rules/no-reserved-component-names.js b/lib/rules/no-reserved-component-names.js
index 890f1a306..e32e182c6 100644
--- a/lib/rules/no-reserved-component-names.js
+++ b/lib/rules/no-reserved-component-names.js
@@ -10,6 +10,13 @@ const casing = require('../utils/casing')
 const htmlElements = require('../utils/html-elements.json')
 const deprecatedHtmlElements = require('../utils/deprecated-html-elements.json')
 const svgElements = require('../utils/svg-elements.json')
+const RESERVED_NAMES_IN_VUE = new Set(
+  require('../utils/vue2-builtin-components')
+)
+
+const RESERVED_NAMES_IN_VUE3 = new Set(
+  require('../utils/vue3-builtin-components')
+)
 
 const kebabCaseElements = [
   'annotation-xml',
@@ -22,17 +29,6 @@ const kebabCaseElements = [
   'missing-glyph'
 ]
 
-// https://vuejs.org/v2/api/index.html#Built-In-Components
-const vueBuiltInComponents = [
-  'component',
-  'transition',
-  'transition-group',
-  'keep-alive',
-  'slot'
-]
-
-const vue3BuiltInComponents = ['teleport', 'suspense']
-
 /** @param {string} word  */
 function isLowercase(word) {
   return /^[a-z]*$/.test(word)
@@ -42,15 +38,6 @@ const RESERVED_NAMES_IN_HTML = new Set([
   ...htmlElements,
   ...htmlElements.map(casing.capitalize)
 ])
-const RESERVED_NAMES_IN_VUE = new Set([
-  ...vueBuiltInComponents,
-  ...vueBuiltInComponents.map(casing.pascalCase)
-])
-const RESERVED_NAMES_IN_VUE3 = new Set([
-  ...RESERVED_NAMES_IN_VUE,
-  ...vue3BuiltInComponents,
-  ...vue3BuiltInComponents.map(casing.pascalCase)
-])
 const RESERVED_NAMES_IN_OTHERS = new Set([
   ...deprecatedHtmlElements,
   ...deprecatedHtmlElements.map(casing.capitalize),
diff --git a/lib/rules/no-reserved-keys.js b/lib/rules/no-reserved-keys.js
index 38b4f410d..a9fce43ca 100644
--- a/lib/rules/no-reserved-keys.js
+++ b/lib/rules/no-reserved-keys.js
@@ -40,7 +40,12 @@ module.exports = {
         },
         additionalProperties: false
       }
-    ]
+    ],
+    messages: {
+      reserved: "Key '{{name}}' is reserved.",
+      startsWithUnderscore:
+        "Keys starting with with '_' are reserved in '{{name}}' group."
+    }
   },
   /** @param {RuleContext} context */
   create(context) {
@@ -52,28 +57,44 @@ module.exports = {
     // Public
     // ----------------------------------------------------------------------
 
-    return utils.executeOnVue(context, (obj) => {
-      const properties = utils.iterateProperties(obj, groups)
-      for (const o of properties) {
-        if (o.groupName === 'data' && o.name[0] === '_') {
-          context.report({
-            node: o.node,
-            message:
-              "Keys starting with with '_' are reserved in '{{name}}' group.",
-            data: {
-              name: o.name
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(_node, props) {
+          for (const { propName, node } of props) {
+            if (propName && reservedKeys.has(propName)) {
+              context.report({
+                node,
+                messageId: 'reserved',
+                data: {
+                  name: propName
+                }
+              })
             }
-          })
-        } else if (reservedKeys.has(o.name)) {
-          context.report({
-            node: o.node,
-            message: "Key '{{name}}' is reserved.",
-            data: {
-              name: o.name
-            }
-          })
+          }
         }
-      }
-    })
+      }),
+      utils.executeOnVue(context, (obj) => {
+        const properties = utils.iterateProperties(obj, groups)
+        for (const o of properties) {
+          if (o.groupName === 'data' && o.name[0] === '_') {
+            context.report({
+              node: o.node,
+              messageId: 'startsWithUnderscore',
+              data: {
+                name: o.name
+              }
+            })
+          } else if (reservedKeys.has(o.name)) {
+            context.report({
+              node: o.node,
+              messageId: 'reserved',
+              data: {
+                name: o.name
+              }
+            })
+          }
+        }
+      })
+    )
   }
 }
diff --git a/lib/rules/no-restricted-call-after-await.js b/lib/rules/no-restricted-call-after-await.js
index 6723d91ce..0c1989418 100644
--- a/lib/rules/no-restricted-call-after-await.js
+++ b/lib/rules/no-restricted-call-after-await.js
@@ -54,15 +54,21 @@ module.exports = {
   },
   /** @param {RuleContext} context */
   create(context) {
+    /**
+     * @typedef {object} SetupScopeData
+     * @property {boolean} afterAwait
+     * @property {[number,number]} range
+     */
+
     /** @type {Map<ESNode, string>} */
     const restrictedCallNodes = new Map()
-    /** @type {Map<FunctionExpression | ArrowFunctionExpression | FunctionDeclaration, { setupProperty: Property, afterAwait: boolean }>} */
-    const setupFunctions = new Map()
+    /** @type {Map<FunctionExpression | ArrowFunctionExpression | FunctionDeclaration | Program, SetupScopeData>} */
+    const setupScopes = new Map()
 
     /**x
      * @typedef {object} ScopeStack
      * @property {ScopeStack | null} upper
-     * @property {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} functionNode
+     * @property {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration | Program} scopeNode
      */
     /** @type {ScopeStack | null} */
     let scopeStack = null
@@ -136,6 +142,11 @@ module.exports = {
       {
         /** @param {Program} node */
         Program(node) {
+          scopeStack = {
+            upper: scopeStack,
+            scopeNode: node
+          }
+
           const tracker = new ReferenceTracker(context.getScope())
 
           for (const option of context.options) {
@@ -170,39 +181,39 @@ module.exports = {
               }
             }
           }
-        }
-      },
-      utils.defineVueVisitor(context, {
+        },
         /** @param {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} node */
         ':function'(node) {
           scopeStack = {
             upper: scopeStack,
-            functionNode: node
+            scopeNode: node
           }
         },
-        onSetupFunctionEnter(node) {
-          setupFunctions.set(node, {
-            setupProperty: node.parent,
-            afterAwait: false
-          })
+        ':function:exit'() {
+          scopeStack = scopeStack && scopeStack.upper
         },
-        AwaitExpression() {
+        /** @param {AwaitExpression} node */
+        AwaitExpression(node) {
           if (!scopeStack) {
             return
           }
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData) {
+          const setupScope = setupScopes.get(scopeStack.scopeNode)
+          if (!setupScope || !utils.inRange(setupScope.range, node)) {
             return
           }
-          setupFunctionData.afterAwait = true
+          setupScope.afterAwait = true
         },
         /** @param {CallExpression} node */
         CallExpression(node) {
           if (!scopeStack) {
             return
           }
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData || !setupFunctionData.afterAwait) {
+          const setupScope = setupScopes.get(scopeStack.scopeNode)
+          if (
+            !setupScope ||
+            !setupScope.afterAwait ||
+            !utils.inRange(setupScope.range, node)
+          ) {
             return
           }
 
@@ -214,12 +225,34 @@ module.exports = {
               data: { message }
             })
           }
+        }
+      },
+      (() => {
+        const scriptSetup = utils.getScriptSetupElement(context)
+        if (!scriptSetup) {
+          return {}
+        }
+        return {
+          /**
+           * @param {Program} node
+           */
+          Program(node) {
+            setupScopes.set(node, {
+              afterAwait: false,
+              range: scriptSetup.range
+            })
+          }
+        }
+      })(),
+      utils.defineVueVisitor(context, {
+        onSetupFunctionEnter(node) {
+          setupScopes.set(node, {
+            afterAwait: false,
+            range: node.range
+          })
         },
-        /** @param {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} node */
-        ':function:exit'(node) {
-          scopeStack = scopeStack && scopeStack.upper
-
-          setupFunctions.delete(node)
+        onSetupFunctionExit(node) {
+          setupScopes.delete(node)
         }
       })
     )
diff --git a/lib/rules/no-restricted-props.js b/lib/rules/no-restricted-props.js
index 8a64913c3..9bd26a81e 100644
--- a/lib/rules/no-restricted-props.js
+++ b/lib/rules/no-restricted-props.js
@@ -7,6 +7,12 @@
 const utils = require('../utils')
 const regexp = require('../utils/regexp')
 
+/**
+ * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
+ * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ * @typedef {import('../utils').ComponentTypeProp} ComponentTypeProp
+ */
+
 /**
  * @typedef {object} ParsedOption
  * @property { (name: string) => boolean } test
@@ -88,39 +94,58 @@ module.exports = {
     /** @type {ParsedOption[]} */
     const options = context.options.map(parseOption)
 
-    return utils.defineVueVisitor(context, {
-      onVueObjectEnter(node) {
-        for (const prop of utils.getComponentProps(node)) {
-          if (!prop.propName) {
-            continue
-          }
+    /**
+     * @param {(ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]} props
+     * @param { { [key: string]: Property | undefined } } [withDefaultsProps]
+     */
+    function processProps(props, withDefaultsProps) {
+      for (const prop of props) {
+        if (!prop.propName) {
+          continue
+        }
 
-          for (const option of options) {
-            if (option.test(prop.propName)) {
-              const message =
-                option.message ||
-                `Using \`${prop.propName}\` props is not allowed.`
-              context.report({
-                node: prop.key,
-                messageId: 'restrictedProp',
-                data: { message },
-                suggest: createSuggest(prop.key, option)
-              })
-              break
-            }
+        for (const option of options) {
+          if (option.test(prop.propName)) {
+            const message =
+              option.message ||
+              `Using \`${prop.propName}\` props is not allowed.`
+            context.report({
+              node: prop.key,
+              messageId: 'restrictedProp',
+              data: { message },
+              suggest: createSuggest(
+                prop.key,
+                option,
+                withDefaultsProps && withDefaultsProps[prop.propName]
+              )
+            })
+            break
           }
         }
       }
-    })
+    }
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(node, props) {
+          processProps(props, utils.getWithDefaultsProps(node))
+        }
+      }),
+      utils.defineVueVisitor(context, {
+        onVueObjectEnter(node) {
+          processProps(utils.getComponentProps(node))
+        }
+      })
+    )
   }
 }
 
 /**
  * @param {Expression} node
  * @param {ParsedOption} option
+ * @param {Property} [withDefault]
  * @returns {Rule.SuggestionReportDescriptor[]}
  */
-function createSuggest(node, option) {
+function createSuggest(node, option, withDefault) {
   if (!option.suggest) {
     return []
   }
@@ -140,7 +165,17 @@ function createSuggest(node, option) {
   return [
     {
       fix(fixer) {
-        return fixer.replaceText(node, replaceText)
+        const fixes = [fixer.replaceText(node, replaceText)]
+        if (withDefault) {
+          if (withDefault.shorthand) {
+            fixes.push(
+              fixer.insertTextBefore(withDefault.value, `${replaceText}:`)
+            )
+          } else {
+            fixes.push(fixer.replaceText(withDefault.key, replaceText))
+          }
+        }
+        return fixes.sort((a, b) => a.range[0] - b.range[0])
       },
       messageId: 'instead',
       data: { suggest: option.suggest }
diff --git a/lib/rules/no-setup-props-destructure.js b/lib/rules/no-setup-props-destructure.js
index e77f63c4d..ee3699c55 100644
--- a/lib/rules/no-setup-props-destructure.js
+++ b/lib/rules/no-setup-props-destructure.js
@@ -20,31 +20,40 @@ module.exports = {
       destructuring:
         'Destructuring the `props` will cause the value to lose reactivity.',
       getProperty:
-        'Getting a value from the `props` in root scope of `setup()` will cause the value to lose reactivity.'
+        'Getting a value from the `props` in root scope of `{{scopeName}}` will cause the value to lose reactivity.'
     }
   },
   /** @param {RuleContext} context */
   create(context) {
-    /** @type {Map<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, Set<Identifier>>} */
+    /**
+     * @typedef {object} ScopePropsReferences
+     * @property {Set<Identifier>} refs
+     * @property {string} scopeName
+     */
+    /** @type {Map<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression | Program, ScopePropsReferences>} */
     const setupScopePropsReferenceIds = new Map()
 
     /**
      * @param {ESNode} node
      * @param {string} messageId
+     * @param {string} scopeName
      */
-    function report(node, messageId) {
+    function report(node, messageId, scopeName) {
       context.report({
         node,
-        messageId
+        messageId,
+        data: {
+          scopeName
+        }
       })
     }
 
     /**
      * @param {Pattern} left
      * @param {Expression | null} right
-     * @param {Set<Identifier>} propsReferenceIds
+     * @param {ScopePropsReferences} propsReferences
      */
-    function verify(left, right, propsReferenceIds) {
+    function verify(left, right, propsReferences) {
       if (!right) {
         return
       }
@@ -62,88 +71,142 @@ module.exports = {
       while (rightId.type === 'MemberExpression') {
         rightId = utils.skipChainExpression(rightId.object)
       }
-      if (rightId.type === 'Identifier' && propsReferenceIds.has(rightId)) {
-        report(left, 'getProperty')
+      if (rightId.type === 'Identifier' && propsReferences.refs.has(rightId)) {
+        report(left, 'getProperty', propsReferences.scopeName)
       }
     }
     /**
      * @typedef {object} ScopeStack
      * @property {ScopeStack | null} upper
-     * @property {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression} functionNode
+     * @property {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression | Program} scopeNode
      */
     /**
      * @type {ScopeStack | null}
      */
     let scopeStack = null
 
-    return utils.defineVueVisitor(context, {
-      ':function'(node) {
-        scopeStack = {
-          upper: scopeStack,
-          functionNode: node
-        }
-      },
-      onSetupFunctionEnter(node) {
-        const propsParam = utils.skipDefaultParamValue(node.params[0])
-        if (!propsParam) {
-          // no arguments
-          return
-        }
-        if (propsParam.type === 'RestElement') {
-          // cannot check
-          return
-        }
-        if (
-          propsParam.type === 'ArrayPattern' ||
-          propsParam.type === 'ObjectPattern'
-        ) {
-          report(propsParam, 'destructuring')
-          return
-        }
+    /**
+     * @param {Pattern | null} node
+     * @param {FunctionDeclaration | FunctionExpression | ArrowFunctionExpression | Program} scopeNode
+     * @param {string} scopeName
+     */
+    function processPattern(node, scopeNode, scopeName) {
+      if (!node) {
+        // no arguments
+        return
+      }
+      if (
+        node.type === 'RestElement' ||
+        node.type === 'AssignmentPattern' ||
+        node.type === 'MemberExpression'
+      ) {
+        // cannot check
+        return
+      }
+      if (node.type === 'ArrayPattern' || node.type === 'ObjectPattern') {
+        report(node, 'destructuring', scopeName)
+        return
+      }
 
-        const variable = findVariable(context.getScope(), propsParam)
-        if (!variable) {
-          return
+      const variable = findVariable(context.getScope(), node)
+      if (!variable) {
+        return
+      }
+      const propsReferenceIds = new Set()
+      for (const reference of variable.references) {
+        if (!reference.isRead()) {
+          continue
         }
-        const propsReferenceIds = new Set()
-        for (const reference of variable.references) {
-          if (!reference.isRead()) {
-            continue
+
+        propsReferenceIds.add(reference.identifier)
+      }
+      setupScopePropsReferenceIds.set(scopeNode, {
+        refs: propsReferenceIds,
+        scopeName
+      })
+    }
+    return utils.compositingVisitors(
+      {
+        /**
+         * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression | Program} node
+         */
+        'Program, :function'(node) {
+          scopeStack = {
+            upper: scopeStack,
+            scopeNode: node
           }
+        },
+        /**
+         * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression | Program} node
+         */
+        'Program, :function:exit'(node) {
+          scopeStack = scopeStack && scopeStack.upper
 
-          propsReferenceIds.add(reference.identifier)
-        }
-        setupScopePropsReferenceIds.set(node, propsReferenceIds)
-      },
-      VariableDeclarator(node) {
-        if (!scopeStack) {
-          return
-        }
-        const propsReferenceIds = setupScopePropsReferenceIds.get(
-          scopeStack.functionNode
-        )
-        if (!propsReferenceIds) {
-          return
+          setupScopePropsReferenceIds.delete(node)
+        },
+        /**
+         * @param {VariableDeclarator} node
+         */
+        VariableDeclarator(node) {
+          if (!scopeStack) {
+            return
+          }
+          const propsReferenceIds = setupScopePropsReferenceIds.get(
+            scopeStack.scopeNode
+          )
+          if (!propsReferenceIds) {
+            return
+          }
+          verify(node.id, node.init, propsReferenceIds)
+        },
+        /**
+         * @param {AssignmentExpression} node
+         */
+        AssignmentExpression(node) {
+          if (!scopeStack) {
+            return
+          }
+          const propsReferenceIds = setupScopePropsReferenceIds.get(
+            scopeStack.scopeNode
+          )
+          if (!propsReferenceIds) {
+            return
+          }
+          verify(node.left, node.right, propsReferenceIds)
         }
-        verify(node.id, node.init, propsReferenceIds)
       },
-      AssignmentExpression(node) {
-        if (!scopeStack) {
-          return
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(node) {
+          let target = node
+          if (
+            target.parent &&
+            target.parent.type === 'CallExpression' &&
+            target.parent.arguments[0] === target &&
+            target.parent.callee.type === 'Identifier' &&
+            target.parent.callee.name === 'withDefaults'
+          ) {
+            target = target.parent
+          }
+          if (!target.parent) {
+            return
+          }
+
+          /** @type {Pattern|null} */
+          let id = null
+          if (target.parent.type === 'VariableDeclarator') {
+            id = target.parent.init === target ? target.parent.id : null
+          } else if (target.parent.type === 'AssignmentExpression') {
+            id = target.parent.right === target ? target.parent.left : null
+          }
+          processPattern(id, context.getSourceCode().ast, '<script setup>')
         }
-        const propsReferenceIds = setupScopePropsReferenceIds.get(
-          scopeStack.functionNode
-        )
-        if (!propsReferenceIds) {
-          return
+      }),
+      utils.defineVueVisitor(context, {
+        onSetupFunctionEnter(node) {
+          const propsParam = utils.skipDefaultParamValue(node.params[0])
+          processPattern(propsParam, node, 'setup()')
         }
-        verify(node.left, node.right, propsReferenceIds)
-      },
-      ':function:exit'(node) {
-        scopeStack = scopeStack && scopeStack.upper
-
-        setupScopePropsReferenceIds.delete(node)
-      }
-    })
+      })
+    )
   }
 }
diff --git a/lib/rules/no-side-effects-in-computed-properties.js b/lib/rules/no-side-effects-in-computed-properties.js
index 54ededbdb..a0d508014 100644
--- a/lib/rules/no-side-effects-in-computed-properties.js
+++ b/lib/rules/no-side-effects-in-computed-properties.js
@@ -8,6 +8,7 @@ const utils = require('../utils')
 
 /**
  * @typedef {import('../utils').VueObjectData} VueObjectData
+ * @typedef {import('../utils').VueVisitor} VueVisitor
  * @typedef {import('../utils').ComponentComputedProperty} ComponentComputedProperty
  */
 
@@ -32,8 +33,8 @@ module.exports = {
     const computedPropertiesMap = new Map()
     /** @type {Array<FunctionExpression | ArrowFunctionExpression>} */
     const computedCallNodes = []
-    /** @type {Array<FunctionExpression | ArrowFunctionExpression | FunctionDeclaration>} */
-    const setupFunctions = []
+    /** @type {[number, number][]} */
+    const setupRanges = []
 
     /**
      * @typedef {object} ScopeStack
@@ -57,7 +58,114 @@ module.exports = {
       scopeStack = scopeStack && scopeStack.upper
     }
 
-    return Object.assign(
+    const nodeVisitor = {
+      ':function': onFunctionEnter,
+      ':function:exit': onFunctionExit,
+
+      /**
+       * @param {(Identifier | ThisExpression) & {parent: MemberExpression}} node
+       * @param {VueObjectData|undefined} [info]
+       */
+      'MemberExpression > :matches(Identifier, ThisExpression)'(node, info) {
+        if (!scopeStack) {
+          return
+        }
+        const targetBody = scopeStack.body
+
+        const computedProperty = (
+          info ? computedPropertiesMap.get(info.node) || [] : []
+        ).find((cp) => {
+          return (
+            cp.value &&
+            cp.value.range[0] <= node.range[0] &&
+            node.range[1] <= cp.value.range[1] &&
+            targetBody === cp.value
+          )
+        })
+        if (computedProperty) {
+          if (!utils.isThis(node, context)) {
+            return
+          }
+          const mem = node.parent
+          if (mem.object !== node) {
+            return
+          }
+
+          const invalid = utils.findMutating(mem)
+          if (invalid) {
+            context.report({
+              node: invalid.node,
+              message: 'Unexpected side effect in "{{key}}" computed property.',
+              data: { key: computedProperty.key || 'Unknown' }
+            })
+          }
+          return
+        }
+
+        // ignore `this` for computed functions
+        if (node.type === 'ThisExpression') {
+          return
+        }
+
+        const computedFunction = computedCallNodes.find(
+          (c) =>
+            c.range[0] <= node.range[0] &&
+            node.range[1] <= c.range[1] &&
+            targetBody === c.body
+        )
+        if (!computedFunction) {
+          return
+        }
+
+        const mem = node.parent
+        if (mem.object !== node) {
+          return
+        }
+
+        const variable = findVariable(context.getScope(), node)
+        if (!variable || variable.defs.length !== 1) {
+          return
+        }
+
+        const def = variable.defs[0]
+        if (
+          def.type === 'ImplicitGlobalVariable' ||
+          def.type === 'TDZ' ||
+          def.type === 'ImportBinding'
+        ) {
+          return
+        }
+
+        const isDeclaredInsideSetup = setupRanges.some(
+          ([start, end]) =>
+            start <= def.node.range[0] && def.node.range[1] <= end
+        )
+        if (!isDeclaredInsideSetup) {
+          return
+        }
+
+        if (
+          computedFunction.range[0] <= def.node.range[0] &&
+          def.node.range[1] <= computedFunction.range[1]
+        ) {
+          // mutating local variables are accepted
+          return
+        }
+
+        const invalid = utils.findMutating(node)
+        if (invalid) {
+          context.report({
+            node: invalid.node,
+            message: 'Unexpected side effect in computed function.'
+          })
+        }
+      }
+    }
+    const scriptSetupNode = utils.getScriptSetupElement(context)
+    if (scriptSetupNode) {
+      setupRanges.push(scriptSetupNode.range)
+    }
+    return utils.compositingVisitors(
       {
         Program() {
           const tracker = new ReferenceTracker(context.getScope())
@@ -80,120 +188,17 @@ module.exports = {
           }
         }
       },
-      utils.defineVueVisitor(context, {
-        onVueObjectEnter(node) {
-          computedPropertiesMap.set(node, utils.getComputedProperties(node))
-        },
-        ':function': onFunctionEnter,
-        ':function:exit': onFunctionExit,
-        onSetupFunctionEnter(node) {
-          setupFunctions.push(node)
-        },
-
-        /**
-         * @param {(Identifier | ThisExpression) & {parent: MemberExpression}} node
-         * @param {VueObjectData} data
-         */
-        'MemberExpression > :matches(Identifier, ThisExpression)'(
-          node,
-          { node: vueNode }
-        ) {
-          if (!scopeStack) {
-            return
-          }
-          const targetBody = scopeStack.body
-
-          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
-            )
+      scriptSetupNode
+        ? utils.defineScriptSetupVisitor(context, nodeVisitor)
+        : utils.defineVueVisitor(context, {
+            onVueObjectEnter(node) {
+              computedPropertiesMap.set(node, utils.getComputedProperties(node))
+            },
+            onSetupFunctionEnter(node) {
+              setupRanges.push(node.body.range)
+            },
+            ...nodeVisitor
           })
-          if (computedProperty) {
-            if (!utils.isThis(node, context)) {
-              return
-            }
-            const mem = node.parent
-            if (mem.object !== node) {
-              return
-            }
-
-            const invalid = utils.findMutating(mem)
-            if (invalid) {
-              context.report({
-                node: invalid.node,
-                message:
-                  'Unexpected side effect in "{{key}}" computed property.',
-                data: { key: computedProperty.key || 'Unknown' }
-              })
-            }
-            return
-          }
-
-          // ignore `this` for computed functions
-          if (node.type === 'ThisExpression') {
-            return
-          }
-
-          const computedFunction = computedCallNodes.find(
-            (c) =>
-              node.loc.start.line >= c.loc.start.line &&
-              node.loc.end.line <= c.loc.end.line &&
-              targetBody === c.body
-          )
-          if (!computedFunction) {
-            return
-          }
-
-          const mem = node.parent
-          if (mem.object !== node) {
-            return
-          }
-
-          const variable = findVariable(context.getScope(), node)
-          if (!variable || variable.defs.length !== 1) {
-            return
-          }
-
-          const def = variable.defs[0]
-          if (
-            def.type === 'ImplicitGlobalVariable' ||
-            def.type === 'TDZ' ||
-            def.type === 'ImportBinding'
-          ) {
-            return
-          }
-
-          const isDeclaredInsideSetup = setupFunctions.some(
-            (setupFn) =>
-              def.node.loc.start.line >= setupFn.loc.start.line &&
-              def.node.loc.end.line <= setupFn.loc.end.line
-          )
-          if (!isDeclaredInsideSetup) {
-            return
-          }
-
-          if (
-            def.node.loc.start.line >= computedFunction.loc.start.line &&
-            def.node.loc.end.line <= computedFunction.loc.end.line
-          ) {
-            // mutating local variables are accepted
-            return
-          }
-
-          const invalid = utils.findMutating(node)
-          if (invalid) {
-            context.report({
-              node: invalid.node,
-              message: 'Unexpected side effect in computed function.'
-            })
-          }
-        }
-      })
     )
   }
 }
diff --git a/lib/rules/no-template-shadow.js b/lib/rules/no-template-shadow.js
index 44f26cf57..f66f8a701 100644
--- a/lib/rules/no-template-shadow.js
+++ b/lib/rules/no-template-shadow.js
@@ -19,7 +19,7 @@ const utils = require('../utils')
 // ------------------------------------------------------------------------------
 
 /** @type {GroupName[]} */
-const GROUP_NAMES = ['props', 'computed', 'data', 'methods']
+const GROUP_NAMES = ['props', 'computed', 'data', 'methods', 'setup']
 
 module.exports = {
   meta: {
@@ -50,44 +50,43 @@ module.exports = {
     // Public
     // ----------------------------------------------------------------------
 
-    return utils.defineTemplateBodyVisitor(
-      context,
-      {
-        /** @param {VElement} node */
-        VElement(node) {
-          scopeStack = {
-            parent: scopeStack,
-            nodes: scopeStack
-              ? scopeStack.nodes.slice() // make copy
-              : []
-          }
-          if (node.variables) {
-            for (const variable of node.variables) {
-              const varNode = variable.id
-              const name = varNode.name
-              if (
-                scopeStack.nodes.some((node) => node.name === name) ||
-                jsVars.has(name)
-              ) {
-                context.report({
-                  node: varNode,
-                  loc: varNode.loc,
-                  message:
-                    "Variable '{{name}}' is already declared in the upper scope.",
-                  data: {
-                    name
-                  }
-                })
-              } else {
-                scopeStack.nodes.push(varNode)
+    return utils.compositingVisitors(
+      utils.isScriptSetup(context)
+        ? {
+            Program() {
+              const globalScope =
+                context.getSourceCode().scopeManager.globalScope
+              if (!globalScope) {
+                return
+              }
+              for (const variable of globalScope.variables) {
+                if (variable.defs.length > 0) {
+                  jsVars.add(variable.name)
+                }
+              }
+              const moduleScope = globalScope.childScopes.find(
+                (scope) => scope.type === 'module'
+              )
+              if (!moduleScope) {
+                return
+              }
+              for (const variable of moduleScope.variables) {
+                if (variable.defs.length > 0) {
+                  jsVars.add(variable.name)
+                }
               }
             }
           }
-        },
-        'VElement:exit'() {
-          scopeStack = scopeStack && scopeStack.parent
+        : {},
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(_node, props) {
+          for (const prop of props) {
+            if (prop.propName) {
+              jsVars.add(prop.propName)
+            }
+          }
         }
-      },
+      }),
       utils.executeOnVue(context, (obj) => {
         const properties = Array.from(
           utils.iterateProperties(obj, new Set(GROUP_NAMES))
@@ -95,6 +94,38 @@ module.exports = {
         for (const node of properties) {
           jsVars.add(node.name)
         }
+      }),
+      utils.defineTemplateBodyVisitor(context, {
+        /** @param {VElement} node */
+        VElement(node) {
+          scopeStack = {
+            parent: scopeStack,
+            nodes: scopeStack ? [...scopeStack.nodes] : []
+          }
+          for (const variable of node.variables) {
+            const varNode = variable.id
+            const name = varNode.name
+            if (
+              scopeStack.nodes.some((node) => node.name === name) ||
+              jsVars.has(name)
+            ) {
+              context.report({
+                node: varNode,
+                loc: varNode.loc,
+                message:
+                  "Variable '{{name}}' is already declared in the upper scope.",
+                data: {
+                  name
+                }
+              })
+            } else {
+              scopeStack.nodes.push(varNode)
+            }
+          }
+        },
+        'VElement:exit'() {
+          scopeStack = scopeStack && scopeStack.parent
+        }
       })
     )
   }
diff --git a/lib/rules/no-unregistered-components.js b/lib/rules/no-unregistered-components.js
index 07d9e800a..5cc22a9f8 100644
--- a/lib/rules/no-unregistered-components.js
+++ b/lib/rules/no-unregistered-components.js
@@ -15,15 +15,6 @@ const casing = require('../utils/casing')
 // Rule helpers
 // ------------------------------------------------------------------------------
 
-const VUE_BUILT_IN_COMPONENTS = [
-  'component',
-  'suspense',
-  'teleport',
-  'transition',
-  'transition-group',
-  'keep-alive',
-  'slot'
-]
 /**
  * Check whether the given node is a built-in component or not.
  *
@@ -37,7 +28,7 @@ const isBuiltInComponent = (node) => {
   return (
     utils.isHtmlElementNode(node) &&
     !utils.isHtmlWellKnownElementName(node.rawName) &&
-    VUE_BUILT_IN_COMPONENTS.indexOf(rawName) > -1
+    utils.isBuiltInComponentName(rawName)
   )
 }
 
@@ -70,6 +61,9 @@ module.exports = {
   },
   /** @param {RuleContext} context */
   create(context) {
+    if (utils.isScriptSetup(context)) {
+      return {}
+    }
     const options = context.options[0] || {}
     /** @type {string[]} */
     const ignorePatterns = options.ignorePatterns || []
diff --git a/lib/rules/no-unsupported-features.js b/lib/rules/no-unsupported-features.js
index 2d4caf3e2..821a82373 100644
--- a/lib/rules/no-unsupported-features.js
+++ b/lib/rules/no-unsupported-features.js
@@ -26,6 +26,7 @@ const FEATURES = {
   'v-model-argument': require('./syntaxes/v-model-argument'),
   'v-model-custom-modifiers': require('./syntaxes/v-model-custom-modifiers'),
   'v-is': require('./syntaxes/v-is'),
+  'script-setup': require('./syntaxes/script-setup'),
   // Vue.js 3.1.0+
   'is-attribute-with-vue-prefix': require('./syntaxes/is-attribute-with-vue-prefix')
 }
@@ -100,6 +101,9 @@ module.exports = {
       forbiddenVModelCustomModifiers:
         'Custom modifiers on `v-model` are not supported until Vue.js "3.0.0".',
       forbiddenVIs: '`v-is` are not supported until Vue.js "3.0.0".',
+      forbiddenScriptSetup:
+        '`<script setup>` are not supported until Vue.js "3.0.0".',
+      // Vue.js 3.1.0+
       forbiddenIsAttributeWithVuePrefix:
         '`is="vue:"` are not supported until Vue.js "3.1.0".'
     }
diff --git a/lib/rules/no-unused-properties.js b/lib/rules/no-unused-properties.js
index be18224ed..9a38c2a75 100644
--- a/lib/rules/no-unused-properties.js
+++ b/lib/rules/no-unused-properties.js
@@ -12,9 +12,27 @@ const utils = require('../utils')
 const eslintUtils = require('eslint-utils')
 
 /**
- * @typedef {import('../utils').ComponentPropertyData} ComponentPropertyData
+ * @typedef {import('../utils').GroupName} GroupName
  * @typedef {import('../utils').VueObjectData} VueObjectData
  */
+
+/**
+ * @typedef {object} ComponentObjectPropertyData
+ * @property {string} name
+ * @property {GroupName} groupName
+ * @property {'object'} type
+ * @property {ASTNode} node
+ * @property {Property} property
+ *
+ * @typedef {object} ComponentNonObjectPropertyData
+ * @property {string} name
+ * @property {GroupName} groupName
+ * @property {'array' | 'type'} type
+ * @property {ASTNode} node
+ *
+ * @typedef { ComponentNonObjectPropertyData | ComponentObjectPropertyData } ComponentPropertyData
+ */
+
 /**
  * @typedef {object} TemplatePropertiesContainer
  * @property {UsedProperties} usedProperties
@@ -256,7 +274,7 @@ class ParamsUsedProperties {
       return param
     }
     if (this.node.params[index]) {
-      return (this.params[index] = extractParamProperties(
+      return (this.params[index] = extractParamOrVerProperties(
         this.node.params[index],
         this.context
       ))
@@ -270,7 +288,7 @@ class ParamsUsedProperties {
  * @param {RuleContext} context
  * @returns {UsedProperties}
  */
-function extractParamProperties(node, context) {
+function extractParamOrVerProperties(node, context) {
   const result = new UsedProperties()
 
   while (node.type === 'AssignmentPattern') {
@@ -826,7 +844,58 @@ module.exports = {
     }
 
     const scriptVisitor = utils.compositingVisitors(
-      {},
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(node, props) {
+          if (!groups.has('props')) {
+            return
+          }
+          const container = getVueComponentPropertiesContainer(node)
+
+          for (const prop of props) {
+            if (!prop.propName) {
+              continue
+            }
+            if (prop.type === 'object') {
+              container.properties.push({
+                type: prop.type,
+                name: prop.propName,
+                groupName: 'props',
+                node: prop.key,
+                property: prop.node
+              })
+            } else {
+              container.properties.push({
+                type: prop.type,
+                name: prop.propName,
+                groupName: 'props',
+                node: prop.key
+              })
+            }
+          }
+          let target = node
+          if (
+            target.parent &&
+            target.parent.type === 'CallExpression' &&
+            target.parent.arguments[0] === target &&
+            target.parent.callee.type === 'Identifier' &&
+            target.parent.callee.name === 'withDefaults'
+          ) {
+            target = target.parent
+          }
+
+          if (
+            !target.parent ||
+            target.parent.type !== 'VariableDeclarator' ||
+            target.parent.init !== target
+          ) {
+            return
+          }
+
+          const pattern = target.parent.id
+          const usedProps = extractParamOrVerProperties(pattern, context)
+          container.usedPropertiesForProps.merge(usedProps)
+        }
+      }),
       utils.defineVueVisitor(context, {
         onVueObjectEnter(node) {
           const container = getVueComponentPropertiesContainer(node)
diff --git a/lib/rules/no-unused-refs.js b/lib/rules/no-unused-refs.js
index 0e9455f61..2c47bc035 100644
--- a/lib/rules/no-unused-refs.js
+++ b/lib/rules/no-unused-refs.js
@@ -180,25 +180,64 @@ module.exports = {
           reportUnusedRefs()
         }
       },
-      {
-        Identifier(id) {
-          if (hasUnknown) {
-            return
-          }
-          if (id.name !== '$refs') {
-            return
+      utils.compositingVisitors(
+        utils.isScriptSetup(context)
+          ? {
+              Program() {
+                const globalScope =
+                  context.getSourceCode().scopeManager.globalScope
+                if (!globalScope) {
+                  return
+                }
+                for (const variable of globalScope.variables) {
+                  if (variable.defs.length > 0) {
+                    usedRefs.add(variable.name)
+                  }
+                }
+                const moduleScope = globalScope.childScopes.find(
+                  (scope) => scope.type === 'module'
+                )
+                if (!moduleScope) {
+                  return
+                }
+                for (const variable of moduleScope.variables) {
+                  if (variable.defs.length > 0) {
+                    usedRefs.add(variable.name)
+                  }
+                }
+              }
+            }
+          : {},
+        utils.defineVueVisitor(context, {
+          onVueObjectEnter(node) {
+            for (const prop of utils.iterateProperties(
+              node,
+              new Set(['setup'])
+            )) {
+              usedRefs.add(prop.name)
+            }
           }
-          /** @type {Identifier | MemberExpression} */
-          let refsNode = id
-          if (id.parent.type === 'MemberExpression') {
-            if (id.parent.property === id) {
-              // `this.$refs.foo`
-              refsNode = id.parent
+        }),
+        {
+          Identifier(id) {
+            if (hasUnknown) {
+              return
+            }
+            if (id.name !== '$refs') {
+              return
             }
+            /** @type {Identifier | MemberExpression} */
+            let refsNode = id
+            if (id.parent.type === 'MemberExpression') {
+              if (id.parent.property === id) {
+                // `this.$refs.foo`
+                refsNode = id.parent
+              }
+            }
+            extractUsedForPattern(refsNode)
           }
-          extractUsedForPattern(refsNode)
         }
-      }
+      )
     )
   }
 }
diff --git a/lib/rules/no-watch-after-await.js b/lib/rules/no-watch-after-await.js
index 5f037fb30..8de30668e 100644
--- a/lib/rules/no-watch-after-await.js
+++ b/lib/rules/no-watch-after-await.js
@@ -57,20 +57,31 @@ module.exports = {
   /** @param {RuleContext} context */
   create(context) {
     const watchCallNodes = new Set()
-    /** @type {Map<FunctionExpression | ArrowFunctionExpression | FunctionDeclaration, { setupProperty: Property, afterAwait: boolean }>} */
-    const setupFunctions = new Map()
+    /**
+     * @typedef {object} SetupScopeData
+     * @property {boolean} afterAwait
+     * @property {[number,number]} range
+     */
+    /** @type {Map<FunctionExpression | ArrowFunctionExpression | FunctionDeclaration | Program, SetupScopeData>} */
+    const setupScopes = new Map()
 
     /**
      * @typedef {object} ScopeStack
      * @property {ScopeStack | null} upper
-     * @property {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} functionNode
+     * @property {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration | Program} scopeNode
      */
     /** @type {ScopeStack | null} */
     let scopeStack = null
 
-    return Object.assign(
+    return utils.compositingVisitors(
       {
-        Program() {
+        /** @param {Program} node */
+        Program(node) {
+          scopeStack = {
+            upper: scopeStack,
+            scopeNode: node
+          }
+
           const tracker = new ReferenceTracker(context.getScope())
           const traceMap = {
             vue: {
@@ -87,39 +98,39 @@ module.exports = {
           for (const { node } of tracker.iterateEsmReferences(traceMap)) {
             watchCallNodes.add(node)
           }
-        }
-      },
-      utils.defineVueVisitor(context, {
+        },
         /** @param {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} node */
         ':function'(node) {
           scopeStack = {
             upper: scopeStack,
-            functionNode: node
+            scopeNode: node
           }
         },
-        onSetupFunctionEnter(node) {
-          setupFunctions.set(node, {
-            setupProperty: node.parent,
-            afterAwait: false
-          })
+        ':function:exit'() {
+          scopeStack = scopeStack && scopeStack.upper
         },
-        AwaitExpression() {
+        /** @param {AwaitExpression} node */
+        AwaitExpression(node) {
           if (!scopeStack) {
             return
           }
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData) {
+          const setupScope = setupScopes.get(scopeStack.scopeNode)
+          if (!setupScope || !utils.inRange(setupScope.range, node)) {
             return
           }
-          setupFunctionData.afterAwait = true
+          setupScope.afterAwait = true
         },
         /** @param {CallExpression} node */
         CallExpression(node) {
           if (!scopeStack) {
             return
           }
-          const setupFunctionData = setupFunctions.get(scopeStack.functionNode)
-          if (!setupFunctionData || !setupFunctionData.afterAwait) {
+          const setupScope = setupScopes.get(scopeStack.scopeNode)
+          if (
+            !setupScope ||
+            !setupScope.afterAwait ||
+            !utils.inRange(setupScope.range, node)
+          ) {
             return
           }
 
@@ -129,12 +140,34 @@ module.exports = {
               messageId: 'forbidden'
             })
           }
+        }
+      },
+      (() => {
+        const scriptSetup = utils.getScriptSetupElement(context)
+        if (!scriptSetup) {
+          return {}
+        }
+        return {
+          /**
+           * @param {Program} node
+           */
+          Program(node) {
+            setupScopes.set(node, {
+              afterAwait: false,
+              range: scriptSetup.range
+            })
+          }
+        }
+      })(),
+      utils.defineVueVisitor(context, {
+        onSetupFunctionEnter(node) {
+          setupScopes.set(node, {
+            afterAwait: false,
+            range: node.range
+          })
         },
-        /** @param {FunctionExpression | ArrowFunctionExpression | FunctionDeclaration} node */
-        ':function:exit'(node) {
-          scopeStack = scopeStack && scopeStack.upper
-
-          setupFunctions.delete(node)
+        onSetupFunctionExit(node) {
+          setupScopes.delete(node)
         }
       })
     )
diff --git a/lib/rules/prop-name-casing.js b/lib/rules/prop-name-casing.js
index 5ee9b78f1..b21147957 100644
--- a/lib/rules/prop-name-casing.js
+++ b/lib/rules/prop-name-casing.js
@@ -8,6 +8,12 @@ const utils = require('../utils')
 const casing = require('../utils/casing')
 const allowedCaseOptions = ['camelCase', 'snake_case']
 
+/**
+ * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
+ * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ * @typedef {import('../utils').ComponentTypeProp} ComponentTypeProp
+ */
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -22,8 +28,11 @@ function create(context) {
   // Public
   // ----------------------------------------------------------------------
 
-  return utils.executeOnVue(context, (obj) => {
-    for (const item of utils.getComponentProps(obj)) {
+  /**
+   * @param {(ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]} props
+   */
+  function processProps(props) {
+    for (const item of props) {
       const propName = item.propName
       if (propName == null) {
         continue
@@ -39,7 +48,17 @@ function create(context) {
         })
       }
     }
-  })
+  }
+  return utils.compositingVisitors(
+    utils.defineScriptSetupVisitor(context, {
+      onDefinePropsEnter(_node, props) {
+        processProps(props)
+      }
+    }),
+    utils.executeOnVue(context, (obj) => {
+      processProps(utils.getComponentProps(obj))
+    })
+  )
 }
 
 // ------------------------------------------------------------------------------
diff --git a/lib/rules/require-default-prop.js b/lib/rules/require-default-prop.js
index e0e29b69e..d35c2f8ea 100644
--- a/lib/rules/require-default-prop.js
+++ b/lib/rules/require-default-prop.js
@@ -5,7 +5,9 @@
 'use strict'
 
 /**
+ * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
  * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ * @typedef {import('../utils').ComponentTypeProp} ComponentTypeProp
  * @typedef {ComponentObjectProp & { value: ObjectExpression} } ComponentObjectPropObject
  */
 
@@ -35,7 +37,10 @@ module.exports = {
       url: 'https://eslint.vuejs.org/rules/require-default-prop.html'
     },
     fixable: null, // or "code" or "whitespace"
-    schema: []
+    schema: [],
+    messages: {
+      missingDefault: `Prop '{{propName}}' requires default value to be set.`
+    }
   },
   /** @param {RuleContext} context */
   create(context) {
@@ -45,11 +50,11 @@ module.exports = {
 
     /**
      * Checks if the passed prop is required
-     * @param {ComponentObjectPropObject} prop - Property AST node for a single prop
+     * @param {ObjectExpression} propValue - ObjectExpression AST node for a single prop
      * @return {boolean}
      */
-    function propIsRequired(prop) {
-      const propRequiredNode = prop.value.properties.find(
+    function propIsRequired(propValue) {
+      const propRequiredNode = propValue.properties.find(
         (p) =>
           p.type === 'Property' &&
           utils.getStaticPropertyName(p) === 'required' &&
@@ -62,11 +67,11 @@ module.exports = {
 
     /**
      * Checks if the passed prop has a default value
-     * @param {ComponentObjectPropObject} prop - Property AST node for a single prop
+     * @param {ObjectExpression} propValue - ObjectExpression AST node for a single prop
      * @return {boolean}
      */
-    function propHasDefault(prop) {
-      const propDefaultNode = prop.value.properties.find(
+    function propHasDefault(propValue) {
+      const propDefaultNode = propValue.properties.find(
         (p) =>
           p.type === 'Property' && utils.getStaticPropertyName(p) === 'default'
       )
@@ -75,32 +80,27 @@ module.exports = {
     }
 
     /**
-     * Finds all props that don't have a default value set
-     * @param {ComponentObjectProp[]} props - Vue component's "props" node
-     * @return {ComponentObjectProp[]} Array of props without "default" value
+     * Checks whether the given props that don't have a default value
+     * @param {ComponentObjectProp} prop Vue component's "props" node
+     * @return {boolean}
      */
-    function findPropsWithoutDefaultValue(props) {
-      return props.filter((prop) => {
-        if (prop.value.type !== 'ObjectExpression') {
-          if (prop.value.type === 'Identifier') {
-            return NATIVE_TYPES.has(prop.value.name)
-          }
-          if (
-            prop.value.type === 'CallExpression' ||
-            prop.value.type === 'MemberExpression'
-          ) {
-            // OK
-            return false
-          }
-          // NG
-          return true
+    function isWithoutDefaultValue(prop) {
+      if (prop.value.type !== 'ObjectExpression') {
+        if (prop.value.type === 'Identifier') {
+          return NATIVE_TYPES.has(prop.value.name)
+        }
+        if (
+          prop.value.type === 'CallExpression' ||
+          prop.value.type === 'MemberExpression'
+        ) {
+          // OK
+          return false
         }
+        // NG
+        return true
+      }
 
-        return (
-          !propIsRequired(/** @type {ComponentObjectPropObject} */ (prop)) &&
-          !propHasDefault(/** @type {ComponentObjectPropObject} */ (prop))
-        )
-      })
+      return !propIsRequired(prop.value) && !propHasDefault(prop.value)
     }
 
     /**
@@ -145,46 +145,66 @@ module.exports = {
     }
 
     /**
-     * Excludes purely Boolean props from the Array
-     * @param {ComponentObjectProp[]} props - Array with props
-     * @return {ComponentObjectProp[]}
+     * @param {(ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]} props
+     * @param {boolean} [withDefaults]
+     * @param { { [key: string]: Expression | undefined } } [withDefaultsExpressions]
      */
-    function excludeBooleanProps(props) {
-      return props.filter((prop) => !isBooleanProp(prop))
+    function processProps(props, withDefaults, withDefaultsExpressions) {
+      for (const prop of props) {
+        if (prop.type === 'object' && !prop.node.shorthand) {
+          if (!isWithoutDefaultValue(prop)) {
+            continue
+          }
+          if (isBooleanProp(prop)) {
+            continue
+          }
+          const propName =
+            prop.propName != null
+              ? prop.propName
+              : `[${context.getSourceCode().getText(prop.node.key)}]`
+
+          context.report({
+            node: prop.node,
+            messageId: `missingDefault`,
+            data: {
+              propName
+            }
+          })
+        } else if (
+          prop.type === 'type' &&
+          withDefaults &&
+          withDefaultsExpressions
+        ) {
+          if (!withDefaultsExpressions[prop.propName]) {
+            context.report({
+              node: prop.node,
+              messageId: `missingDefault`,
+              data: {
+                propName: prop.propName
+              }
+            })
+          }
+        }
+      }
     }
 
     // ----------------------------------------------------------------------
     // Public
     // ----------------------------------------------------------------------
 
-    return utils.executeOnVue(context, (obj) => {
-      const props = utils
-        .getComponentProps(obj)
-        .filter(
-          (prop) =>
-            prop.value &&
-            !(prop.node.type === 'Property' && prop.node.shorthand)
-        )
-
-      const propsWithoutDefault = findPropsWithoutDefaultValue(
-        /** @type {ComponentObjectProp[]} */ (props)
-      )
-      const propsToReport = excludeBooleanProps(propsWithoutDefault)
-
-      for (const prop of propsToReport) {
-        const propName =
-          prop.propName != null
-            ? prop.propName
-            : `[${context.getSourceCode().getText(prop.node.key)}]`
-
-        context.report({
-          node: prop.node,
-          message: `Prop '{{propName}}' requires default value to be set.`,
-          data: {
-            propName
-          }
-        })
-      }
-    })
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(node, props) {
+          processProps(
+            props,
+            utils.hasWithDefaults(node),
+            utils.getWithDefaultsPropExpressions(node)
+          )
+        }
+      }),
+      utils.executeOnVue(context, (obj) => {
+        processProps(utils.getComponentProps(obj))
+      })
+    )
   }
 }
diff --git a/lib/rules/require-emit-validator.js b/lib/rules/require-emit-validator.js
index 9d6e5d7f1..083e39e6d 100644
--- a/lib/rules/require-emit-validator.js
+++ b/lib/rules/require-emit-validator.js
@@ -9,6 +9,7 @@ const utils = require('../utils')
 /**
  * @typedef {import('../utils').ComponentArrayEmit} ComponentArrayEmit
  * @typedef {import('../utils').ComponentObjectEmit} ComponentObjectEmit
+ * @typedef {import('../utils').ComponentTypeEmit} ComponentTypeEmit
  */
 
 // ------------------------------------------------------------------------------
@@ -83,8 +84,20 @@ module.exports = {
     // Public
     // ----------------------------------------------------------------------
 
-    return utils.executeOnVue(context, (obj) => {
-      utils.getComponentEmits(obj).forEach(checker)
-    })
+    return utils.compositingVisitors(
+      utils.executeOnVue(context, (obj) => {
+        utils.getComponentEmits(obj).forEach(checker)
+      }),
+      utils.defineScriptSetupVisitor(context, {
+        onDefineEmitsEnter(_node, emits) {
+          for (const emit of emits) {
+            if (emit.type === 'type') {
+              continue
+            }
+            checker(emit)
+          }
+        }
+      })
+    )
   }
 }
diff --git a/lib/rules/require-explicit-emits.js b/lib/rules/require-explicit-emits.js
index 797428254..34b557b4b 100644
--- a/lib/rules/require-explicit-emits.js
+++ b/lib/rules/require-explicit-emits.js
@@ -7,8 +7,10 @@
 /**
  * @typedef {import('../utils').ComponentArrayEmit} ComponentArrayEmit
  * @typedef {import('../utils').ComponentObjectEmit} ComponentObjectEmit
+ * @typedef {import('../utils').ComponentTypeEmit} ComponentTypeEmit
  * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
  * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ * @typedef {import('../utils').ComponentTypeProp} ComponentTypeProp
  * @typedef {import('../utils').VueObjectData} VueObjectData
  */
 
@@ -105,42 +107,43 @@ module.exports = {
     ],
     messages: {
       missing:
-        'The "{{name}}" event has been triggered but not declared on `emits` option.',
-      addOneOption: 'Add the "{{name}}" to `emits` option.',
+        'The "{{name}}" event has been triggered but not declared on {{emitsKind}}.',
+      addOneOption: 'Add the "{{name}}" to {{emitsKind}}.',
       addArrayEmitsOption:
-        'Add the `emits` option with array syntax and define "{{name}}" event.',
+        'Add the {{emitsKind}} with array syntax and define "{{name}}" event.',
       addObjectEmitsOption:
-        'Add the `emits` option with object syntax and define "{{name}}" event.'
+        'Add the {{emitsKind}} with object syntax and define "{{name}}" event.'
     }
   },
   /** @param {RuleContext} context */
   create(context) {
     const options = context.options[0] || {}
     const allowProps = !!options.allowProps
-    /** @type {Map<ObjectExpression, { contextReferenceIds: Set<Identifier>, emitReferenceIds: Set<Identifier> }>} */
+    /** @type {Map<ObjectExpression | Program, { contextReferenceIds: Set<Identifier>, emitReferenceIds: Set<Identifier> }>} */
     const setupContexts = new Map()
-    /** @type {Map<ObjectExpression, (ComponentArrayEmit | ComponentObjectEmit)[]>} */
+    /** @type {Map<ObjectExpression | Program, (ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]>} */
     const vueEmitsDeclarations = new Map()
-    /** @type {Map<ObjectExpression, (ComponentArrayProp | ComponentObjectProp)[]>} */
+    /** @type {Map<ObjectExpression | Program, (ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]>} */
     const vuePropsDeclarations = new Map()
 
     /**
-     * @typedef {object} VueTemplateObjectData
-     * @property {'export' | 'mark' | 'definition'} type
-     * @property {ObjectExpression} object
-     * @property {(ComponentArrayEmit | ComponentObjectEmit)[]} emits
-     * @property {(ComponentArrayProp | ComponentObjectProp)[]} props
+     * @typedef {object} VueTemplateDefineData
+     * @property {'export' | 'mark' | 'definition' | 'setup'} type
+     * @property {ObjectExpression | Program} define
+     * @property {(ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]} emits
+     * @property {(ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]} props
+     * @property {CallExpression} [defineEmits]
      */
-    /** @type {VueTemplateObjectData | null} */
-    let vueTemplateObjectData = null
+    /** @type {VueTemplateDefineData | null} */
+    let vueTemplateDefineData = null
 
     /**
-     * @param {(ComponentArrayEmit | ComponentObjectEmit)[]} emits
-     * @param {(ComponentArrayProp | ComponentObjectProp)[]} props
+     * @param {(ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]} emits
+     * @param {(ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]} props
      * @param {Literal} nameLiteralNode
-     * @param {ObjectExpression} vueObjectNode
+     * @param {ObjectExpression | Program} vueDefineNode
      */
-    function verifyEmit(emits, props, nameLiteralNode, vueObjectNode) {
+    function verifyEmit(emits, props, nameLiteralNode, vueDefineNode) {
       const name = `${nameLiteralNode.value}`
       if (emits.some((e) => e.emitName === name)) {
         return
@@ -155,12 +158,98 @@ module.exports = {
         node: nameLiteralNode,
         messageId: 'missing',
         data: {
-          name
+          name,
+          emitsKind:
+            vueDefineNode.type === 'ObjectExpression'
+              ? '`emits` option'
+              : '`defineEmits`'
         },
-        suggest: buildSuggest(vueObjectNode, emits, nameLiteralNode, context)
+        suggest: buildSuggest(vueDefineNode, emits, nameLiteralNode, context)
       })
     }
 
+    const programNode = context.getSourceCode().ast
+    if (utils.isScriptSetup(context)) {
+      // init
+      vueTemplateDefineData = {
+        type: 'setup',
+        define: programNode,
+        emits: [],
+        props: []
+      }
+    }
+
+    const callVisitor = {
+      /**
+       * @param {CallExpression & { arguments: [Literal, ...Expression] }} node
+       * @param {VueObjectData} [info]
+       */
+      'CallExpression[arguments.0.type=Literal]'(node, info) {
+        const callee = utils.skipChainExpression(node.callee)
+        const nameLiteralNode = node.arguments[0]
+        if (!nameLiteralNode || typeof nameLiteralNode.value !== 'string') {
+          // cannot check
+          return
+        }
+        const vueDefineNode = info ? info.node : programNode
+        const emitsDeclarations = vueEmitsDeclarations.get(vueDefineNode)
+        if (!emitsDeclarations) {
+          return
+        }
+
+        let emit
+        if (callee.type === 'MemberExpression') {
+          const name = utils.getStaticPropertyName(callee)
+          if (name === 'emit' || name === '$emit') {
+            emit = { name, member: callee }
+          }
+        }
+
+        // verify setup context
+        const setupContext = setupContexts.get(vueDefineNode)
+        if (setupContext) {
+          const { contextReferenceIds, emitReferenceIds } = setupContext
+          if (callee.type === 'Identifier' && emitReferenceIds.has(callee)) {
+            // verify setup(props,{emit}) {emit()}
+            verifyEmit(
+              emitsDeclarations,
+              vuePropsDeclarations.get(vueDefineNode) || [],
+              nameLiteralNode,
+              vueDefineNode
+            )
+          } else if (emit && emit.name === 'emit') {
+            const memObject = utils.skipChainExpression(emit.member.object)
+            if (
+              memObject.type === 'Identifier' &&
+              contextReferenceIds.has(memObject)
+            ) {
+              // verify setup(props,context) {context.emit()}
+              verifyEmit(
+                emitsDeclarations,
+                vuePropsDeclarations.get(vueDefineNode) || [],
+                nameLiteralNode,
+                vueDefineNode
+              )
+            }
+          }
+        }
+
+        // verify $emit
+        if (emit && emit.name === '$emit') {
+          const memObject = utils.skipChainExpression(emit.member.object)
+          if (utils.isThis(memObject, context)) {
+            // verify this.$emit()
+            verifyEmit(
+              emitsDeclarations,
+              vuePropsDeclarations.get(vueDefineNode) || [],
+              nameLiteralNode,
+              vueDefineNode
+            )
+          }
+        }
+      }
+    }
+
     return utils.defineTemplateBodyVisitor(
       context,
       {
@@ -172,54 +261,41 @@ module.exports = {
             // cannot check
             return
           }
-          if (!vueTemplateObjectData) {
+          if (!vueTemplateDefineData) {
             return
           }
           if (callee.type === 'Identifier' && callee.name === '$emit') {
             verifyEmit(
-              vueTemplateObjectData.emits,
-              vueTemplateObjectData.props,
+              vueTemplateDefineData.emits,
+              vueTemplateDefineData.props,
               nameLiteralNode,
-              vueTemplateObjectData.object
+              vueTemplateDefineData.define
             )
           }
         }
       },
-      utils.defineVueVisitor(context, {
-        onVueObjectEnter(node) {
-          vueEmitsDeclarations.set(node, utils.getComponentEmits(node))
-          if (allowProps) {
-            vuePropsDeclarations.set(node, utils.getComponentProps(node))
-          }
-        },
-        onSetupFunctionEnter(node, { node: vueNode }) {
-          const contextParam = node.params[1]
-          if (!contextParam) {
-            // no arguments
-            return
-          }
-          if (contextParam.type === 'RestElement') {
-            // cannot check
-            return
-          }
-          if (contextParam.type === 'ArrayPattern') {
-            // cannot check
-            return
-          }
-          /** @type {Set<Identifier>} */
-          const contextReferenceIds = new Set()
-          /** @type {Set<Identifier>} */
-          const emitReferenceIds = new Set()
-          if (contextParam.type === 'ObjectPattern') {
-            const emitProperty = utils.findAssignmentProperty(
-              contextParam,
-              'emit'
-            )
-            if (!emitProperty) {
+      utils.compositingVisitors(
+        utils.defineScriptSetupVisitor(context, {
+          onDefineEmitsEnter(node, emits) {
+            vueEmitsDeclarations.set(programNode, emits)
+
+            if (
+              vueTemplateDefineData &&
+              vueTemplateDefineData.type === 'setup'
+            ) {
+              vueTemplateDefineData.emits = emits
+              vueTemplateDefineData.defineEmits = node
+            }
+
+            if (
+              !node.parent ||
+              node.parent.type !== 'VariableDeclarator' ||
+              node.parent.init !== node
+            ) {
               return
             }
-            const emitParam = emitProperty.value
-            // `setup(props, {emit})`
+
+            const emitParam = node.parent.id
             const variable =
               emitParam.type === 'Identifier'
                 ? findVariable(context.getScope(), emitParam)
@@ -227,6 +303,8 @@ module.exports = {
             if (!variable) {
               return
             }
+            /** @type {Set<Identifier>} */
+            const emitReferenceIds = new Set()
             for (const reference of variable.references) {
               if (!reference.isRead()) {
                 continue
@@ -234,150 +312,170 @@ module.exports = {
 
               emitReferenceIds.add(reference.identifier)
             }
-          } else if (contextParam.type === 'Identifier') {
-            // `setup(props, context)`
-            const variable = findVariable(context.getScope(), contextParam)
-            if (!variable) {
+            setupContexts.set(programNode, {
+              contextReferenceIds: new Set(),
+              emitReferenceIds
+            })
+          },
+          onDefinePropsEnter(_node, props) {
+            if (allowProps) {
+              vuePropsDeclarations.set(programNode, props)
+
+              if (
+                vueTemplateDefineData &&
+                vueTemplateDefineData.type === 'setup'
+              ) {
+                vueTemplateDefineData.props = props
+              }
+            }
+          },
+          ...callVisitor
+        }),
+        utils.defineVueVisitor(context, {
+          onVueObjectEnter(node) {
+            vueEmitsDeclarations.set(node, utils.getComponentEmits(node))
+            if (allowProps) {
+              vuePropsDeclarations.set(node, utils.getComponentProps(node))
+            }
+          },
+          onSetupFunctionEnter(node, { node: vueNode }) {
+            const contextParam = node.params[1]
+            if (!contextParam) {
+              // no arguments
               return
             }
-            for (const reference of variable.references) {
-              if (!reference.isRead()) {
-                continue
-              }
-
-              contextReferenceIds.add(reference.identifier)
+            if (contextParam.type === 'RestElement') {
+              // cannot check
+              return
             }
-          }
-          setupContexts.set(vueNode, {
-            contextReferenceIds,
-            emitReferenceIds
-          })
-        },
-        /**
-         * @param {CallExpression & { arguments: [Literal, ...Expression] }} node
-         * @param {VueObjectData} data
-         */
-        'CallExpression[arguments.0.type=Literal]'(node, { node: vueNode }) {
-          const callee = utils.skipChainExpression(node.callee)
-          const nameLiteralNode = node.arguments[0]
-          if (!nameLiteralNode || typeof nameLiteralNode.value !== 'string') {
-            // cannot check
-            return
-          }
-          const emitsDeclarations = vueEmitsDeclarations.get(vueNode)
-          if (!emitsDeclarations) {
-            return
-          }
-
-          let emit
-          if (callee.type === 'MemberExpression') {
-            const name = utils.getStaticPropertyName(callee)
-            if (name === 'emit' || name === '$emit') {
-              emit = { name, member: callee }
+            if (contextParam.type === 'ArrayPattern') {
+              // cannot check
+              return
             }
-          }
-
-          // verify setup context
-          const setupContext = setupContexts.get(vueNode)
-          if (setupContext) {
-            const { contextReferenceIds, emitReferenceIds } = setupContext
-            if (callee.type === 'Identifier' && emitReferenceIds.has(callee)) {
-              // verify setup(props,{emit}) {emit()}
-              verifyEmit(
-                emitsDeclarations,
-                vuePropsDeclarations.get(vueNode) || [],
-                nameLiteralNode,
-                vueNode
+            /** @type {Set<Identifier>} */
+            const contextReferenceIds = new Set()
+            /** @type {Set<Identifier>} */
+            const emitReferenceIds = new Set()
+            if (contextParam.type === 'ObjectPattern') {
+              const emitProperty = utils.findAssignmentProperty(
+                contextParam,
+                'emit'
               )
-            } else if (emit && emit.name === 'emit') {
-              const memObject = utils.skipChainExpression(emit.member.object)
-              if (
-                memObject.type === 'Identifier' &&
-                contextReferenceIds.has(memObject)
-              ) {
-                // verify setup(props,context) {context.emit()}
-                verifyEmit(
-                  emitsDeclarations,
-                  vuePropsDeclarations.get(vueNode) || [],
-                  nameLiteralNode,
-                  vueNode
-                )
+              if (!emitProperty) {
+                return
               }
-            }
-          }
+              const emitParam = emitProperty.value
+              // `setup(props, {emit})`
+              const variable =
+                emitParam.type === 'Identifier'
+                  ? findVariable(context.getScope(), emitParam)
+                  : null
+              if (!variable) {
+                return
+              }
+              for (const reference of variable.references) {
+                if (!reference.isRead()) {
+                  continue
+                }
 
-          // verify $emit
-          if (emit && emit.name === '$emit') {
-            const memObject = utils.skipChainExpression(emit.member.object)
-            if (utils.isThis(memObject, context)) {
-              // verify this.$emit()
-              verifyEmit(
-                emitsDeclarations,
-                vuePropsDeclarations.get(vueNode) || [],
-                nameLiteralNode,
-                vueNode
-              )
+                emitReferenceIds.add(reference.identifier)
+              }
+            } else if (contextParam.type === 'Identifier') {
+              // `setup(props, context)`
+              const variable = findVariable(context.getScope(), contextParam)
+              if (!variable) {
+                return
+              }
+              for (const reference of variable.references) {
+                if (!reference.isRead()) {
+                  continue
+                }
+
+                contextReferenceIds.add(reference.identifier)
+              }
             }
-          }
-        },
-        onVueObjectExit(node, { type }) {
-          const emits = vueEmitsDeclarations.get(node)
-          if (
-            !vueTemplateObjectData ||
-            vueTemplateObjectData.type !== 'export'
-          ) {
+            setupContexts.set(vueNode, {
+              contextReferenceIds,
+              emitReferenceIds
+            })
+          },
+          ...callVisitor,
+          onVueObjectExit(node, { type }) {
+            const emits = vueEmitsDeclarations.get(node)
             if (
-              emits &&
-              (type === 'mark' || type === 'export' || type === 'definition')
+              !vueTemplateDefineData ||
+              (vueTemplateDefineData.type !== 'export' &&
+                vueTemplateDefineData.type !== 'setup')
             ) {
-              vueTemplateObjectData = {
-                type,
-                object: node,
-                emits,
-                props: vuePropsDeclarations.get(node) || []
+              if (
+                emits &&
+                (type === 'mark' || type === 'export' || type === 'definition')
+              ) {
+                vueTemplateDefineData = {
+                  type,
+                  define: node,
+                  emits,
+                  props: vuePropsDeclarations.get(node) || []
+                }
               }
             }
+            setupContexts.delete(node)
+            vueEmitsDeclarations.delete(node)
+            vuePropsDeclarations.delete(node)
           }
-          setupContexts.delete(node)
-          vueEmitsDeclarations.delete(node)
-          vuePropsDeclarations.delete(node)
-        }
-      })
+        })
+      )
     )
   }
 }
 
 /**
- * @param {ObjectExpression} object
- * @param {(ComponentArrayEmit | ComponentObjectEmit)[]} emits
+ * @param {ObjectExpression|Program} define
+ * @param {(ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]} emits
  * @param {Literal} nameNode
  * @param {RuleContext} context
  * @returns {Rule.SuggestionReportDescriptor[]}
  */
-function buildSuggest(object, emits, nameNode, context) {
+function buildSuggest(define, emits, nameNode, context) {
+  const emitsKind =
+    define.type === 'ObjectExpression' ? '`emits` option' : '`defineEmits`'
   const certainEmits = emits.filter((e) => e.key)
   if (certainEmits.length) {
     const last = certainEmits[certainEmits.length - 1]
     return [
       {
         messageId: 'addOneOption',
-        data: { name: `${nameNode.value}` },
+        data: {
+          name: `${nameNode.value}`,
+          emitsKind
+        },
         fix(fixer) {
-          if (last.value === null) {
+          if (last.type === 'array') {
             // Array
             return fixer.insertTextAfter(last.node, `, '${nameNode.value}'`)
-          } else {
+          } else if (last.type === 'object') {
             // Object
             return fixer.insertTextAfter(
               last.node,
               `, '${nameNode.value}': null`
             )
+          } else {
+            // type
+            // The argument is unknown and cannot be suggested.
+            return null
           }
         }
       }
     ]
   }
 
+  if (define.type !== 'ObjectExpression') {
+    // We don't know where to put defineEmits.
+    return []
+  }
+
+  const object = define
+
   const propertyNodes = object.properties.filter(utils.isProperty)
 
   const emitsOption = propertyNodes.find(
@@ -393,7 +491,7 @@ function buildSuggest(object, emits, nameNode, context) {
       return [
         {
           messageId: 'addOneOption',
-          data: { name: `${nameNode.value}` },
+          data: { name: `${nameNode.value}`, emitsKind },
           fix(fixer) {
             return fixer.insertTextAfter(
               leftBracket,
@@ -411,7 +509,7 @@ function buildSuggest(object, emits, nameNode, context) {
       return [
         {
           messageId: 'addOneOption',
-          data: { name: `${nameNode.value}` },
+          data: { name: `${nameNode.value}`, emitsKind },
           fix(fixer) {
             return fixer.insertTextAfter(
               leftBrace,
@@ -433,7 +531,7 @@ function buildSuggest(object, emits, nameNode, context) {
   return [
     {
       messageId: 'addArrayEmitsOption',
-      data: { name: `${nameNode.value}` },
+      data: { name: `${nameNode.value}`, emitsKind },
       fix(fixer) {
         if (afterOptionNode) {
           return fixer.insertTextAfter(
@@ -468,7 +566,7 @@ function buildSuggest(object, emits, nameNode, context) {
     },
     {
       messageId: 'addObjectEmitsOption',
-      data: { name: `${nameNode.value}` },
+      data: { name: `${nameNode.value}`, emitsKind },
       fix(fixer) {
         if (afterOptionNode) {
           return fixer.insertTextAfter(
diff --git a/lib/rules/require-name-property.js b/lib/rules/require-name-property.js
index 6bb57b244..d4052f153 100644
--- a/lib/rules/require-name-property.js
+++ b/lib/rules/require-name-property.js
@@ -32,6 +32,9 @@ module.exports = {
   },
   /** @param {RuleContext} context */
   create(context) {
+    if (utils.isScriptSetup(context)) {
+      return {}
+    }
     return utils.executeOnVue(context, (component, type) => {
       if (type === 'definition') {
         const defType = getVueComponentDefinitionType(component)
diff --git a/lib/rules/require-prop-type-constructor.js b/lib/rules/require-prop-type-constructor.js
index 0f94f0f2c..f22da8118 100644
--- a/lib/rules/require-prop-type-constructor.js
+++ b/lib/rules/require-prop-type-constructor.js
@@ -7,6 +7,12 @@
 const utils = require('../utils')
 const { isDef } = require('../utils')
 
+/**
+ * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
+ * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
+ * @typedef {import('../utils').ComponentTypeProp} ComponentTypeProp
+ */
+
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -76,8 +82,9 @@ module.exports = {
         )
     }
 
-    return utils.executeOnVueComponent(context, (obj) => {
-      for (const prop of utils.getComponentProps(obj)) {
+    /** @param {(ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]} props */
+    function verifyProps(props) {
+      for (const prop of props) {
         if (!prop.value || prop.propName == null) {
           continue
         }
@@ -94,6 +101,17 @@ module.exports = {
           checkPropertyNode(prop.propName, typeProperty.value)
         }
       }
-    })
+    }
+
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(_node, props) {
+          verifyProps(props)
+        }
+      }),
+      utils.executeOnVueComponent(context, (obj) => {
+        verifyProps(utils.getComponentProps(obj))
+      })
+    )
   }
 }
diff --git a/lib/rules/require-prop-types.js b/lib/rules/require-prop-types.js
index 17037853f..3978db3f0 100644
--- a/lib/rules/require-prop-types.js
+++ b/lib/rules/require-prop-types.js
@@ -92,12 +92,24 @@ module.exports = {
     // Public
     // ----------------------------------------------------------------------
 
-    return utils.executeOnVue(context, (obj) => {
-      const props = utils.getComponentProps(obj)
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(_node, props) {
+          for (const prop of props) {
+            if (prop.type === 'type') {
+              continue
+            }
+            checkProperty(prop)
+          }
+        }
+      }),
+      utils.executeOnVue(context, (obj) => {
+        const props = utils.getComponentProps(obj)
 
-      for (const prop of props) {
-        checkProperty(prop)
-      }
-    })
+        for (const prop of props) {
+          checkProperty(prop)
+        }
+      })
+    )
   }
 }
diff --git a/lib/rules/require-valid-default-prop.js b/lib/rules/require-valid-default-prop.js
index e40cad861..2b711b56c 100644
--- a/lib/rules/require-valid-default-prop.js
+++ b/lib/rules/require-valid-default-prop.js
@@ -9,6 +9,7 @@ const { capitalize } = require('../utils/casing')
 /**
  * @typedef {import('../utils').ComponentObjectProp} ComponentObjectProp
  * @typedef {import('../utils').ComponentArrayProp} ComponentArrayProp
+ * @typedef {import('../utils').ComponentTypeProp} ComponentTypeProp
  * @typedef {import('../utils').VueObjectData} VueObjectData
  */
 
@@ -88,18 +89,45 @@ module.exports = {
   /** @param {RuleContext} context */
   create(context) {
     /**
-     * @typedef { { type: string, function: false } } StandardValueType
-     * @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 {object} StandardValueType
+     * @property {string} type
+     * @property {false} function
+     */
+    /**
+     * @typedef {object} FunctionExprValueType
+     * @property {'Function'} type
+     * @property {true} function
+     * @property {true} expression
+     * @property {Expression} functionBody
+     * @property {string | null} returnType
+     */
+    /**
+     * @typedef {object} FunctionValueType
+     * @property {'Function'} type
+     * @property {true} function
+     * @property {false} expression
+     * @property {BlockStatement} functionBody
+     * @property {ReturnType[]} returnTypes
+     */
+    /**
      * @typedef { ComponentObjectProp & { value: ObjectExpression } } ComponentObjectDefineProp
-     * @typedef { { prop: ComponentObjectDefineProp, type: Set<string>, default: FunctionValueType } } PropDefaultFunctionContext
      * @typedef { { type: string, node: Expression } } ReturnType
      */
+    /**
+     * @typedef {object} PropDefaultFunctionContext
+     * @property {ComponentObjectProp | ComponentTypeProp} prop
+     * @property {Set<string>} types
+     * @property {FunctionValueType} default
+     */
 
     /**
      * @type {Map<ObjectExpression, PropDefaultFunctionContext[]>}
      */
     const vueObjectPropsContexts = new Map()
+    /**
+     * @type { {node: CallExpression, props:PropDefaultFunctionContext[]}[] }
+     */
+    const scriptSetupPropsContexts = []
 
     /**
      * @typedef {object} ScopeStack
@@ -194,7 +222,7 @@ module.exports = {
 
     /**
      * @param {*} node
-     * @param {ComponentObjectProp} prop
+     * @param {ComponentObjectProp | ComponentTypeProp} prop
      * @param {Iterable<string>} expectedTypeNames
      */
     function report(node, prop, expectedTypeNames) {
@@ -213,127 +241,196 @@ module.exports = {
       })
     }
 
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-
-    return utils.defineVueVisitor(context, {
-      onVueObjectEnter(obj) {
-        /** @type {ComponentObjectDefineProp[]} */
-        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) {
+    /**
+     * @param {(ComponentObjectDefineProp | ComponentTypeProp)[]} props
+     * @param { { [key: string]: Expression | undefined } } withDefaults
+     */
+    function processPropDefs(props, withDefaults) {
+      /** @type {PropDefaultFunctionContext[]} */
+      const propContexts = []
+      for (const prop of props) {
+        let typeList
+        let defExpr
+        if (prop.type === 'object') {
           const type = getPropertyNode(prop.value, 'type')
           if (!type) continue
 
-          const typeNames = new Set(
-            getTypes(type.value).filter((item) => NATIVE_TYPES.has(item))
-          )
-
-          // There is no native types detected
-          if (typeNames.size === 0) continue
+          typeList = getTypes(type.value)
 
           const def = getPropertyNode(prop.value, 'default')
           if (!def) continue
 
-          const defType = getValueType(def.value)
+          defExpr = def.value
+        } else {
+          typeList = prop.types
+          defExpr = withDefaults[prop.propName]
+        }
+        if (!defExpr) continue
+
+        const typeNames = new Set(
+          typeList.filter((item) => NATIVE_TYPES.has(item))
+        )
+        // There is no native types detected
+        if (typeNames.size === 0) continue
+
+        const defType = getValueType(defExpr)
 
-          if (!defType) continue
+        if (!defType) continue
 
-          if (!defType.function) {
-            if (typeNames.has(defType.type)) {
-              if (!FUNCTION_VALUE_TYPES.has(defType.type)) {
-                continue
-              }
+        if (!defType.function) {
+          if (typeNames.has(defType.type)) {
+            if (!FUNCTION_VALUE_TYPES.has(defType.type)) {
+              continue
             }
-            report(
-              def.value,
-              prop,
-              Array.from(typeNames).map((type) =>
-                FUNCTION_VALUE_TYPES.has(type) ? 'Function' : type
-              )
+          }
+          report(
+            defExpr,
+            prop,
+            Array.from(typeNames).map((type) =>
+              FUNCTION_VALUE_TYPES.has(type) ? 'Function' : type
             )
-          } else {
-            if (typeNames.has('Function')) {
+          )
+        } else {
+          if (typeNames.has('Function')) {
+            continue
+          }
+          if (defType.expression) {
+            if (!defType.returnType || typeNames.has(defType.returnType)) {
               continue
             }
-            if (defType.expression) {
-              if (!defType.returnType || typeNames.has(defType.returnType)) {
-                continue
-              }
-              report(defType.functionBody, prop, typeNames)
-            } else {
-              propContexts.push({
-                prop,
-                type: typeNames,
-                default: defType
+            report(defType.functionBody, prop, typeNames)
+          } else {
+            propContexts.push({
+              prop,
+              types: typeNames,
+              default: defType
+            })
+          }
+        }
+      }
+      return propContexts
+    }
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return utils.compositingVisitors(
+      {
+        /**
+         * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
+         */
+        ':function'(node) {
+          scopeStack = {
+            upper: scopeStack,
+            body: node.body,
+            returnTypes: null
+          }
+        },
+        /**
+         * @param {ReturnStatement} node
+         */
+        ReturnStatement(node) {
+          if (!scopeStack) {
+            return
+          }
+          if (scopeStack.returnTypes && node.argument) {
+            const type = getValueType(node.argument)
+            if (type) {
+              scopeStack.returnTypes.push({
+                type: type.type,
+                node: node.argument
               })
             }
           }
-        }
-        vueObjectPropsContexts.set(obj, propContexts)
+        },
+        ':function:exit': onFunctionExit
       },
-      /**
-       * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
-       * @param {VueObjectData} data
-       */
-      ':function'(node, { node: vueNode }) {
-        scopeStack = {
-          upper: scopeStack,
-          body: node.body,
-          returnTypes: null
-        }
+      utils.defineVueVisitor(context, {
+        onVueObjectEnter(obj) {
+          /** @type {ComponentObjectDefineProp[]} */
+          const props = utils.getComponentProps(obj).filter(
+            /**
+             * @param {ComponentObjectProp | ComponentArrayProp} prop
+             * @returns {prop is ComponentObjectDefineProp}
+             */
+            (prop) =>
+              Boolean(
+                prop.type === 'object' && prop.value.type === 'ObjectExpression'
+              )
+          )
+          const propContexts = processPropDefs(props, {})
+          vueObjectPropsContexts.set(obj, propContexts)
+        },
+        /**
+         * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
+         * @param {VueObjectData} data
+         */
+        ':function'(node, { node: vueNode }) {
+          const data = vueObjectPropsContexts.get(vueNode)
+          if (!data || !scopeStack) {
+            return
+          }
 
-        const data = vueObjectPropsContexts.get(vueNode)
-        if (!data) {
-          return
-        }
+          for (const { default: defType } of data) {
+            if (node.body === defType.functionBody) {
+              scopeStack.returnTypes = defType.returnTypes
+            }
+          }
+        },
+        onVueObjectExit(obj) {
+          const data = vueObjectPropsContexts.get(obj)
+          if (!data) {
+            return
+          }
+          for (const { prop, types: typeNames, default: defType } of data) {
+            for (const returnType of defType.returnTypes) {
+              if (typeNames.has(returnType.type)) continue
 
-        for (const { default: defType } of data) {
-          if (node.body === defType.functionBody) {
-            scopeStack.returnTypes = defType.returnTypes
+              report(returnType.node, prop, typeNames)
+            }
           }
         }
-      },
-      /**
-       * @param {ReturnStatement} node
-       */
-      ReturnStatement(node) {
-        if (!scopeStack) {
-          return
-        }
-        if (scopeStack.returnTypes && node.argument) {
-          const type = getValueType(node.argument)
-          if (type) {
-            scopeStack.returnTypes.push({
-              type: type.type,
-              node: node.argument
-            })
+      }),
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(node, baseProps) {
+          /** @type {(ComponentObjectDefineProp | ComponentTypeProp)[]} */
+          const props = baseProps.filter(
+            /**
+             * @param {ComponentObjectProp | ComponentArrayProp | ComponentTypeProp} prop
+             * @returns {prop is ComponentObjectDefineProp | ComponentTypeProp}
+             */
+            (prop) =>
+              Boolean(
+                prop.type === 'type' ||
+                  (prop.type === 'object' &&
+                    prop.value.type === 'ObjectExpression')
+              )
+          )
+          const defaults = utils.getWithDefaultsPropExpressions(node)
+          const propContexts = processPropDefs(props, defaults)
+          scriptSetupPropsContexts.push({ node, props: propContexts })
+        },
+        /**
+         * @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node
+         */
+        ':function'(node) {
+          const data =
+            scriptSetupPropsContexts[scriptSetupPropsContexts.length - 1]
+          if (!data || !scopeStack) {
+            return
           }
-        }
-      },
-      ':function:exit': onFunctionExit,
-      onVueObjectExit(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
 
-            report(returnType.node, prop, typeNames)
+          for (const { default: defType } of data.props) {
+            if (node.body === defType.functionBody) {
+              scopeStack.returnTypes = defType.returnTypes
+            }
           }
+        },
+        onDefinePropsExit(node) {
+          scriptSetupPropsContexts.pop()
         }
-      }
-    })
+      })
+    )
   }
 }
diff --git a/lib/rules/return-in-emits-validator.js b/lib/rules/return-in-emits-validator.js
index c4ced9074..03d197b18 100644
--- a/lib/rules/return-in-emits-validator.js
+++ b/lib/rules/return-in-emits-validator.js
@@ -9,6 +9,7 @@ const utils = require('../utils')
 /**
  * @typedef {import('../utils').ComponentArrayEmit} ComponentArrayEmit
  * @typedef {import('../utils').ComponentObjectEmit} ComponentObjectEmit
+ * @typedef {import('../utils').ComponentTypeEmit} ComponentTypeEmit
  */
 
 /**
@@ -67,25 +68,36 @@ module.exports = {
      */
     let scopeStack = null
 
-    return Object.assign(
-      {},
+    /**
+     * @param {(ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]} emits
+     */
+    function processEmits(emits) {
+      for (const emit of emits) {
+        if (!emit.value) {
+          continue
+        }
+        if (
+          emit.value.type !== 'FunctionExpression' &&
+          emit.value.type !== 'ArrowFunctionExpression'
+        ) {
+          continue
+        }
+        emitsValidators.push(emit)
+      }
+    }
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefineEmitsEnter(_node, emits) {
+          processEmits(emits)
+        }
+      }),
       utils.defineVueVisitor(context, {
         /** @param {ObjectExpression} obj */
         onVueObjectEnter(obj) {
-          for (const emits of utils.getComponentEmits(obj)) {
-            if (!emits.value) {
-              continue
-            }
-            const emitsValue = emits.value
-            if (
-              emitsValue.type !== 'FunctionExpression' &&
-              emitsValue.type !== 'ArrowFunctionExpression'
-            ) {
-              continue
-            }
-            emitsValidators.push(emits)
-          }
-        },
+          processEmits(utils.getComponentEmits(obj))
+        }
+      }),
+      {
         /** @param {FunctionExpression | FunctionDeclaration | ArrowFunctionExpression} node */
         ':function'(node) {
           scopeStack = {
@@ -135,7 +147,7 @@ module.exports = {
 
           scopeStack = scopeStack && scopeStack.upper
         }
-      })
+      }
     )
   }
 }
diff --git a/lib/rules/script-setup-uses-vars.js b/lib/rules/script-setup-uses-vars.js
new file mode 100644
index 000000000..68e0b3fc3
--- /dev/null
+++ b/lib/rules/script-setup-uses-vars.js
@@ -0,0 +1,121 @@
+/**
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const utils = require('../utils')
+const casing = require('../utils/casing')
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'prevent `<script setup>` variables used in `<template>` to be marked as unused', // eslint-disable-line consistent-docs-description
+      categories: ['base'],
+      url: 'https://eslint.vuejs.org/rules/script-setup-uses-vars.html'
+    },
+    schema: []
+  },
+  /**
+   * @param {RuleContext} context - The rule context.
+   * @returns {RuleListener} AST event handlers.
+   */
+  create(context) {
+    if (!utils.isScriptSetup(context)) {
+      return {}
+    }
+    /** @type {Set<string>} */
+    const scriptVariableNames = new Set()
+    const globalScope = context.getSourceCode().scopeManager.globalScope
+    if (globalScope) {
+      for (const variable of globalScope.variables) {
+        scriptVariableNames.add(variable.name)
+      }
+      const moduleScope = globalScope.childScopes.find(
+        (scope) => scope.type === 'module'
+      )
+      for (const variable of (moduleScope && moduleScope.variables) || []) {
+        scriptVariableNames.add(variable.name)
+      }
+    }
+
+    /**
+     * `casing.camelCase()` converts the beginning to lowercase,
+     * but does not convert the case of the beginning character when converting with Vue3.
+     * @see https://github.com/vuejs/vue-next/blob/1ffd48a2f5fd3eead3ea29dae668b7ed1c6f6130/packages/shared/src/index.ts#L116
+     * @param {string} str
+     */
+    function camelize(str) {
+      return str.replace(/-(\w)/g, (_, c) => (c ? c.toUpperCase() : ''))
+    }
+    /**
+     * @see https://github.com/vuejs/vue-next/blob/1ffd48a2f5fd3eead3ea29dae668b7ed1c6f6130/packages/compiler-core/src/transforms/transformElement.ts#L321
+     * @param {string} name
+     */
+    function markElementVariableAsUsed(name) {
+      if (scriptVariableNames.has(name)) {
+        context.markVariableAsUsed(name)
+      }
+      const camelName = camelize(name)
+      if (scriptVariableNames.has(camelName)) {
+        context.markVariableAsUsed(camelName)
+      }
+      const pascalName = casing.capitalize(camelName)
+      if (scriptVariableNames.has(pascalName)) {
+        context.markVariableAsUsed(pascalName)
+      }
+    }
+
+    return utils.defineTemplateBodyVisitor(
+      context,
+      {
+        VExpressionContainer(node) {
+          for (const ref of node.references.filter(
+            (ref) => ref.variable == null
+          )) {
+            context.markVariableAsUsed(ref.id.name)
+          }
+        },
+        VElement(node) {
+          if (
+            (!utils.isHtmlElementNode(node) && !utils.isSvgElementNode(node)) ||
+            (node.rawName === node.name &&
+              (utils.isHtmlWellKnownElementName(node.rawName) ||
+                utils.isSvgWellKnownElementName(node.rawName))) ||
+            utils.isBuiltInComponentName(node.rawName)
+          ) {
+            return
+          }
+          markElementVariableAsUsed(node.rawName)
+        },
+        /** @param {VDirective} node */
+        'VAttribute[directive=true]'(node) {
+          if (utils.isBuiltInDirectiveName(node.key.name.name)) {
+            return
+          }
+          markElementVariableAsUsed(`v-${node.key.name.rawName}`)
+        },
+        /** @param {VAttribute} node */
+        'VAttribute[directive=false]'(node) {
+          if (node.key.name === 'ref' && node.value) {
+            context.markVariableAsUsed(node.value.value)
+          }
+        }
+      },
+      undefined,
+      {
+        templateBodyTriggerSelector: 'Program'
+      }
+    )
+  }
+}
diff --git a/lib/rules/syntaxes/script-setup.js b/lib/rules/syntaxes/script-setup.js
new file mode 100644
index 000000000..ef395d5ed
--- /dev/null
+++ b/lib/rules/syntaxes/script-setup.js
@@ -0,0 +1,28 @@
+/**
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const utils = require('../../utils')
+
+module.exports = {
+  supported: '>=3.0.0',
+  /** @param {RuleContext} context @returns {TemplateListener} */
+  createScriptVisitor(context) {
+    const scriptSetup = utils.getScriptSetupElement(context)
+    if (!scriptSetup) {
+      return {}
+    }
+    const reportNode =
+      utils.getAttribute(scriptSetup, 'setup') || scriptSetup.startTag
+    return {
+      Program() {
+        context.report({
+          node: reportNode,
+          messageId: 'forbiddenScriptSetup'
+        })
+      }
+    }
+  }
+}
diff --git a/lib/rules/valid-define-emits.js b/lib/rules/valid-define-emits.js
new file mode 100644
index 000000000..6b79e83cc
--- /dev/null
+++ b/lib/rules/valid-define-emits.js
@@ -0,0 +1,144 @@
+/**
+ * @author Yosuke Ota <https://github.com/ota-meshi>
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const { findVariable } = require('eslint-utils')
+const utils = require('../utils')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'enforce valid `defineEmits` compiler macro',
+      // TODO Switch in the major version.
+      // categories: ['vue3-essential'],
+      categories: undefined,
+      url: 'https://eslint.vuejs.org/rules/valid-define-emits.html'
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      hasTypeAndArg: '`defineEmits` has both a type-only emit and an argument.',
+      referencingLocally:
+        '`defineEmits` are referencing locally declared variables.',
+      multiple: '`defineEmits` has been called multiple times.',
+      notDefined: 'Custom events are not defined.',
+      definedInBoth:
+        'Custom events are defined in both `defineEmits` and `export default {}`.'
+    }
+  },
+  /** @param {RuleContext} context */
+  create(context) {
+    const scriptSetup = utils.getScriptSetupElement(context)
+    if (!scriptSetup) {
+      return {}
+    }
+
+    /** @type {Set<Expression | SpreadElement>} */
+    const emitsDefExpressions = new Set()
+    let hasDefaultExport = false
+    /** @type {CallExpression[]} */
+    const defineEmitsNodes = []
+    /** @type {CallExpression | null} */
+    let emptyDefineEmits = null
+
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefineEmitsEnter(node) {
+          defineEmitsNodes.push(node)
+
+          if (node.arguments.length >= 1) {
+            if (node.typeParameters && node.typeParameters.params.length >= 1) {
+              // `defineEmits` has both a literal type and an argument.
+              context.report({
+                node,
+                messageId: 'hasTypeAndArg'
+              })
+              return
+            }
+
+            emitsDefExpressions.add(node.arguments[0])
+          } else {
+            if (
+              !node.typeParameters ||
+              node.typeParameters.params.length === 0
+            ) {
+              emptyDefineEmits = node
+            }
+          }
+        },
+        Identifier(node) {
+          for (const def of emitsDefExpressions) {
+            if (utils.inRange(def.range, node)) {
+              const variable = findVariable(context.getScope(), node)
+              if (
+                variable &&
+                variable.references.some((ref) => ref.identifier === node)
+              ) {
+                if (
+                  variable.defs.length &&
+                  variable.defs.every((def) =>
+                    utils.inRange(scriptSetup.range, def.name)
+                  )
+                ) {
+                  //`defineEmits` are referencing locally declared variables.
+                  context.report({
+                    node,
+                    messageId: 'referencingLocally'
+                  })
+                }
+              }
+            }
+          }
+        }
+      }),
+      utils.defineVueVisitor(context, {
+        onVueObjectEnter(node, { type }) {
+          if (type !== 'export' || utils.inRange(scriptSetup.range, node)) {
+            return
+          }
+
+          hasDefaultExport = Boolean(utils.findProperty(node, 'emits'))
+        }
+      }),
+      {
+        'Program:exit'() {
+          if (!defineEmitsNodes.length) {
+            return
+          }
+          if (defineEmitsNodes.length > 1) {
+            // `defineEmits` has been called multiple times.
+            for (const node of defineEmitsNodes) {
+              context.report({
+                node,
+                messageId: 'multiple'
+              })
+            }
+            return
+          }
+          if (emptyDefineEmits) {
+            if (!hasDefaultExport) {
+              // Custom events are not defined.
+              context.report({
+                node: emptyDefineEmits,
+                messageId: 'notDefined'
+              })
+            }
+          } else {
+            if (hasDefaultExport) {
+              // Custom events are defined in both `defineEmits` and `export default {}`.
+              for (const node of defineEmitsNodes) {
+                context.report({
+                  node,
+                  messageId: 'definedInBoth'
+                })
+              }
+            }
+          }
+        }
+      }
+    )
+  }
+}
diff --git a/lib/rules/valid-define-props.js b/lib/rules/valid-define-props.js
new file mode 100644
index 000000000..613916659
--- /dev/null
+++ b/lib/rules/valid-define-props.js
@@ -0,0 +1,145 @@
+/**
+ * @author Yosuke Ota <https://github.com/ota-meshi>
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const { findVariable } = require('eslint-utils')
+const utils = require('../utils')
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'enforce valid `defineProps` compiler macro',
+      // TODO Switch in the major version.
+      // categories: ['vue3-essential'],
+      categories: undefined,
+      url: 'https://eslint.vuejs.org/rules/valid-define-props.html'
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      hasTypeAndArg:
+        '`defineProps` has both a type-only props and an argument.',
+      referencingLocally:
+        '`defineProps` are referencing locally declared variables.',
+      multiple: '`defineProps` has been called multiple times.',
+      notDefined: 'Props are not defined.',
+      definedInBoth:
+        'Props are defined in both `defineProps` and `export default {}`.'
+    }
+  },
+  /** @param {RuleContext} context */
+  create(context) {
+    const scriptSetup = utils.getScriptSetupElement(context)
+    if (!scriptSetup) {
+      return {}
+    }
+
+    /** @type {Set<Expression | SpreadElement>} */
+    const propsDefExpressions = new Set()
+    let hasDefaultExport = false
+    /** @type {CallExpression[]} */
+    const definePropsNodes = []
+    /** @type {CallExpression | null} */
+    let emptyDefineProps = null
+
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(node) {
+          definePropsNodes.push(node)
+
+          if (node.arguments.length >= 1) {
+            if (node.typeParameters && node.typeParameters.params.length >= 1) {
+              // `defineProps` has both a literal type and an argument.
+              context.report({
+                node,
+                messageId: 'hasTypeAndArg'
+              })
+              return
+            }
+
+            propsDefExpressions.add(node.arguments[0])
+          } else {
+            if (
+              !node.typeParameters ||
+              node.typeParameters.params.length === 0
+            ) {
+              emptyDefineProps = node
+            }
+          }
+        },
+        Identifier(node) {
+          for (const def of propsDefExpressions) {
+            if (utils.inRange(def.range, node)) {
+              const variable = findVariable(context.getScope(), node)
+              if (
+                variable &&
+                variable.references.some((ref) => ref.identifier === node)
+              ) {
+                if (
+                  variable.defs.length &&
+                  variable.defs.every((def) =>
+                    utils.inRange(scriptSetup.range, def.name)
+                  )
+                ) {
+                  //`defineProps` are referencing locally declared variables.
+                  context.report({
+                    node,
+                    messageId: 'referencingLocally'
+                  })
+                }
+              }
+            }
+          }
+        }
+      }),
+      utils.defineVueVisitor(context, {
+        onVueObjectEnter(node, { type }) {
+          if (type !== 'export' || utils.inRange(scriptSetup.range, node)) {
+            return
+          }
+
+          hasDefaultExport = Boolean(utils.findProperty(node, 'props'))
+        }
+      }),
+      {
+        'Program:exit'() {
+          if (!definePropsNodes.length) {
+            return
+          }
+          if (definePropsNodes.length > 1) {
+            // `defineProps` has been called multiple times.
+            for (const node of definePropsNodes) {
+              context.report({
+                node,
+                messageId: 'multiple'
+              })
+            }
+            return
+          }
+          if (emptyDefineProps) {
+            if (!hasDefaultExport) {
+              // Props are not defined.
+              context.report({
+                node: emptyDefineProps,
+                messageId: 'notDefined'
+              })
+            }
+          } else {
+            if (hasDefaultExport) {
+              // Props are defined in both `defineProps` and `export default {}`.
+              for (const node of definePropsNodes) {
+                context.report({
+                  node,
+                  messageId: 'definedInBoth'
+                })
+              }
+            }
+          }
+        }
+      }
+    )
+  }
+}
diff --git a/lib/utils/indent-common.js b/lib/utils/indent-common.js
index 8ec6bbe41..5d80b83bb 100644
--- a/lib/utils/indent-common.js
+++ b/lib/utils/indent-common.js
@@ -1824,6 +1824,8 @@ module.exports.defineVisitor = function create(
       let firstToken = tokenStore.getFirstToken(node)
 
       while (
+        leftToken &&
+        rightToken &&
         isOpeningParenToken(leftToken) &&
         isClosingParenToken(rightToken)
       ) {
diff --git a/lib/utils/indent-ts.js b/lib/utils/indent-ts.js
index 4801ab211..9afcdb34f 100644
--- a/lib/utils/indent-ts.js
+++ b/lib/utils/indent-ts.js
@@ -19,6 +19,7 @@ const {
  * @typedef { { type: string } & HasLocation } MaybeNode
  */
 /**
+ * @typedef {import('@typescript-eslint/types').TSESTree.Node} TSESTreeNode
  * @typedef {import('@typescript-eslint/types').TSESTree.ClassExpression} ClassExpression
  * @typedef {import('@typescript-eslint/types').TSESTree.ClassDeclaration} ClassDeclaration
  * @typedef {import('@typescript-eslint/types').TSESTree.TSTypeAliasDeclaration} TSTypeAliasDeclaration
@@ -125,6 +126,48 @@ function defineVisitor({
   processSemicolons,
   getFirstAndLastTokens
 }) {
+  /**
+   * Check whether a given token is the first token of:
+   *
+   * - A parameter of TSTypeParameterInstantiation
+   * - An element of TSTupleType
+   *
+   * @param {Token} token The token to check.
+   * @param {TSUnionType | TSIntersectionType} 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) {
+    /** @type {TSESTreeNode | null} */
+    let node = belongingNode
+
+    while (node != null && node.parent != null) {
+      /** @type {TSESTreeNode} */
+      const parent = node.parent
+      if (parent.type === 'TSTypeParameterInstantiation') {
+        return (
+          parent.params.length >= 2 &&
+          parent.params.some(
+            (param) =>
+              getFirstAndLastTokens(param).firstToken.range[0] ===
+              token.range[0]
+          )
+        )
+      }
+      if (parent.type === 'TSTupleType') {
+        return parent.elementTypes.some(
+          (element) =>
+            element != null &&
+            getFirstAndLastTokens(element).firstToken.range[0] ===
+              token.range[0]
+        )
+      }
+
+      node = parent
+    }
+
+    return false
+  }
+
   return {
     // Support TypeScript
     /** @param {ClassDeclaration | ClassExpression} node */
@@ -463,16 +506,34 @@ function defineVisitor({
       // A | B
       // A & B
       const firstToken = tokenStore.getFirstToken(node)
-      const types = [...node.types]
-      if (getFirstAndLastTokens(types[0]).firstToken === firstToken) {
-        types.shift()
+
+      const prevToken = tokenStore.getTokenBefore(firstToken)
+      const shouldIndent =
+        prevToken == null ||
+        prevToken.loc.end.line === firstToken.loc.start.line ||
+        isBeginningOfElement(firstToken, node)
+      const offset = shouldIndent ? 1 : 0
+
+      const typeTokensList = node.types.map(getFirstAndLastTokens)
+      const typeTokens = typeTokensList.shift()
+      if (!typeTokens) {
+        return
+      }
+      let lastToken
+      if (typeTokens.firstToken === firstToken) {
+        lastToken = typeTokens.lastToken
+      } else {
+        typeTokensList.unshift(typeTokens)
+        lastToken = firstToken
+      }
+      for (const typeTokens of typeTokensList) {
+        setOffset(
+          tokenStore.getTokensBetween(lastToken, typeTokens.firstToken),
+          offset,
+          firstToken
+        )
+        setOffset(typeTokens.firstToken, offset, firstToken)
       }
-      processNodeList(
-        types,
-        firstToken,
-        null,
-        isBeginningOfLine(firstToken) ? 0 : 1
-      )
     },
     TSParenthesizedType(node) {
       // (T)
@@ -1253,12 +1314,4 @@ function defineVisitor({
     // ----------------------------------------------------------------------
     TSLiteralType() {}
   }
-  /**
-   * Check whether the given node or token is the beginning of a line.
-   * @param {MaybeNode} node
-   */
-  function isBeginningOfLine(node) {
-    const prevToken = tokenStore.getTokenBefore(node, { includeComments: true })
-    return !prevToken || prevToken.loc.end.line < node.loc.start.line
-  }
 }
diff --git a/lib/utils/index.js b/lib/utils/index.js
index 06ef51420..b697a0d6b 100644
--- a/lib/utils/index.js
+++ b/lib/utils/index.js
@@ -12,70 +12,12 @@
  * @typedef {import('eslint').Rule.CodePathSegment} CodePathSegment
  */
 /**
- * @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 {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 {import('../../typings/eslint-plugin-vue/util-types/utils').ComponentArrayProp} ComponentArrayProp
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').ComponentObjectProp} ComponentObjectProp
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').ComponentTypeProp} ComponentTypeProp
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').ComponentArrayEmit} ComponentArrayEmit
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').ComponentObjectEmit} ComponentObjectEmit
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').ComponentTypeEmit} ComponentTypeEmit
  */
 /**
  * @typedef { {key: string | null, value: BlockStatement | null} } ComponentComputedProperty
@@ -90,6 +32,7 @@
  * @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
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').ScriptSetupVisitor} ScriptSetupVisitor
  */
 
 // ------------------------------------------------------------------------------
@@ -99,10 +42,20 @@
 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 VUE2_BUILTIN_COMPONENT_NAMES = new Set(
+  require('./vue2-builtin-components')
+)
+const VUE3_BUILTIN_COMPONENT_NAMES = new Set(
+  require('./vue3-builtin-components')
+)
 const path = require('path')
 const vueEslintParser = require('vue-eslint-parser')
 const traverseNodes = vueEslintParser.AST.traverseNodes
 const { findVariable } = require('eslint-utils')
+const {
+  getComponentPropsFromTypeDefine,
+  getComponentEmitsFromTypeDefine
+} = require('./ts-ast-utils')
 
 /**
  * @type { WeakMap<RuleContext, Token[]> }
@@ -277,6 +230,7 @@ module.exports = {
    * @param {RuleContext} context The rule context to use parser services.
    * @param {TemplateListener} templateBodyVisitor The visitor to traverse the template body.
    * @param {RuleListener} [scriptVisitor] The visitor to traverse the script.
+   * @param { { templateBodyTriggerSelector: "Program" | "Program:exit" } } [options] The options.
    * @returns {RuleListener} The merged visitor.
    */
   defineTemplateBodyVisitor,
@@ -399,28 +353,6 @@ module.exports = {
     return null
   },
 
-  /**
-   * Check whether the given start tag has specific directive.
-   * @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) {
-    return Boolean(this.getAttribute(node, name, value))
-  },
-
-  /**
-   * Check whether the given start tag has specific directive.
-   * @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) {
-    return Boolean(this.getDirective(node, name, argument))
-  },
-
   /**
    * Check whether the given directive attribute has their empty value (`=""`).
    * @param {VDirective} node The directive attribute node to check.
@@ -508,24 +440,16 @@ module.exports = {
    * @param {string} [value] The attribute value to check.
    * @returns {VAttribute | null} The found attribute.
    */
-  getAttribute(node, name, 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
-    )
-  },
+  getAttribute,
+
+  /**
+   * Check whether the given start tag has specific directive.
+   * @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,
 
   /**
    * Get the directive list which has the given name.
@@ -533,19 +457,7 @@ module.exports = {
    * @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
-      }
-    )
-  },
+  getDirectives,
   /**
    * Get the directive which has the given name.
    * @param {VElement} node The start tag node to check.
@@ -553,26 +465,16 @@ module.exports = {
    * @param {string} [argument] The directive argument to check.
    * @returns {VDirective | null} The found directive.
    */
-  getDirective(node, 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
-    )
-  },
+  getDirective,
+
+  /**
+   * Check whether the given start tag has specific directive.
+   * @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,
 
   /**
    * Returns the list of all registered components
@@ -636,13 +538,13 @@ module.exports = {
     for (const childNode of node.children) {
       if (childNode.type === 'VElement') {
         let connected
-        if (this.hasDirective(childNode, 'if')) {
+        if (hasDirective(childNode, 'if')) {
           connected = false
           vIf = true
-        } else if (this.hasDirective(childNode, 'else-if')) {
+        } else if (hasDirective(childNode, 'else-if')) {
           connected = vIf
           vIf = true
-        } else if (this.hasDirective(childNode, 'else')) {
+        } else if (hasDirective(childNode, 'else')) {
           connected = vIf
           vIf = false
         } else {
@@ -678,9 +580,9 @@ module.exports = {
         !this.isHtmlWellKnownElementName(node.rawName)) ||
       (this.isSvgElementNode(node) &&
         !this.isSvgWellKnownElementName(node.rawName)) ||
-      this.hasAttribute(node, 'is') ||
-      this.hasDirective(node, 'bind', 'is') ||
-      this.hasDirective(node, 'is')
+      hasAttribute(node, 'is') ||
+      hasDirective(node, 'bind', 'is') ||
+      hasDirective(node, 'is')
     )
   },
 
@@ -737,6 +639,44 @@ module.exports = {
   isHtmlVoidElementName(name) {
     return VOID_ELEMENT_NAMES.has(name)
   },
+
+  /**
+   * Check whether the given name is Vue builtin component name or not.
+   * @param {string} name The name to check.
+   * @returns {boolean} `true` if the name is a builtin component name
+   */
+  isBuiltInComponentName(name) {
+    return (
+      VUE3_BUILTIN_COMPONENT_NAMES.has(name) ||
+      VUE2_BUILTIN_COMPONENT_NAMES.has(name)
+    )
+  },
+
+  /**
+   * Check whether the given name is Vue builtin directive name or not.
+   * @param {string} name The name to check.
+   * @returns {boolean} `true` if the name is a builtin Directive name
+   */
+  isBuiltInDirectiveName(name) {
+    return (
+      name === 'bind' ||
+      name === 'on' ||
+      name === 'text' ||
+      name === 'html' ||
+      name === 'show' ||
+      name === 'if' ||
+      name === 'else' ||
+      name === 'else-if' ||
+      name === 'for' ||
+      name === 'model' ||
+      name === 'slot' ||
+      name === 'pre' ||
+      name === 'cloak' ||
+      name === 'once' ||
+      name === 'is'
+    )
+  },
+
   /**
    * Gets the property name of a given node.
    * @param {Property|AssignmentProperty|MethodDefinition|MemberExpression} node - The node to get.
@@ -774,49 +714,7 @@ module.exports = {
       return []
     }
 
-    if (propsNode.value.type === 'ObjectExpression') {
-      return propsNode.value.properties.filter(isProperty).map((prop) => {
-        const propName = getStaticPropertyName(prop)
-        if (propName != null) {
-          return {
-            type: 'object',
-            key: prop.key,
-            propName,
-            value: skipTSAsExpression(prop.value),
-            node: prop
-          }
-        }
-        return {
-          type: 'object',
-          key: null,
-          propName: null,
-          value: skipTSAsExpression(prop.value),
-          node: prop
-        }
-      })
-    } else {
-      return propsNode.value.elements.filter(isDef).map((prop) => {
-        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 {
-          type: 'array',
-          key: null,
-          propName: null,
-          value: null,
-          node: prop
-        }
-      })
-    }
+    return getComponentPropsFromDefine(propsNode.value)
   },
 
   /**
@@ -844,49 +742,7 @@ module.exports = {
       return []
     }
 
-    if (emitsNode.value.type === 'ObjectExpression') {
-      return emitsNode.value.properties.filter(isProperty).map((prop) => {
-        const emitName = getStaticPropertyName(prop)
-        if (emitName != null) {
-          return {
-            type: 'object',
-            key: prop.key,
-            emitName,
-            value: skipTSAsExpression(prop.value),
-            node: prop
-          }
-        }
-        return {
-          type: 'object',
-          key: null,
-          emitName: null,
-          value: skipTSAsExpression(prop.value),
-          node: prop
-        }
-      })
-    } else {
-      return emitsNode.value.elements.filter(isDef).map((prop) => {
-        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 {
-          type: 'array',
-          key: null,
-          emitName: null,
-          value: null,
-          node: prop
-        }
-      })
-    }
+    return getComponentEmitsFromDefine(emitsNode.value)
   },
 
   /**
@@ -978,6 +834,18 @@ module.exports = {
 
   isVueFile,
 
+  /**
+   * Checks whether the current file is uses `<script setup>`
+   * @param {RuleContext} context The ESLint rule context object.
+   */
+  isScriptSetup,
+  /**
+   * Gets the element of `<script setup>`
+   * @param {RuleContext} context The ESLint rule context object.
+   * @returns {VElement | null} the element of `<script setup>`
+   */
+  getScriptSetupElement,
+
   /**
    * Check if current file is a Vue instance or component and call callback
    * @param {RuleContext} context The ESLint rule context object.
@@ -1066,7 +934,12 @@ module.exports = {
         vueStack = vueStack.parent
       }
     }
-    if (visitor.onSetupFunctionEnter || visitor.onRenderFunctionEnter) {
+    if (
+      visitor.onSetupFunctionEnter ||
+      visitor.onSetupFunctionExit ||
+      visitor.onRenderFunctionEnter
+    ) {
+      const setups = new Set()
       /** @param { (FunctionExpression | ArrowFunctionExpression) & { parent: Property } } node */
       vueVisitor[
         'Property[value.type=/^(Arrow)?FunctionExpression$/] > :function'
@@ -1077,6 +950,7 @@ module.exports = {
           const name = getStaticPropertyName(prop)
           if (name === 'setup') {
             callVisitor('onSetupFunctionEnter', node)
+            setups.add(node)
           } else if (name === 'render') {
             callVisitor('onRenderFunctionEnter', node)
           }
@@ -1086,11 +960,236 @@ module.exports = {
           node
         )
       }
+      if (visitor.onSetupFunctionExit) {
+        /** @param { (FunctionExpression | ArrowFunctionExpression) & { parent: Property } } node */
+        vueVisitor[
+          'Property[value.type=/^(Arrow)?FunctionExpression$/] > :function:exit'
+        ] = (node) => {
+          if (setups.has(node)) {
+            callVisitor('onSetupFunctionExit', node)
+            setups.delete(node)
+          }
+        }
+      }
     }
 
     return vueVisitor
   },
 
+  /**
+   * Define handlers to traverse the AST nodes in `<script setup>`.
+   * Some special events are available to visitor.
+   *
+   * - `onDefinePropsEnter` ... Event when defineProps is found.
+   * - `onDefinePropsExit` ... Event when defineProps visit ends.
+   * - `onDefineEmitsEnter` ... Event when defineEmits is found.
+   * - `onDefineEmitsExit` ... Event when defineEmits visit ends.
+   *
+   * @param {RuleContext} context The ESLint rule context object.
+   * @param {ScriptSetupVisitor} visitor The visitor to traverse the AST nodes.
+   */
+  defineScriptSetupVisitor(context, visitor) {
+    const scriptSetup = getScriptSetupElement(context)
+    if (scriptSetup == null) {
+      return {}
+    }
+    const scriptSetupRange = scriptSetup.range
+
+    /**
+     * @param {ESNode} node
+     */
+    function inScriptSetup(node) {
+      return (
+        scriptSetupRange[0] <= node.range[0] &&
+        node.range[1] <= scriptSetupRange[1]
+      )
+    }
+    /**
+     * @param {string} key
+     * @param {ESNode} node
+     * @param {any[]} args
+     */
+    function callVisitor(key, node, ...args) {
+      if (visitor[key]) {
+        if (inScriptSetup(node)) {
+          // @ts-expect-error
+          visitor[key](node, ...args)
+        }
+      }
+    }
+
+    /** @type {NodeListener} */
+    const scriptSetupVisitor = {}
+    for (const key in visitor) {
+      scriptSetupVisitor[key] = (node) => callVisitor(key, node)
+    }
+
+    /**
+     * @param {ESNode} node
+     * @returns {ObjectExpression | ArrayExpression | null}
+     */
+    function getObjectOrArray(node) {
+      if (node.type === 'ObjectExpression') {
+        return node
+      }
+      if (node.type === 'ArrayExpression') {
+        return node
+      }
+      if (node.type === 'Identifier') {
+        const variable = findVariable(context.getScope(), node)
+
+        if (variable != null && variable.defs.length === 1) {
+          const def = variable.defs[0]
+          if (
+            def.type === 'Variable' &&
+            def.parent.kind === 'const' &&
+            def.node.id.type === 'Identifier' &&
+            def.node.init
+          ) {
+            return getObjectOrArray(def.node.init)
+          }
+        }
+      }
+      return null
+    }
+
+    const hasPropsEvent =
+      visitor.onDefinePropsEnter || visitor.onDefinePropsExit
+    const hasEmitsEvent =
+      visitor.onDefineEmitsEnter || visitor.onDefineEmitsExit
+    if (hasPropsEvent || hasEmitsEvent) {
+      /** @type {Expression | null} */
+      let candidateMacro = null
+      /** @param {VariableDeclarator|ExpressionStatement} node */
+      scriptSetupVisitor[
+        'Program > VariableDeclaration > VariableDeclarator, Program > ExpressionStatement'
+      ] = (node) => {
+        if (!candidateMacro) {
+          candidateMacro =
+            node.type === 'VariableDeclarator' ? node.init : node.expression
+        }
+      }
+      /** @param {VariableDeclarator|ExpressionStatement} node */
+      scriptSetupVisitor[
+        'Program > VariableDeclaration > VariableDeclarator, Program > ExpressionStatement:exit'
+      ] = (node) => {
+        if (
+          candidateMacro ===
+          (node.type === 'VariableDeclarator' ? node.init : node.expression)
+        ) {
+          candidateMacro = null
+        }
+      }
+      const definePropsMap = new Map()
+      const defineEmitsMap = new Map()
+      /**
+       * @param {CallExpression} node
+       */
+      scriptSetupVisitor.CallExpression = (node) => {
+        if (
+          candidateMacro &&
+          inScriptSetup(node) &&
+          node.callee.type === 'Identifier'
+        ) {
+          if (
+            hasPropsEvent &&
+            (candidateMacro === node ||
+              candidateMacro === getWithDefaults(node)) &&
+            node.callee.name === 'defineProps'
+          ) {
+            /** @type {(ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]} */
+            let props = []
+            if (node.arguments.length >= 1) {
+              const defNode = getObjectOrArray(node.arguments[0])
+              if (defNode) {
+                props = getComponentPropsFromDefine(defNode)
+              }
+            } else if (
+              node.typeParameters &&
+              node.typeParameters.params.length >= 1
+            ) {
+              props = getComponentPropsFromTypeDefine(
+                context,
+                node.typeParameters.params[0]
+              )
+            }
+            callVisitor('onDefinePropsEnter', node, props)
+            definePropsMap.set(node, props)
+          } else if (
+            hasEmitsEvent &&
+            candidateMacro === node &&
+            node.callee.name === 'defineEmits'
+          ) {
+            /** @type {(ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]} */
+            let emits = []
+            if (node.arguments.length >= 1) {
+              const defNode = getObjectOrArray(node.arguments[0])
+              if (defNode) {
+                emits = getComponentEmitsFromDefine(defNode)
+              }
+            } else if (
+              node.typeParameters &&
+              node.typeParameters.params.length >= 1
+            ) {
+              emits = getComponentEmitsFromTypeDefine(
+                context,
+                node.typeParameters.params[0]
+              )
+            }
+            callVisitor('onDefineEmitsEnter', node, emits)
+            defineEmitsMap.set(node, emits)
+          }
+        }
+        callVisitor('CallExpression', node)
+      }
+      scriptSetupVisitor['CallExpression:exit'] = (node) => {
+        callVisitor('CallExpression:exit', node)
+        if (definePropsMap.has(node)) {
+          callVisitor('onDefinePropsExit', node, definePropsMap.get(node))
+          definePropsMap.delete(node)
+        }
+        if (defineEmitsMap.has(node)) {
+          callVisitor('onDefineEmitsExit', node, defineEmitsMap.get(node))
+          defineEmitsMap.delete(node)
+        }
+      }
+    }
+
+    return scriptSetupVisitor
+  },
+
+  /**
+   * Checks whether given defineProps call node has withDefaults.
+   * @param {CallExpression} node The node of defineProps
+   * @returns {node is CallExpression & { parent: CallExpression }}
+   */
+  hasWithDefaults,
+
+  /**
+   * Gets a map of the expressions defined in withDefaults.
+   * @param {CallExpression} node The node of defineProps
+   * @returns { { [key: string]: Expression | undefined } }
+   */
+  getWithDefaultsPropExpressions(node) {
+    const map = getWithDefaultsProps(node)
+
+    /** @type {Record<string, Expression | undefined>} */
+    const result = {}
+
+    for (const key of Object.keys(map)) {
+      const prop = map[key]
+      result[key] = prop && prop.value
+    }
+
+    return result
+  },
+  /**
+   * Gets a map of the property nodes defined in withDefaults.
+   * @param {CallExpression} node The node of defineProps
+   * @returns { { [key: string]: Property | undefined } }
+   */
+  getWithDefaultsProps,
+
   getVueObjectType,
   /**
    * Get the Vue component definition type from given node
@@ -1456,6 +1555,14 @@ module.exports = {
     }
     return dp[alen][blen]
   },
+  /**
+   * Checks whether the target node is within the given range.
+   * @param { [number, number] } range
+   * @param {ASTNode} target
+   */
+  inRange(range, target) {
+    return range[0] <= target.range[0] && target.range[1] <= range[1]
+  },
   /**
    * Checks whether the given node is Property.
    */
@@ -1668,12 +1775,14 @@ function isDef(v) {
  * @param {RuleContext} context The rule context to use parser services.
  * @param {TemplateListener} templateBodyVisitor The visitor to traverse the template body.
  * @param {RuleListener} [scriptVisitor] The visitor to traverse the script.
+ * @param { { templateBodyTriggerSelector: "Program" | "Program:exit" } } [options] The options.
  * @returns {RuleListener} The merged visitor.
  */
 function defineTemplateBodyVisitor(
   context,
   templateBodyVisitor,
-  scriptVisitor
+  scriptVisitor,
+  options
 ) {
   if (context.parserServices.defineTemplateBodyVisitor == null) {
     const filename = context.getFilename()
@@ -1688,7 +1797,8 @@ function defineTemplateBodyVisitor(
   }
   return context.parserServices.defineTemplateBodyVisitor(
     templateBodyVisitor,
-    scriptVisitor
+    scriptVisitor,
+    options
   )
 }
 
@@ -1956,6 +2066,39 @@ function isVueFile(path) {
   return path.endsWith('.vue') || path.endsWith('.jsx')
 }
 
+/**
+ * Checks whether the current file is uses `<script setup>`
+ * @param {RuleContext} context The ESLint rule context object.
+ */
+function isScriptSetup(context) {
+  return Boolean(getScriptSetupElement(context))
+}
+/**
+ * Gets the element of `<script setup>`
+ * @param {RuleContext} context The ESLint rule context object.
+ * @returns {VElement | null} the element of `<script setup>`
+ */
+function getScriptSetupElement(context) {
+  const df =
+    context.parserServices.getDocumentFragment &&
+    context.parserServices.getDocumentFragment()
+  if (!df) {
+    return null
+  }
+  const scripts = df.children
+    .filter(isVElement)
+    .filter((e) => e.name === 'script')
+  if (scripts.length === 2) {
+    return scripts.find((e) => hasAttribute(e, 'setup')) || null
+  } else {
+    const script = scripts[0]
+    if (script && hasAttribute(script, 'setup')) {
+      return script
+    }
+  }
+  return null
+}
+
 /**
  * Check whether the given node is a Vue component based
  * on the filename and default export type
@@ -2082,6 +2225,15 @@ function getVueObjectType(context, node) {
       isVueComponentFile(parent, filePath) &&
       skipTSAsExpression(parent.declaration) === node
     ) {
+      const scriptSetup = getScriptSetupElement(context)
+      if (
+        scriptSetup &&
+        scriptSetup.range[0] <= parent.range[0] &&
+        parent.range[1] <= scriptSetup.range[1]
+      ) {
+        // `export default` in `<script setup>`
+        return null
+      }
       return 'export'
     }
   } else if (parent.type === 'CallExpression') {
@@ -2151,3 +2303,254 @@ function* iterateWatchHandlerValues(property) {
     yield value
   }
 }
+
+/**
+ * Get the attribute which has the given name.
+ * @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 {VAttribute | null} The found attribute.
+ */
+function getAttribute(node, name, 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.
+ */
+function 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 {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 {VDirective | null} The found directive.
+ */
+function getDirective(node, 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
+  )
+}
+
+/**
+ * Check whether the given start tag has specific directive.
+ * @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.
+ */
+function hasAttribute(node, name, value) {
+  return Boolean(getAttribute(node, name, value))
+}
+
+/**
+ * Check whether the given start tag has specific directive.
+ * @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.
+ */
+function hasDirective(node, name, argument) {
+  return Boolean(getDirective(node, name, argument))
+}
+
+/**
+ * Checks whether given defineProps call node has withDefaults.
+ * @param {CallExpression} node The node of defineProps
+ * @returns {node is CallExpression & { parent: CallExpression }}
+ */
+function hasWithDefaults(node) {
+  return (
+    node.parent &&
+    node.parent.type === 'CallExpression' &&
+    node.parent.arguments[0] === node &&
+    node.parent.callee.type === 'Identifier' &&
+    node.parent.callee.name === 'withDefaults'
+  )
+}
+
+/**
+ * Get the withDefaults call node from given defineProps call node.
+ * @param {CallExpression} node The node of defineProps
+ * @returns {CallExpression | null}
+ */
+function getWithDefaults(node) {
+  return hasWithDefaults(node) ? node.parent : null
+}
+
+/**
+ * Gets a map of the property nodes defined in withDefaults.
+ * @param {CallExpression} node The node of defineProps
+ * @returns { { [key: string]: Property | undefined } }
+ */
+function getWithDefaultsProps(node) {
+  if (!hasWithDefaults(node)) {
+    return {}
+  }
+  const param = node.parent.arguments[1]
+  if (!param || param.type !== 'ObjectExpression') {
+    return {}
+  }
+
+  /** @type {Record<string, Property>} */
+  const result = {}
+
+  for (const prop of param.properties) {
+    if (prop.type !== 'Property') {
+      return {}
+    }
+    const name = getStaticPropertyName(prop)
+    if (name != null) {
+      result[name] = prop
+    }
+  }
+
+  return result
+}
+
+/**
+ * Get all props by looking at all component's properties
+ * @param {ObjectExpression|ArrayExpression} propsNode Object with props definition
+ * @return {(ComponentArrayProp | ComponentObjectProp)[]} Array of component props in format: [{key?: String, value?: ASTNode, node: ASTNod}]
+ */
+function getComponentPropsFromDefine(propsNode) {
+  if (propsNode.type === 'ObjectExpression') {
+    return propsNode.properties.filter(isProperty).map((prop) => {
+      const propName = getStaticPropertyName(prop)
+      if (propName != null) {
+        return {
+          type: 'object',
+          key: prop.key,
+          propName,
+          value: skipTSAsExpression(prop.value),
+          node: prop
+        }
+      }
+      return {
+        type: 'object',
+        key: null,
+        propName: null,
+        value: skipTSAsExpression(prop.value),
+        node: prop
+      }
+    })
+  } else {
+    return propsNode.elements.filter(isDef).map((prop) => {
+      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 {
+        type: 'array',
+        key: null,
+        propName: null,
+        value: null,
+        node: prop
+      }
+    })
+  }
+}
+
+/**
+ * Get all emits by looking at all component's properties
+ * @param {ObjectExpression|ArrayExpression} emitsNode Object with emits definition
+ * @return {(ComponentArrayEmit | ComponentObjectEmit)[]} Array of component emits
+ */
+function getComponentEmitsFromDefine(emitsNode) {
+  if (emitsNode.type === 'ObjectExpression') {
+    return emitsNode.properties.filter(isProperty).map((prop) => {
+      const emitName = getStaticPropertyName(prop)
+      if (emitName != null) {
+        return {
+          type: 'object',
+          key: prop.key,
+          emitName,
+          value: skipTSAsExpression(prop.value),
+          node: prop
+        }
+      }
+      return {
+        type: 'object',
+        key: null,
+        emitName: null,
+        value: skipTSAsExpression(prop.value),
+        node: prop
+      }
+    })
+  } else {
+    return emitsNode.elements.filter(isDef).map((emit) => {
+      if (emit.type === 'Literal' || emit.type === 'TemplateLiteral') {
+        const emitName = getStringLiteralValue(emit)
+        if (emitName != null) {
+          return {
+            type: 'array',
+            key: emit,
+            emitName,
+            value: null,
+            node: emit
+          }
+        }
+      }
+      return {
+        type: 'array',
+        key: null,
+        emitName: null,
+        value: null,
+        node: emit
+      }
+    })
+  }
+}
diff --git a/lib/utils/ts-ast-utils.js b/lib/utils/ts-ast-utils.js
new file mode 100644
index 000000000..f23a752e3
--- /dev/null
+++ b/lib/utils/ts-ast-utils.js
@@ -0,0 +1,288 @@
+const { findVariable } = require('eslint-utils')
+/**
+ * @typedef {import('@typescript-eslint/types').TSESTree.TypeNode} TypeNode
+ * @typedef {import('@typescript-eslint/types').TSESTree.TSInterfaceBody} TSInterfaceBody
+ * @typedef {import('@typescript-eslint/types').TSESTree.TSTypeLiteral} TSTypeLiteral
+ * @typedef {import('@typescript-eslint/types').TSESTree.Parameter} TSESTreeParameter
+ *
+ */
+/**
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').ComponentTypeProp} ComponentTypeProp
+ * @typedef {import('../../typings/eslint-plugin-vue/util-types/utils').ComponentTypeEmit} ComponentTypeEmit
+ */
+
+module.exports = {
+  getComponentPropsFromTypeDefine,
+  getComponentEmitsFromTypeDefine
+}
+
+/**
+ * @param {TypeNode} node
+ * @returns {node is TSTypeLiteral}
+ */
+function isTSTypeLiteral(node) {
+  return node.type === 'TSTypeLiteral'
+}
+/**
+ * @param {TypeNode} node
+ * @returns {node is TSFunctionType}
+ */
+function isTSFunctionType(node) {
+  return node.type === 'TSFunctionType'
+}
+
+/**
+ * Get all props by looking at all component's properties
+ * @param {RuleContext} context The ESLint rule context object.
+ * @param {TypeNode} propsNode Type with props definition
+ * @return {ComponentTypeProp[]} Array of component props
+ */
+function getComponentPropsFromTypeDefine(context, propsNode) {
+  /** @type {TSInterfaceBody | TSTypeLiteral|null} */
+  const defNode = resolveQualifiedType(context, propsNode, isTSTypeLiteral)
+  if (!defNode) {
+    return []
+  }
+  return [...extractRuntimeProps(context, defNode)]
+}
+
+/**
+ * Get all emits by looking at all component's properties
+ * @param {RuleContext} context The ESLint rule context object.
+ * @param {TypeNode} emitsNode Type with emits definition
+ * @return {ComponentTypeEmit[]} Array of component emits
+ */
+function getComponentEmitsFromTypeDefine(context, emitsNode) {
+  /** @type {TSInterfaceBody | TSTypeLiteral | TSFunctionType | null} */
+  const defNode = resolveQualifiedType(
+    context,
+    emitsNode,
+    (n) => isTSTypeLiteral(n) || isTSFunctionType(n)
+  )
+  if (!defNode) {
+    return []
+  }
+  return [...extractRuntimeEmits(defNode)]
+}
+
+/**
+ * @see https://github.com/vuejs/vue-next/blob/253ca2729d808fc051215876aa4af986e4caa43c/packages/compiler-sfc/src/compileScript.ts#L1512
+ * @param {RuleContext} context The ESLint rule context object.
+ * @param {TSTypeLiteral | TSInterfaceBody} node
+ * @returns {IterableIterator<ComponentTypeProp>}
+ */
+function* extractRuntimeProps(context, node) {
+  const members = node.type === 'TSTypeLiteral' ? node.members : node.body
+  for (const m of members) {
+    if (
+      (m.type === 'TSPropertySignature' || m.type === 'TSMethodSignature') &&
+      m.key.type === 'Identifier'
+    ) {
+      let type
+      if (m.type === 'TSMethodSignature') {
+        type = ['Function']
+      } else if (m.typeAnnotation) {
+        type = inferRuntimeType(context, m.typeAnnotation.typeAnnotation)
+      }
+      yield {
+        type: 'type',
+        key: /** @type {Identifier} */ (m.key),
+        propName: m.key.name,
+        value: null,
+        node: /** @type {TSPropertySignature | TSMethodSignature} */ (m),
+
+        required: !m.optional,
+        types: type || [`null`]
+      }
+    }
+  }
+}
+
+/**
+ * @see https://github.com/vuejs/vue-next/blob/348c3b01e56383ffa70b180d1376fdf4ac12e274/packages/compiler-sfc/src/compileScript.ts#L1632
+ * @param {TSTypeLiteral | TSInterfaceBody | TSFunctionType} node
+ * @returns {IterableIterator<ComponentTypeEmit>}
+ */
+function* extractRuntimeEmits(node) {
+  if (node.type === 'TSTypeLiteral' || node.type === 'TSInterfaceBody') {
+    const members = node.type === 'TSTypeLiteral' ? node.members : node.body
+    for (const t of members) {
+      if (t.type === 'TSCallSignatureDeclaration') {
+        yield* extractEventNames(
+          t.params[0],
+          /** @type {TSCallSignatureDeclaration} */ (t)
+        )
+      }
+    }
+    return
+  } else {
+    yield* extractEventNames(node.params[0], node)
+  }
+
+  /**
+   * @param {TSESTreeParameter} eventName
+   * @param {TSCallSignatureDeclaration | TSFunctionType} member
+   * @returns {IterableIterator<ComponentTypeEmit>}
+   */
+  function* extractEventNames(eventName, member) {
+    if (
+      eventName &&
+      eventName.type === 'Identifier' &&
+      eventName.typeAnnotation &&
+      eventName.typeAnnotation.type === 'TSTypeAnnotation'
+    ) {
+      const typeNode = eventName.typeAnnotation.typeAnnotation
+      if (
+        typeNode.type === 'TSLiteralType' &&
+        typeNode.literal.type === 'Literal'
+      ) {
+        const emitName = String(typeNode.literal.value)
+        yield {
+          type: 'type',
+          key: /** @type {TSLiteralType} */ (typeNode),
+          emitName,
+          value: null,
+          node: member
+        }
+      } else if (typeNode.type === 'TSUnionType') {
+        for (const t of typeNode.types) {
+          if (t.type === 'TSLiteralType' && t.literal.type === 'Literal') {
+            const emitName = String(t.literal.value)
+            yield {
+              type: 'type',
+              key: /** @type {TSLiteralType} */ (t),
+              emitName,
+              value: null,
+              node: member
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @see https://github.com/vuejs/vue-next/blob/253ca2729d808fc051215876aa4af986e4caa43c/packages/compiler-sfc/src/compileScript.ts#L425
+ *
+ * @param {RuleContext} context The ESLint rule context object.
+ * @param {TypeNode} node
+ * @param {(n: TypeNode)=> boolean } qualifier
+ */
+function resolveQualifiedType(context, node, qualifier) {
+  if (qualifier(node)) {
+    return node
+  }
+  if (node.type === 'TSTypeReference' && node.typeName.type === 'Identifier') {
+    const refName = node.typeName.name
+    const variable = findVariable(context.getScope(), refName)
+    if (variable && variable.defs.length === 1) {
+      const def = variable.defs[0]
+      if (def.node.type === 'TSInterfaceDeclaration') {
+        return /** @type {any} */ (def.node).body
+      }
+      if (def.node.type === 'TSTypeAliasDeclaration') {
+        const typeAnnotation = /** @type {any} */ (def.node).typeAnnotation
+        return qualifier(typeAnnotation) ? typeAnnotation : null
+      }
+    }
+  }
+}
+
+/**
+ * @param {RuleContext} context The ESLint rule context object.
+ * @param {TypeNode} node
+ * @param {Set<TypeNode>} [checked]
+ * @returns {string[]}
+ */
+function inferRuntimeType(context, node, checked = new Set()) {
+  switch (node.type) {
+    case 'TSStringKeyword':
+      return ['String']
+    case 'TSNumberKeyword':
+      return ['Number']
+    case 'TSBooleanKeyword':
+      return ['Boolean']
+    case 'TSObjectKeyword':
+      return ['Object']
+    case 'TSTypeLiteral':
+      return ['Object']
+    case 'TSFunctionType':
+      return ['Function']
+    case 'TSArrayType':
+    case 'TSTupleType':
+      return ['Array']
+
+    case 'TSLiteralType':
+      switch (node.literal.type) {
+        //@ts-ignore ?
+        case 'StringLiteral':
+          return ['String']
+        //@ts-ignore ?
+        case 'BooleanLiteral':
+          return ['Boolean']
+        //@ts-ignore ?
+        case 'NumericLiteral':
+        //@ts-ignore ?
+        // eslint-disable-next-line no-fallthrough
+        case 'BigIntLiteral':
+          return ['Number']
+        default:
+          return [`null`]
+      }
+
+    case 'TSTypeReference':
+      if (node.typeName.type === 'Identifier') {
+        const variable = findVariable(context.getScope(), node.typeName.name)
+        if (variable && variable.defs.length === 1) {
+          const def = variable.defs[0]
+          if (def.node.type === 'TSInterfaceDeclaration') {
+            return [`Object`]
+          }
+          if (def.node.type === 'TSTypeAliasDeclaration') {
+            const typeAnnotation = /** @type {any} */ (def.node).typeAnnotation
+            if (!checked.has(typeAnnotation)) {
+              checked.add(typeAnnotation)
+              return inferRuntimeType(context, typeAnnotation, checked)
+            }
+          }
+        }
+        switch (node.typeName.name) {
+          case 'Array':
+          case 'Function':
+          case 'Object':
+          case 'Set':
+          case 'Map':
+          case 'WeakSet':
+          case 'WeakMap':
+            return [node.typeName.name]
+          case 'Record':
+          case 'Partial':
+          case 'Readonly':
+          case 'Pick':
+          case 'Omit':
+          case 'Exclude':
+          case 'Extract':
+          case 'Required':
+          case 'InstanceType':
+            return ['Object']
+        }
+      }
+      return [`null`]
+
+    case 'TSUnionType':
+      const set = new Set()
+      for (const t of node.types) {
+        for (const tt of inferRuntimeType(context, t, checked)) {
+          set.add(tt)
+        }
+      }
+      return [...set]
+
+    case 'TSIntersectionType':
+      return ['Object']
+
+    default:
+      return [`null`] // no runtime check
+  }
+}
diff --git a/lib/utils/vue2-builtin-components.js b/lib/utils/vue2-builtin-components.js
new file mode 100644
index 000000000..54acbc9e8
--- /dev/null
+++ b/lib/utils/vue2-builtin-components.js
@@ -0,0 +1,12 @@
+module.exports = [
+  'template',
+  'slot',
+  'component',
+  'Component',
+  'transition',
+  'Transition',
+  'transition-group',
+  'TransitionGroup',
+  'keep-alive',
+  'KeepAlive'
+]
diff --git a/lib/utils/vue3-builtin-components.js b/lib/utils/vue3-builtin-components.js
new file mode 100644
index 000000000..da000397b
--- /dev/null
+++ b/lib/utils/vue3-builtin-components.js
@@ -0,0 +1,7 @@
+module.exports = [
+  ...require('./vue2-builtin-components'),
+  'teleport',
+  'Teleport',
+  'suspense',
+  'Suspense'
+]
diff --git a/package.json b/package.json
index c7c7b10a7..f6feb58d4 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-vue",
-  "version": "7.12.1",
+  "version": "7.13.0",
   "description": "Official ESLint plugin for Vue.js",
   "main": "lib/index.js",
   "scripts": {
@@ -56,7 +56,7 @@
     "eslint-utils": "^2.1.0",
     "natural-compare": "^1.4.0",
     "semver": "^7.3.2",
-    "vue-eslint-parser": "^7.6.0"
+    "vue-eslint-parser": "^7.8.0"
   },
   "devDependencies": {
     "@types/eslint": "^7.2.0",
@@ -75,7 +75,7 @@
     "eslint-plugin-prettier": "^3.1.3",
     "eslint-plugin-vue": "file:.",
     "eslint4b": "^7.0.0",
-    "espree": "^8.0.0-0",
+    "espree": "^8.0.0",
     "lodash": "^4.17.15",
     "mocha": "^7.1.2",
     "nyc": "^15.0.1",
diff --git a/tests/fixtures/script-indent/ts-union-intersection-02.vue b/tests/fixtures/script-indent/ts-union-intersection-02.vue
new file mode 100644
index 000000000..04b722218
--- /dev/null
+++ b/tests/fixtures/script-indent/ts-union-intersection-02.vue
@@ -0,0 +1,21 @@
+<!--{"parserOptions": {"parser":"@typescript-eslint/parser"}}-->
+<script lang="ts">
+type T =
+  a
+  | b
+type U =
+  | a
+  | b
+type V =
+  a
+  & b
+type W =
+  & a
+  & b
+type X =
+  &
+  (
+    a
+    | b
+  )
+</script>
diff --git a/tests/fixtures/script-indent/ts-union-intersection-03.vue b/tests/fixtures/script-indent/ts-union-intersection-03.vue
new file mode 100644
index 000000000..78928f2e5
--- /dev/null
+++ b/tests/fixtures/script-indent/ts-union-intersection-03.vue
@@ -0,0 +1,19 @@
+<!--{"parserOptions": {"parser":"@typescript-eslint/parser"}}-->
+<script lang="ts">
+type T = a
+  | b
+  | c
+type U = | a
+  | b
+  | c
+type V = a
+  |
+  b
+  |
+  c
+const a = a
+  |
+  b
+  |
+  c
+</script>
diff --git a/tests/fixtures/script-indent/ts-union-intersection-04.vue b/tests/fixtures/script-indent/ts-union-intersection-04.vue
new file mode 100644
index 000000000..7396edc48
--- /dev/null
+++ b/tests/fixtures/script-indent/ts-union-intersection-04.vue
@@ -0,0 +1,17 @@
+<!--{"parserOptions": {"parser":"@typescript-eslint/parser"}}-->
+<script lang="ts">
+type T = U< a
+  | b
+  | c
+>
+type T = U<
+  | a
+  | b
+  | c
+>
+type T = U<
+  & a
+  & b
+  & c
+>
+</script>
diff --git a/tests/fixtures/script-indent/ts-union-intersection-05.vue b/tests/fixtures/script-indent/ts-union-intersection-05.vue
new file mode 100644
index 000000000..d6013535a
--- /dev/null
+++ b/tests/fixtures/script-indent/ts-union-intersection-05.vue
@@ -0,0 +1,19 @@
+<!--{"parserOptions": {"parser":"@typescript-eslint/parser"}}-->
+<script lang="ts">
+type T = U<
+  a
+    | b
+    | c,
+  a
+    | b
+    | c
+>
+type T = U<
+  a
+    & b
+    & c,
+  a
+    & b
+    & c
+>
+</script>
diff --git a/tests/fixtures/script-indent/ts-union-intersection-06.vue b/tests/fixtures/script-indent/ts-union-intersection-06.vue
new file mode 100644
index 000000000..a363a2847
--- /dev/null
+++ b/tests/fixtures/script-indent/ts-union-intersection-06.vue
@@ -0,0 +1,27 @@
+<!--{"parserOptions": {"parser":"@typescript-eslint/parser"}}-->
+<script lang="ts">
+type T = [
+  a
+    | b
+    | c
+]
+type U = [
+  | a
+    | b
+    | c
+]
+type T2 = [ a
+              | b
+              | c,
+            a
+              | b
+              | c
+]
+type U2 = [ | a
+              | b
+              | c,
+            | a
+              | b
+              | c
+]
+</script>
diff --git a/tests/lib/rules/custom-event-name-casing.js b/tests/lib/rules/custom-event-name-casing.js
index cd857b4ce..00b76e4ed 100644
--- a/tests/lib/rules/custom-event-name-casing.js
+++ b/tests/lib/rules/custom-event-name-casing.js
@@ -478,6 +478,22 @@ tester.run('custom-event-name-casing', rule, {
         "Custom event name 'bar-baz' must be camelCase.",
         "Custom event name 'baz-qux' must be camelCase."
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      const emit = defineEmits({})
+      emit('fooBar')
+      emit('foo-bar')
+      </script>
+      `,
+      errors: [
+        {
+          message: "Custom event name 'fooBar' must be kebab-case.",
+          line: 4
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/jsx-uses-vars.js b/tests/lib/rules/jsx-uses-vars.js
index 875fb9288..ea00e836c 100644
--- a/tests/lib/rules/jsx-uses-vars.js
+++ b/tests/lib/rules/jsx-uses-vars.js
@@ -30,10 +30,11 @@ linter.defineRule('jsx-uses-vars', rule)
 // Tests
 // ------------------------------------------------------------------------------
 
-ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
-  valid: [
-    {
-      code: `
+describe('jsx-uses-vars', () => {
+  ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
+    valid: [
+      {
+        code: `
         /* eslint jsx-uses-vars: 1 */
         import SomeComponent from './SomeComponent.jsx';
         export default {
@@ -44,9 +45,9 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
           },
         };
       `
-    },
-    {
-      code: `
+      },
+      {
+        code: `
         /* eslint jsx-uses-vars: 1 */
         import SomeComponent from './SomeComponent.vue';
         import OtherComponent from './OtherComponent.vue';
@@ -69,9 +70,9 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
           }
         }
       `
-    },
-    {
-      code: `
+      },
+      {
+        code: `
         /* eslint jsx-uses-vars: 1 */
         export default {
           render () {
@@ -81,12 +82,12 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
           }
         }
       `
-    }
-  ],
+      }
+    ],
 
-  invalid: [
-    {
-      code: `
+    invalid: [
+      {
+        code: `
         /* eslint jsx-uses-vars: 1 */
         import SomeComponent from './SomeComponent.jsx';
         export default {
@@ -95,14 +96,14 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
           },
         };
       `,
-      errors: [
-        {
-          message: "'SomeComponent' is defined but never used."
-        }
-      ]
-    },
-    {
-      code: `
+        errors: [
+          {
+            message: "'SomeComponent' is defined but never used."
+          }
+        ]
+      },
+      {
+        code: `
         /* eslint jsx-uses-vars: 1 */
         import SomeComponent from './SomeComponent.jsx';
         const wrapper = {
@@ -115,11 +116,12 @@ ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
           },
         };
       `,
-      errors: [
-        {
-          message: "'wrapper' is assigned a value but never used."
-        }
-      ]
-    }
-  ]
+        errors: [
+          {
+            message: "'wrapper' is assigned a value but never used."
+          }
+        ]
+      }
+    ]
+  })
 })
diff --git a/tests/lib/rules/no-async-in-computed-properties.js b/tests/lib/rules/no-async-in-computed-properties.js
index 2a15712cf..c54b833af 100644
--- a/tests/lib/rules/no-async-in-computed-properties.js
+++ b/tests/lib/rules/no-async-in-computed-properties.js
@@ -15,6 +15,7 @@ const parserOptions = {
   ecmaVersion: 2020,
   sourceType: 'module'
 }
+const parser = require.resolve('vue-eslint-parser')
 
 // ------------------------------------------------------------------------------
 // Tests
@@ -920,6 +921,207 @@ ruleTester.run('no-async-in-computed-properties', rule, {
           line: 5
         }
       ]
+    },
+
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {computed} from 'vue'
+      const test1 = computed(async () => {
+        return await someFunc()
+      })
+      const test2 = computed(async () => await someFunc())
+      const test3 = computed(async function () {
+        return await someFunc()
+      })
+      </script>
+      `,
+      parser,
+      parserOptions,
+      errors: [
+        {
+          message:
+            'Unexpected async function declaration in computed function.',
+          line: 4
+        },
+        {
+          message: 'Unexpected await operator in computed function.',
+          line: 5
+        },
+        {
+          message:
+            'Unexpected async function declaration in computed function.',
+          line: 7
+        },
+        {
+          message: 'Unexpected await operator in computed function.',
+          line: 7
+        },
+        {
+          message:
+            'Unexpected async function declaration in computed function.',
+          line: 8
+        },
+        {
+          message: 'Unexpected await operator in computed function.',
+          line: 9
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {computed} from 'vue'
+      const test = computed(async () => {
+        return new Promise((resolve, reject) => {})
+      })
+      </script>
+      `,
+      parser,
+      parserOptions,
+      errors: [
+        {
+          message:
+            'Unexpected async function declaration in computed function.',
+          line: 4
+        },
+        {
+          message: 'Unexpected Promise object in computed function.',
+          line: 5
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {computed} from 'vue'
+      const test1 = computed(() => {
+        return bar.then(response => {})
+      })
+      const test2 = computed(() => {
+        return Promise.all([])
+      })
+      </script>
+      `,
+      parser,
+      parserOptions,
+      errors: [
+        {
+          message: 'Unexpected asynchronous action in computed function.',
+          line: 5
+        },
+        {
+          message: 'Unexpected asynchronous action in computed function.',
+          line: 8
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {computed} from 'vue'
+      const test1 = computed({
+        get: () => {
+          return Promise.resolve([])
+        }
+      })
+      const test2 = computed({
+        get() {
+          return Promise.resolve([])
+        }
+      })
+      </script>
+      `,
+      parser,
+      parserOptions,
+      errors: [
+        {
+          message: 'Unexpected asynchronous action in computed function.',
+          line: 6
+        },
+        {
+          message: 'Unexpected asynchronous action in computed function.',
+          line: 11
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {computed} from 'vue'
+      const test = computed(() => {
+        setTimeout(() => { }, 0)
+        window.setTimeout(() => { }, 0)
+        setInterval(() => { }, 0)
+        window.setInterval(() => { }, 0)
+        setImmediate(() => { })
+        window.setImmediate(() => { })
+        requestAnimationFrame(() => {})
+        window.requestAnimationFrame(() => {})
+      })
+      </script>
+      `,
+      parser,
+      parserOptions,
+      errors: [
+        {
+          message: 'Unexpected timed function in computed function.',
+          line: 5
+        },
+        {
+          message: 'Unexpected timed function in computed function.',
+          line: 6
+        },
+        {
+          message: 'Unexpected timed function in computed function.',
+          line: 7
+        },
+        {
+          message: 'Unexpected timed function in computed function.',
+          line: 8
+        },
+        {
+          message: 'Unexpected timed function in computed function.',
+          line: 9
+        },
+        {
+          message: 'Unexpected timed function in computed function.',
+          line: 10
+        },
+        {
+          message: 'Unexpected timed function in computed function.',
+          line: 11
+        },
+        {
+          message: 'Unexpected timed function in computed function.',
+          line: 12
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {computed} from 'vue'
+      const test = computed(async () => {
+        bar()
+      })
+      </script>
+      `,
+      parser,
+      parserOptions,
+      errors: [
+        {
+          message:
+            'Unexpected async function declaration in computed function.',
+          line: 4
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/no-boolean-default.js b/tests/lib/rules/no-boolean-default.js
index 7421a049d..ef1af7925 100644
--- a/tests/lib/rules/no-boolean-default.js
+++ b/tests/lib/rules/no-boolean-default.js
@@ -8,6 +8,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
+const semver = require('semver')
 const rule = require('../../../lib/rules/no-boolean-default')
 
 const RuleTester = require('eslint').RuleTester
@@ -229,6 +230,102 @@ ruleTester.run('no-boolean-default', rule, {
         }
       `,
       options: ['default-false']
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: {
+          type:Boolean
+        }
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser')
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: {
+          type:Boolean,
+          default: false
+        }
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      options: ['default-false']
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: boolean
+      }
+      withDefaults(defineProps<Props>(), {
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        parser: require.resolve('@typescript-eslint/parser')
+      }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: boolean
+      }
+      withDefaults(defineProps<Props>(), {
+        foo: false
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      options: ['default-false']
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: boolean | string
+      }
+      withDefaults(defineProps<Props>(), {
+        foo: false
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        parser: require.resolve('@typescript-eslint/parser')
+      }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: string
+      }
+      withDefaults(defineProps<Props>(), {
+        foo: false
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        parser: require.resolve('@typescript-eslint/parser')
+      }
     }
   ],
 
@@ -314,6 +411,103 @@ ruleTester.run('no-boolean-default', rule, {
           line: 6
         }
       ]
-    }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: {
+          type:Boolean,
+          default: false
+        }
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [
+        {
+          message:
+            'Boolean prop should not set a default (Vue defaults it to false).',
+          line: 6
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: {
+          type:Boolean,
+          default: true
+        }
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      options: ['default-false'],
+      errors: [
+        {
+          message: 'Boolean prop should only be defaulted to false.',
+          line: 6
+        }
+      ]
+    },
+    ...(semver.lt(
+      require('@typescript-eslint/parser/package.json').version,
+      '4.0.0'
+    )
+      ? []
+      : [
+          {
+            filename: 'test.vue',
+            code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: boolean
+      }
+      withDefaults(defineProps<Props>(), {
+        foo: false
+      })
+      </script>
+      `,
+            parser: require.resolve('vue-eslint-parser'),
+            parserOptions: {
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            errors: [
+              {
+                message:
+                  'Boolean prop should not set a default (Vue defaults it to false).',
+                line: 7
+              }
+            ]
+          },
+          {
+            filename: 'test.vue',
+            code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: boolean
+      }
+      withDefaults(defineProps<Props>(), {
+        foo: true
+      })
+      </script>
+      `,
+            parser: require.resolve('vue-eslint-parser'),
+            parserOptions: {
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            options: ['default-false'],
+            errors: [
+              {
+                message: 'Boolean prop should only be defaulted to false.',
+                line: 7
+              }
+            ]
+          }
+        ])
   ]
 })
diff --git a/tests/lib/rules/no-export-in-script-setup.js b/tests/lib/rules/no-export-in-script-setup.js
new file mode 100644
index 000000000..5bc759f4c
--- /dev/null
+++ b/tests/lib/rules/no-export-in-script-setup.js
@@ -0,0 +1,107 @@
+/**
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const eslint = require('eslint')
+const rule = require('../../../lib/rules/no-export-in-script-setup')
+
+const RuleTester = eslint.RuleTester
+const ruleTester = new RuleTester({
+  parser: require.resolve('vue-eslint-parser'),
+  parserOptions: {
+    ecmaVersion: 6,
+    sourceType: 'module'
+  }
+})
+
+// ------------------------------------------------------------------------------
+// Tests
+// ------------------------------------------------------------------------------
+
+ruleTester.run('no-export-in-script-setup', rule, {
+  valid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <script>
+      export * from 'foo'
+      export default {}
+      export class A {}
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script>
+      export * from 'foo'
+      export default {}
+      export class A {}
+      </script>
+      <script setup>
+      let foo;
+      </script>
+      `
+    }
+  ],
+
+  invalid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      export * from 'foo'
+      export default {}
+      export class A {}
+      </script>
+      `,
+      errors: [
+        {
+          message: '`<script setup>` cannot contain ES module exports.',
+          line: 3
+        },
+        {
+          message: '`<script setup>` cannot contain ES module exports.',
+          line: 4
+        },
+        {
+          message: '`<script setup>` cannot contain ES module exports.',
+          line: 5
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script>
+      let foo;
+      </script>
+      <script setup>
+      export * from 'foo'
+      export default {}
+      export class A {}
+      </script>
+      `,
+      errors: [
+        {
+          message: '`<script setup>` cannot contain ES module exports.',
+          line: 6
+        },
+        {
+          message: '`<script setup>` cannot contain ES module exports.',
+          line: 7
+        },
+        {
+          message: '`<script setup>` cannot contain ES module exports.',
+          line: 8
+        }
+      ]
+    }
+  ]
+})
diff --git a/tests/lib/rules/no-lifecycle-after-await.js b/tests/lib/rules/no-lifecycle-after-await.js
index 17dfada47..9fc17f3ab 100644
--- a/tests/lib/rules/no-lifecycle-after-await.js
+++ b/tests/lib/rules/no-lifecycle-after-await.js
@@ -106,6 +106,43 @@ tester.run('no-lifecycle-after-await', rule, {
       }
       </script>
       `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {onMounted} from 'vue'
+      onMounted(() => { /* ... */ })
+      await doSomething()
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      await doSomething()
+      </script>
+      <script>
+      import {onMounted} from 'vue'
+      onMounted(() => { /* ... */ }) // not error
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      </script>
+      <script>
+      import {onMounted} from 'vue'
+      await doSomething()
+      onMounted(() => { /* ... */ }) // not error
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 }
     }
   ],
   invalid: [
@@ -224,6 +261,24 @@ tester.run('no-lifecycle-after-await', rule, {
           messageId: 'forbidden'
         }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {onMounted} from 'vue'
+      await doSomething()
+
+      onMounted(() => { /* ... */ }) // error
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 },
+      errors: [
+        {
+          messageId: 'forbidden',
+          line: 6
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/no-mutating-props.js b/tests/lib/rules/no-mutating-props.js
index e46ae0fd2..2dcc68c5b 100644
--- a/tests/lib/rules/no-mutating-props.js
+++ b/tests/lib/rules/no-mutating-props.js
@@ -291,6 +291,33 @@ ruleTester.run('no-mutating-props', rule, {
           }
         </script>
       `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+        <script>
+        // not <script setup>
+        const {value} = defineProps({
+          value: Object,
+        })
+        value.value++
+        </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+        <script>
+        // not <script setup>
+        const {value} = defineProps({
+          value: Object,
+        })
+        value.value++
+        </script>
+        <script setup>
+        value.value++
+        </script>
+      `
     }
   ],
 
@@ -698,6 +725,85 @@ ruleTester.run('no-mutating-props', rule, {
         </script>
       `,
       errors: ['Unexpected mutation of "[a]" prop.']
+    },
+
+    {
+      filename: 'test.vue',
+      code: `
+        <template>
+          <input v-model="value">
+          <input v-model="props.value">
+        </template>
+        <script setup>
+        const props = defineProps({
+          value: String,
+        })
+        </script>
+      `,
+      errors: [
+        {
+          message: 'Unexpected mutation of "value" prop.',
+          line: 3
+        },
+        {
+          message: 'Unexpected mutation of "props" prop.',
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+        <script setup>
+        const props = defineProps({
+          value: String,
+        })
+        props.value++
+        </script>
+      `,
+      errors: [
+        {
+          message: 'Unexpected mutation of "value" prop.',
+          line: 6
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+        <script setup>
+        const {value} = defineProps({
+          value: Object,
+        })
+        value.value++
+        </script>
+      `,
+      errors: [
+        {
+          message: 'Unexpected mutation of "value" prop.',
+          line: 6
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+        <script setup lang="ts">
+        const props = withDefaults(defineProps<Props>(), {
+          msg: 'hello'
+        })
+        props.value++
+        </script>
+      `,
+      parserOptions: {
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      errors: [
+        {
+          message: 'Unexpected mutation of "value" prop.',
+          line: 6
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/no-reserved-keys.js b/tests/lib/rules/no-reserved-keys.js
index fdd5e01f4..49857cd51 100644
--- a/tests/lib/rules/no-reserved-keys.js
+++ b/tests/lib/rules/no-reserved-keys.js
@@ -8,6 +8,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
+const semver = require('semver')
 const rule = require('../../../lib/rules/no-reserved-keys')
 const RuleTester = require('eslint').RuleTester
 
@@ -225,6 +226,94 @@ ruleTester.run('no-reserved-keys', rule, {
           line: 4
         }
       ]
-    }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        defineProps({
+          $el: String
+        })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: { ecmaVersion: 6 },
+      errors: [
+        {
+          message: "Key '$el' is reserved.",
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+        defineProps<{$el: string}>()
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        ecmaVersion: 6,
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      errors: [
+        {
+          message: "Key '$el' is reserved.",
+          line: 3
+        }
+      ]
+    },
+    ...(semver.lt(
+      require('@typescript-eslint/parser/package.json').version,
+      '4.0.0'
+    )
+      ? []
+      : [
+          {
+            filename: 'test.vue',
+            code: `
+      <script setup lang="ts">
+        interface Props {
+          $el: string
+        }
+        defineProps<Props>()
+      </script>
+      `,
+            parser: require.resolve('vue-eslint-parser'),
+            parserOptions: {
+              ecmaVersion: 6,
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            errors: [
+              {
+                message: "Key '$el' is reserved.",
+                line: 4
+              }
+            ]
+          },
+          {
+            filename: 'test.vue',
+            code: `
+      <script setup lang="ts">
+        type A = {
+          $el: string
+        }
+        defineProps<A>()
+      </script>
+      `,
+            parser: require.resolve('vue-eslint-parser'),
+            parserOptions: {
+              ecmaVersion: 6,
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            errors: [
+              {
+                message: "Key '$el' is reserved.",
+                line: 4
+              }
+            ]
+          }
+        ])
   ]
 })
diff --git a/tests/lib/rules/no-restricted-call-after-await.js b/tests/lib/rules/no-restricted-call-after-await.js
index 530e7cd39..92353eaf0 100644
--- a/tests/lib/rules/no-restricted-call-after-await.js
+++ b/tests/lib/rules/no-restricted-call-after-await.js
@@ -125,6 +125,18 @@ tester.run('no-restricted-call-after-await', rule, {
         { module: './baz', path: 'qux' },
         { module: 'vue-i18n', path: 'useI18n' }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {useI18n} from 'vue-i18n'
+      useI18n()
+      await doSomething()
+      </script>
+      `,
+      options: [{ module: 'vue-i18n', path: 'useI18n' }],
+      parserOptions: { ecmaVersion: 2022 }
     }
   ],
   invalid: [
@@ -377,6 +389,25 @@ tester.run('no-restricted-call-after-await', rule, {
           line: 7
         }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {useI18n} from 'vue-i18n'
+      await doSomething()
+      useI18n()
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 },
+      options: [{ module: 'vue-i18n', path: 'useI18n' }],
+      errors: [
+        {
+          message:
+            'The `import("vue-i18n").useI18n` after `await` expression are forbidden.',
+          line: 5
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/no-restricted-props.js b/tests/lib/rules/no-restricted-props.js
index 4206b4014..3348ca1a0 100644
--- a/tests/lib/rules/no-restricted-props.js
+++ b/tests/lib/rules/no-restricted-props.js
@@ -7,6 +7,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
+const semver = require('semver')
 const RuleTester = require('eslint').RuleTester
 const rule = require('../../../lib/rules/no-restricted-props')
 
@@ -326,6 +327,265 @@ tester.run('no-restricted-props', rule, {
           ]
         }
       ]
-    }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: {},
+      })
+      </script>
+      `,
+      options: [{ name: 'foo', suggest: 'Foo' }],
+      errors: [
+        {
+          message: 'Using `foo` props is not allowed.',
+          line: 4,
+          suggestions: [
+            {
+              desc: 'Instead, change to `Foo`.',
+              output: `
+      <script setup>
+      defineProps({
+        Foo: {},
+      })
+      </script>
+      `
+            }
+          ]
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps(['foo'])
+      </script>
+      `,
+      options: [{ name: 'foo', suggest: 'Foo' }],
+      errors: [
+        {
+          message: 'Using `foo` props is not allowed.',
+          line: 3,
+          suggestions: [
+            {
+              desc: 'Instead, change to `Foo`.',
+              output: `
+      <script setup>
+      defineProps(["Foo"])
+      </script>
+      `
+            }
+          ]
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      defineProps<{
+        foo:boolean
+      }>()
+      </script>
+      `,
+      parserOptions: {
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      options: [{ name: 'foo', suggest: 'Foo' }],
+      errors: [
+        {
+          message: 'Using `foo` props is not allowed.',
+          line: 4,
+          suggestions: [
+            {
+              desc: 'Instead, change to `Foo`.',
+              output: `
+      <script setup lang="ts">
+      defineProps<{
+        Foo:boolean
+      }>()
+      </script>
+      `
+            }
+          ]
+        }
+      ]
+    },
+    ...(semver.lt(
+      require('@typescript-eslint/parser/package.json').version,
+      '4.0.0'
+    )
+      ? []
+      : [
+          {
+            filename: 'test.vue',
+            code: `
+      <script setup lang="ts">
+      interface Props {
+        foo:boolean
+      }
+      defineProps<Props>()
+      </script>
+      `,
+            parserOptions: {
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            options: [{ name: 'foo', suggest: 'Foo' }],
+            errors: [
+              {
+                message: 'Using `foo` props is not allowed.',
+                line: 4,
+                suggestions: [
+                  {
+                    desc: 'Instead, change to `Foo`.',
+                    output: `
+      <script setup lang="ts">
+      interface Props {
+        Foo:boolean
+      }
+      defineProps<Props>()
+      </script>
+      `
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            filename: 'test.vue',
+            code: `
+      <script setup lang="ts">
+      interface Props {
+        foo:boolean
+      }
+      withDefaults(defineProps<Props>(),
+        {
+          foo: false
+        }
+      )
+      </script>
+      `,
+            parserOptions: {
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            options: [{ name: 'foo', suggest: 'Foo' }],
+            errors: [
+              {
+                message: 'Using `foo` props is not allowed.',
+                line: 4,
+                suggestions: [
+                  {
+                    desc: 'Instead, change to `Foo`.',
+                    output: `
+      <script setup lang="ts">
+      interface Props {
+        Foo:boolean
+      }
+      withDefaults(defineProps<Props>(),
+        {
+          Foo: false
+        }
+      )
+      </script>
+      `
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            filename: 'test.vue',
+            code: `
+      <script>
+      const foo = false
+      </script>
+      <script setup lang="ts">
+      interface Props {
+        foo:boolean
+      }
+      withDefaults(defineProps<Props>(),
+        {
+          foo
+        }
+      )
+      </script>
+      `,
+            parserOptions: {
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            options: [{ name: 'foo', suggest: 'Foo' }],
+            errors: [
+              {
+                message: 'Using `foo` props is not allowed.',
+                line: 7,
+                suggestions: [
+                  {
+                    desc: 'Instead, change to `Foo`.',
+                    output: `
+      <script>
+      const foo = false
+      </script>
+      <script setup lang="ts">
+      interface Props {
+        Foo:boolean
+      }
+      withDefaults(defineProps<Props>(),
+        {
+          Foo:foo
+        }
+      )
+      </script>
+      `
+                  }
+                ]
+              }
+            ]
+          },
+          {
+            filename: 'test.vue',
+            code: `
+      <script setup lang="ts">
+      withDefaults(defineProps<Props>(),
+        {
+          foo: false
+        }
+      )
+      interface Props {
+        foo:boolean
+      }
+      </script>
+      `,
+            parserOptions: {
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            options: [{ name: 'foo', suggest: 'Foo' }],
+            errors: [
+              {
+                message: 'Using `foo` props is not allowed.',
+                line: 9,
+                suggestions: [
+                  {
+                    desc: 'Instead, change to `Foo`.',
+                    output: `
+      <script setup lang="ts">
+      withDefaults(defineProps<Props>(),
+        {
+          Foo: false
+        }
+      )
+      interface Props {
+        Foo:boolean
+      }
+      </script>
+      `
+                  }
+                ]
+              }
+            ]
+          }
+        ])
   ]
 })
diff --git a/tests/lib/rules/no-setup-props-destructure.js b/tests/lib/rules/no-setup-props-destructure.js
index 781a3ce08..d990f8857 100644
--- a/tests/lib/rules/no-setup-props-destructure.js
+++ b/tests/lib/rules/no-setup-props-destructure.js
@@ -165,6 +165,46 @@ tester.run('no-setup-props-destructure', rule, {
       Vue.component('test', {
         el: a = b
       })`
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      const props = defineProps({count:Number})
+      watch(() => {
+        const {count} = props
+      })
+      watch(() => {
+        const count = props.count
+      })
+      </script>
+      `,
+      errors: [
+        {
+          messageId: 'getProperty',
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      const props = defineProps({count:Number})
+      watch(() => {
+        ({ count } = props)
+      })
+      watch(() => {
+        count = props.count
+      })
+      </script>
+      `,
+      errors: [
+        {
+          messageId: 'getProperty',
+          line: 4
+        }
+      ]
     }
   ],
   invalid: [
@@ -428,6 +468,63 @@ tester.run('no-setup-props-destructure', rule, {
           line: 5
         }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      const {count} = defineProps({count:Number})
+      </script>
+      `,
+      errors: [
+        {
+          message:
+            'Destructuring the `props` will cause the value to lose reactivity.',
+          line: 3
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      const props = defineProps({count:Number})
+      const {count} = props
+      ;({count} = props)
+      </script>
+      `,
+      errors: [
+        {
+          message:
+            'Getting a value from the `props` in root scope of `<script setup>` will cause the value to lose reactivity.',
+          line: 4
+        },
+        {
+          message:
+            'Getting a value from the `props` in root scope of `<script setup>` will cause the value to lose reactivity.',
+          line: 5
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      const props = defineProps({count:Number})
+      const count = props.count
+      count = props.count
+      </script>
+      `,
+      errors: [
+        {
+          messageId: 'getProperty',
+          line: 4
+        },
+        {
+          messageId: 'getProperty',
+          line: 5
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/no-side-effects-in-computed-properties.js b/tests/lib/rules/no-side-effects-in-computed-properties.js
index 647910d4a..7c4aabe95 100644
--- a/tests/lib/rules/no-side-effects-in-computed-properties.js
+++ b/tests/lib/rules/no-side-effects-in-computed-properties.js
@@ -591,6 +591,141 @@ ruleTester.run('no-side-effects-in-computed-properties', rule, {
           message: 'Unexpected side effect in computed function.'
         }
       ]
+    },
+
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {ref, computed} from 'vue'
+      const foo = useFoo()
+      const asd = { qwe: {} }
+      function a () {}
+      class A {}
+
+      const test1 = computed(() => {
+        foo.firstName = 'lorem'
+        asd.qwe.zxc = 'lorem'
+        return foo.firstName + ' ' + foo.lastName
+      })
+      const test2 = computed(() => {
+        foo.count += 2;
+        foo.count++;
+        return foo.count;
+      })
+      const test3 = computed(() => foo.something.reverse())
+      const test4 = computed(() => {
+        const test = foo.another.something.push('example')
+        return 'something'
+      })
+      const test5 = computed(() => {
+        foo.something[index] = foo.thing[index]
+        return foo.something
+      })
+      const test6 = computed(() => foo.something.keys.sort())
+      const test7 = computed({
+        get() {
+          return foo.something.reverse()
+        }
+      })
+      const test8 = computed(() => {
+        a.name = ''
+      })
+      const test9 = computed(() => {
+        A.name = ''
+      })
+      const test10 = computed(() => (foo.a = '', true))
+
+      const test100 = computed(() => {
+        const a = foo
+        a.count++ // false negative
+      })
+      </script>
+      `,
+      errors: [
+        {
+          line: 10,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 11,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 15,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 16,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 19,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 21,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 25,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 28,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 31,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 35,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 38,
+          message: 'Unexpected side effect in computed function.'
+        },
+        {
+          line: 40,
+          message: 'Unexpected side effect in computed function.'
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {reactive, computed} from 'vue'
+      const arr = reactive([])
+
+      const test1 = computed(() => arr.reverse())
+      </script>
+      `,
+      errors: [
+        {
+          line: 6,
+          message: 'Unexpected side effect in computed function.'
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script lang="ts" setup>
+      import {ref, computed} from 'vue'
+      const foo = useFoo()
+
+      const test1 = computed(() => foo.something.reverse())
+      </script>
+      `,
+      errors: [
+        {
+          line: 6,
+          message: 'Unexpected side effect in computed function.'
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/no-template-shadow.js b/tests/lib/rules/no-template-shadow.js
index 872dffcf1..1f1daa184 100644
--- a/tests/lib/rules/no-template-shadow.js
+++ b/tests/lib/rules/no-template-shadow.js
@@ -115,6 +115,54 @@ ruleTester.run('no-template-shadow', rule, {
           }
         }
       </script>`
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div v-for="i in 5">
+          <div v-for="j in 5">
+          </div>
+        </div>
+      </template>
+      <script>
+        export default {
+          setup() {
+            return {
+              k: 42
+            }
+          }
+        }
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div v-for="i in 5">
+          <div v-for="j in 5">
+          </div>
+        </div>
+      </template>
+      <script setup>
+      let k = 42
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div v-for="i in 5">
+          <div v-for="j in 5">
+          </div>
+        </div>
+      </template>
+      <script setup>
+      defineProps({k:Number})
+      </script>
+      `
     }
   ],
 
@@ -345,6 +393,72 @@ ruleTester.run('no-template-shadow', rule, {
           line: 7
         }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div v-for="i in 5">
+          <div v-for="j in 5">
+          </div>
+        </div>
+      </template>
+      <script>
+        export default {
+          setup() {
+            return {
+              j: 42
+            }
+          }
+        }
+      </script>
+      `,
+      errors: [
+        {
+          message: "Variable 'j' is already declared in the upper scope.",
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div v-for="i in 5">
+          <div v-for="j in 5">
+          </div>
+        </div>
+      </template>
+      <script setup>
+      let j = 42
+      </script>
+      `,
+      errors: [
+        {
+          message: "Variable 'j' is already declared in the upper scope.",
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div v-for="i in 5">
+          <div v-for="j in 5">
+          </div>
+        </div>
+      </template>
+      <script setup>
+      defineProps({j:Number})
+      </script>
+      `,
+      errors: [
+        {
+          message: "Variable 'j' is already declared in the upper scope.",
+          line: 4
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/no-unregistered-components.js b/tests/lib/rules/no-unregistered-components.js
index 6a51bf494..f120cde81 100644
--- a/tests/lib/rules/no-unregistered-components.js
+++ b/tests/lib/rules/no-unregistered-components.js
@@ -490,6 +490,17 @@ tester.run('no-unregistered-components', rule, {
         }
         </script>
       `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <TheModal />
+      </template>
+
+      <script setup>
+      import TheModal from 'foo'
+      </script>`
     }
   ],
   invalid: [
diff --git a/tests/lib/rules/no-unsupported-features/script-setup.js b/tests/lib/rules/no-unsupported-features/script-setup.js
new file mode 100644
index 000000000..584262364
--- /dev/null
+++ b/tests/lib/rules/no-unsupported-features/script-setup.js
@@ -0,0 +1,48 @@
+/**
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const RuleTester = require('eslint').RuleTester
+const rule = require('../../../../lib/rules/no-unsupported-features')
+const utils = require('./utils')
+
+const buildOptions = utils.optionsBuilder('script-setup', '^3.0.0')
+const tester = new RuleTester({
+  parser: require.resolve('vue-eslint-parser'),
+  parserOptions: {
+    ecmaVersion: 2019
+  }
+})
+
+tester.run('no-unsupported-features/script-setup', rule, {
+  valid: [
+    {
+      code: `
+      <script setup>
+      </script>`,
+      options: buildOptions()
+    },
+    {
+      code: `
+      <script>
+      </script>`,
+      options: buildOptions({ version: '^2.6.0' })
+    }
+  ],
+  invalid: [
+    {
+      code: `
+      <script setup>
+      </script>`,
+      options: buildOptions({ version: '^2.6.0' }),
+      errors: [
+        {
+          message: '`<script setup>` are not supported until Vue.js "3.0.0".',
+          line: 2
+        }
+      ]
+    }
+  ]
+})
diff --git a/tests/lib/rules/no-unused-properties.js b/tests/lib/rules/no-unused-properties.js
index e52a4bbf4..f9d61e4b0 100644
--- a/tests/lib/rules/no-unused-properties.js
+++ b/tests/lib/rules/no-unused-properties.js
@@ -2400,6 +2400,18 @@ tester.run('no-unused-properties', rule, {
         "'a' of data found, but never used.",
         "'b' of data found, but never used."
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        {{a}}
+      </template>
+      <script setup>
+      const props = defineProps(['a', 'b', 'c'])
+      props.b
+      </script>`,
+      errors: ["'c' of property found, but never used."]
     }
   ]
 })
diff --git a/tests/lib/rules/no-unused-refs.js b/tests/lib/rules/no-unused-refs.js
index 3deea4680..2547ef05d 100644
--- a/tests/lib/rules/no-unused-refs.js
+++ b/tests/lib/rules/no-unused-refs.js
@@ -284,6 +284,37 @@ tester.run('no-unused-refs', rule, {
       }
       </script>
       `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <input ref="x" />
+      </template>
+      <script>
+      import {ref} from 'vue'
+      export default {
+        setup() {
+          const x = ref(null)
+          return {
+            x
+          }
+        }
+      }
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <input ref="x" />
+      </template>
+      <script setup>
+      import {ref} from 'vue'
+      const x = ref(null)
+      </script>
+      `
     }
   ],
 
diff --git a/tests/lib/rules/no-watch-after-await.js b/tests/lib/rules/no-watch-after-await.js
index c7cf73150..ae5718672 100644
--- a/tests/lib/rules/no-watch-after-await.js
+++ b/tests/lib/rules/no-watch-after-await.js
@@ -118,6 +118,43 @@ tester.run('no-watch-after-await', rule, {
       }
       </script>
       `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {watchEffect} from 'vue'
+      watchEffect(() => { /* ... */ })
+      await doSomething()
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      await doSomething()
+      </script>
+      <script>
+      import {watchEffect} from 'vue'
+      watchEffect(() => { /* ... */ }) // not error
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      </script>
+      <script>
+      import {watchEffect} from 'vue'
+      await doSomething()
+      watchEffect(() => { /* ... */ }) // not error
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 }
     }
   ],
   invalid: [
@@ -199,6 +236,26 @@ tester.run('no-watch-after-await', rule, {
           line: 12
         }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      import {watch} from 'vue'
+      watch(foo, () => { /* ... */ })
+
+      await doSomething()
+
+      watch(foo, () => { /* ... */ })
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 2022 },
+      errors: [
+        {
+          message: 'The `watch` after `await` expression are forbidden.',
+          line: 8
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/prop-name-casing.js b/tests/lib/rules/prop-name-casing.js
index 4815c4ebf..4226e2dc8 100644
--- a/tests/lib/rules/prop-name-casing.js
+++ b/tests/lib/rules/prop-name-casing.js
@@ -8,6 +8,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
+const semver = require('semver')
 const rule = require('../../../lib/rules/prop-name-casing')
 const RuleTester = require('eslint').RuleTester
 
@@ -322,6 +323,44 @@ ruleTester.run('prop-name-casing', rule, {
       `,
       options: ['snake_case'],
       parserOptions
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        greetingText: String
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps(['greetingText'])
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      interface Props {
+        greetingText: number
+      }
+      defineProps<Props>()
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        ...parserOptions,
+        parser: require.resolve('@typescript-eslint/parser')
+      }
     }
   ],
 
@@ -580,6 +619,69 @@ ruleTester.run('prop-name-casing', rule, {
       `,
       parserOptions,
       errors: ['Prop "/greeting-text/" is not in camelCase.']
-    }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        greeting_text: String
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions,
+      errors: [
+        {
+          message: 'Prop "greeting_text" is not in camelCase.',
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps(['greeting_text'])
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions,
+      errors: [
+        {
+          message: 'Prop "greeting_text" is not in camelCase.',
+          line: 3
+        }
+      ]
+    },
+    ...(semver.lt(
+      require('@typescript-eslint/parser/package.json').version,
+      '4.0.0'
+    )
+      ? []
+      : [
+          {
+            filename: 'test.vue',
+            code: `
+            <script setup lang="ts">
+            interface Props {
+              greeting_text: number
+            }
+            defineProps<Props>()
+            </script>
+            `,
+            parser: require.resolve('vue-eslint-parser'),
+            parserOptions: {
+              ...parserOptions,
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            errors: [
+              {
+                message: 'Prop "greeting_text" is not in camelCase.',
+                line: 4
+              }
+            ]
+          }
+        ])
   ]
 })
diff --git a/tests/lib/rules/require-default-prop.js b/tests/lib/rules/require-default-prop.js
index dcd551560..d93c5e5da 100644
--- a/tests/lib/rules/require-default-prop.js
+++ b/tests/lib/rules/require-default-prop.js
@@ -8,6 +8,7 @@
 // Requirements
 // ------------------------------------------------------------------------------
 
+const semver = require('semver')
 const rule = require('../../../lib/rules/require-default-prop')
 const RuleTester = require('eslint').RuleTester
 const parserOptions = {
@@ -181,6 +182,14 @@ ruleTester.run('require-default-prop', rule, {
         }
       `
     },
+    {
+      filename: 'test.vue',
+      code: `
+      export default {
+        props: ['foo']
+      }`,
+      parserOptions
+    },
 
     // sparse array
     {
@@ -195,6 +204,83 @@ ruleTester.run('require-default-prop', rule, {
           }
         }
       `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: {
+          type: String,
+          default: ''
+        }
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps(['foo'])
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: number
+      }
+      defineProps<Props>()
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        ...parserOptions,
+        parser: require.resolve('@typescript-eslint/parser')
+      }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: number
+      }
+      withDefaults(defineProps<Props>(), {foo:42})
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        ...parserOptions,
+        parser: require.resolve('@typescript-eslint/parser')
+      }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      interface Props {
+        foo: number
+      }
+      defineProps<Props>({
+        foo:{
+          default: 42
+        }
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        ...parserOptions,
+        parser: require.resolve('@typescript-eslint/parser')
+      }
     }
   ],
 
@@ -387,6 +473,53 @@ ruleTester.run('require-default-prop', rule, {
         "Prop 'baz' requires default value to be set.",
         "Prop 'bar1' requires default value to be set."
       ]
-    }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: String
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions,
+      errors: [
+        {
+          message: "Prop 'foo' requires default value to be set.",
+          line: 4
+        }
+      ]
+    },
+    ...(semver.lt(
+      require('@typescript-eslint/parser/package.json').version,
+      '4.0.0'
+    )
+      ? []
+      : [
+          {
+            filename: 'test.vue',
+            code: `
+            <script setup lang="ts">
+            interface Props {
+              foo: number
+            }
+            withDefaults(defineProps<Props>(), {bar:42})
+            </script>
+            `,
+            parser: require.resolve('vue-eslint-parser'),
+            parserOptions: {
+              ...parserOptions,
+              parser: require.resolve('@typescript-eslint/parser')
+            },
+            errors: [
+              {
+                message: "Prop 'foo' requires default value to be set.",
+                line: 4
+              }
+            ]
+          }
+        ])
   ]
 })
diff --git a/tests/lib/rules/require-emit-validator.js b/tests/lib/rules/require-emit-validator.js
index 6c1170e95..b63248cd7 100644
--- a/tests/lib/rules/require-emit-validator.js
+++ b/tests/lib/rules/require-emit-validator.js
@@ -163,6 +163,20 @@ ruleTester.run('require-emit-validator', rule, {
         }
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      const emit = defineEmits<(e: 'foo')=>void>()
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      }
     }
   ],
 
@@ -325,6 +339,46 @@ ruleTester.run('require-emit-validator', rule, {
           line: 4
         }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      const emit = defineEmits(['foo'])
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module'
+      },
+      errors: [
+        {
+          messageId: 'missing',
+          data: { name: 'foo' },
+          line: 3
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      const emit = defineEmits({foo:null})
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module'
+      },
+      errors: [
+        {
+          messageId: 'skipped',
+          data: { name: 'foo' },
+          line: 3
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/require-explicit-emits.js b/tests/lib/rules/require-explicit-emits.js
index 6cf1cc6eb..1ea1758d2 100644
--- a/tests/lib/rules/require-explicit-emits.js
+++ b/tests/lib/rules/require-explicit-emits.js
@@ -394,6 +394,69 @@ tester.run('require-explicit-emits', rule, {
       </script>
       `,
       options: [{ allowProps: true }]
+    },
+
+    // <script setup>
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('foo')"/>
+      </template>
+      <script setup>
+      defineEmits(['foo'])
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('foo')"/>
+      </template>
+      <script setup>
+      defineEmits({foo:null})
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('foo')"/>
+      </template>
+      <script setup lang="ts">
+      defineEmits<{
+        (e: 'foo'): void
+      }>()
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('foo')"/>
+      </template>
+      <script setup lang="ts">
+      defineEmits<(e: 'foo') => void>()
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('foo')"/>
+        <div @click="$emit('bar')"/>
+      </template>
+      <script setup lang="ts">
+      defineEmits<(e: 'foo' | 'bar') => void>()
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') }
     }
   ],
   invalid: [
@@ -1607,6 +1670,145 @@ emits: {'foo': null}
           messageId: 'missing'
         }
       ]
+    },
+
+    // <script setup>
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('bar')"/>
+      </template>
+      <script setup>
+      defineEmits(['foo'])
+      </script>
+      `,
+      errors: [
+        {
+          message:
+            'The "bar" event has been triggered but not declared on `defineEmits`.',
+          line: 3,
+          suggestions: [
+            {
+              desc: 'Add the "bar" to `defineEmits`.',
+              output: `
+      <template>
+        <div @click="$emit('bar')"/>
+      </template>
+      <script setup>
+      defineEmits(['foo', 'bar'])
+      </script>
+      `
+            }
+          ]
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('bar')"/>
+      </template>
+      <script setup>
+      defineEmits({foo:null})
+      </script>
+      `,
+      errors: [
+        {
+          message:
+            'The "bar" event has been triggered but not declared on `defineEmits`.',
+          line: 3,
+          suggestions: [
+            {
+              desc: 'Add the "bar" to `defineEmits`.',
+              output: `
+      <template>
+        <div @click="$emit('bar')"/>
+      </template>
+      <script setup>
+      defineEmits({foo:null, 'bar': null})
+      </script>
+      `
+            }
+          ]
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('bar')"/>
+      </template>
+      <script setup lang="ts">
+      defineEmits<{
+        (e: 'foo'): void
+      }>()
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') },
+      errors: [
+        {
+          message:
+            'The "bar" event has been triggered but not declared on `defineEmits`.',
+          line: 3
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('bar')"/>
+      </template>
+      <script setup lang="ts">
+      defineEmits<(e: 'foo') => void>()
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') },
+      errors: [
+        {
+          message:
+            'The "bar" event has been triggered but not declared on `defineEmits`.',
+          line: 3
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+        <div @click="$emit('foo')"/>
+      </template>
+      <script setup>
+      </script>
+      `,
+      errors: [
+        {
+          message:
+            'The "foo" event has been triggered but not declared on `defineEmits`.',
+          line: 3
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      const emit = defineEmits<(e: 'foo') => void>()
+      emit('foo');
+      emit('bar')
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') },
+      errors: [
+        {
+          message:
+            'The "bar" event has been triggered but not declared on `defineEmits`.',
+          line: 5
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/require-name-property.js b/tests/lib/rules/require-name-property.js
index eae44a9ca..8f7200d63 100644
--- a/tests/lib/rules/require-name-property.js
+++ b/tests/lib/rules/require-name-property.js
@@ -51,6 +51,19 @@ ruleTester.run('require-name-property', rule, {
         })
       `,
       parserOptions
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script>
+      export default {
+      }
+      </script>
+      <script setup>
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      parserOptions
     }
   ],
 
diff --git a/tests/lib/rules/require-prop-type-constructor.js b/tests/lib/rules/require-prop-type-constructor.js
index 18ece4f55..452bb35aa 100644
--- a/tests/lib/rules/require-prop-type-constructor.js
+++ b/tests/lib/rules/require-prop-type-constructor.js
@@ -355,6 +355,36 @@ ruleTester.run('require-prop-type-constructor', rule, {
           line: 18
         }
       ]
+    },
+    {
+      filename: 'SomeComponent.vue',
+      code: `
+      <script setup>
+      defineProps({
+        a: {
+          type: 'String',
+          default: 'abc'
+        },
+      })
+      </script>
+      `,
+      output: `
+      <script setup>
+      defineProps({
+        a: {
+          type: String,
+          default: 'abc'
+        },
+      })
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [
+        {
+          message: 'The "a" property should be a constructor.',
+          line: 5
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/require-prop-types.js b/tests/lib/rules/require-prop-types.js
index 4d7d153b3..990126536 100644
--- a/tests/lib/rules/require-prop-types.js
+++ b/tests/lib/rules/require-prop-types.js
@@ -158,6 +158,32 @@ ruleTester.run('require-prop-types', rule, {
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       parser: require.resolve('@typescript-eslint/parser')
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: String
+      })
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser')
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      defineProps<{foo:string}>()
+      </script>
+      `,
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      parser: require.resolve('vue-eslint-parser')
     }
   ],
 
@@ -305,6 +331,40 @@ ruleTester.run('require-prop-types', rule, {
           line: 4
         }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps({
+        foo: {}
+      })
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [
+        {
+          message: 'Prop "foo" should define at least its type.',
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+      defineProps(['foo'])
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [
+        {
+          message: 'Prop "foo" should define at least its type.',
+          line: 3
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/require-valid-default-prop.js b/tests/lib/rules/require-valid-default-prop.js
index 836f06d5c..e353edf58 100644
--- a/tests/lib/rules/require-valid-default-prop.js
+++ b/tests/lib/rules/require-valid-default-prop.js
@@ -871,6 +871,49 @@ ruleTester.run('require-valid-default-prop', rule, {
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       parser: require.resolve('@typescript-eslint/parser'),
       errors: errorMessage('function')
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        defineProps({
+          foo: {
+            type: String,
+            default: () => 123
+          }
+        })
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [
+        {
+          message: "Type of the default value for 'foo' prop must be a string.",
+          line: 6
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        withDefaults(defineProps<{foo:string}>(),{
+          foo: () => 123
+        })
+      </script>
+      `,
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [
+        {
+          message: "Type of the default value for 'foo' prop must be a string.",
+          line: 4
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/return-in-emits-validator.js b/tests/lib/rules/return-in-emits-validator.js
index a1d3557ed..f47e8ca77 100644
--- a/tests/lib/rules/return-in-emits-validator.js
+++ b/tests/lib/rules/return-in-emits-validator.js
@@ -119,6 +119,18 @@ ruleTester.run('return-in-emits-validator', rule, {
         }
         </script>
       `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+        <script setup>
+        defineEmits({
+          foo () {
+            return true
+          }
+        })
+        </script>
+      `
     }
   ],
 
@@ -307,6 +319,24 @@ ruleTester.run('return-in-emits-validator', rule, {
           line: 5
         }
       ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+        <script setup>
+        defineEmits({
+          foo () {
+          }
+        })
+        </script>
+      `,
+      errors: [
+        {
+          message:
+            'Expected to return a boolean value in "foo" emits validator.',
+          line: 4
+        }
+      ]
     }
   ]
 })
diff --git a/tests/lib/rules/script-setup-uses-vars.js b/tests/lib/rules/script-setup-uses-vars.js
new file mode 100644
index 000000000..5d3c80060
--- /dev/null
+++ b/tests/lib/rules/script-setup-uses-vars.js
@@ -0,0 +1,311 @@
+/**
+ * @fileoverview Prevent `<script setup>` variables used in `<template>` to be marked as unused
+ * @author Yosuke Ota
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const eslint = require('eslint')
+const rule = require('../../../lib/rules/script-setup-uses-vars')
+const ruleNoUnusedVars = require('eslint/lib/rules/no-unused-vars')
+
+const RuleTester = eslint.RuleTester
+const ruleTester = new RuleTester({
+  parser: require.resolve('vue-eslint-parser'),
+  parserOptions: {
+    ecmaVersion: 6,
+    sourceType: 'module'
+  }
+})
+
+const linter = ruleTester.linter || eslint.linter
+linter.defineRule('script-setup-uses-vars', rule)
+
+// ------------------------------------------------------------------------------
+// Tests
+// ------------------------------------------------------------------------------
+
+describe('script-setup-uses-vars', () => {
+  ruleTester.run('no-unused-vars', ruleNoUnusedVars, {
+    valid: [
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          // imported components are also directly usable in template
+          import Foo from './Foo.vue'
+          import { ref } from 'vue'
+
+          // write Composition API code just like in a normal setup()
+          // but no need to manually return everything
+          const count = ref(0)
+          const inc = () => {
+            count.value++
+          }
+        </script>
+
+        <template>
+          <Foo :count="count" @click="inc" />
+        </template>
+        `
+      },
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          const msg = 'Hello!'
+        </script>
+
+        <template>
+          <div>{{ msg }}</div>
+        </template>
+        `
+      },
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          import Foo from './Foo.vue'
+          import MyComponent from './MyComponent.vue'
+        </script>
+
+        <template>
+          <Foo />
+          <!-- kebab-case also works -->
+          <my-component />
+        </template>
+        `
+      },
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          import Foo from './Foo.vue'
+          import Bar from './Bar.vue'
+        </script>
+
+        <template>
+          <component :is="Foo" />
+          <component :is="someCondition ? Foo : Bar" />
+        </template>
+        `
+      },
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          import { directive as vClickOutside } from 'v-click-outside'
+        </script>
+
+        <template>
+          <div v-click-outside />
+        </template>
+        `
+      },
+
+      // Resolve component name
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          import FooPascalCase from './component.vue'
+          import BarPascalCase from './component.vue'
+          import BazPascalCase from './component.vue'
+        </script>
+
+        <template>
+          <FooPascalCase />
+          <bar-pascal-case />
+          <bazPascalCase />
+        </template>
+        `
+      },
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          import fooCamelCase from './component.vue'
+          import barCamelCase from './component.vue'
+        </script>
+
+        <template>
+          <fooCamelCase />
+          <bar-camel-case />
+        </template>
+        `
+      },
+
+      // TopLevel await
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          const post = await fetch(\`/api/post/1\`).then((r) => r.json())
+        </script>
+
+        <template>
+          {{post}}
+        </template>
+        `,
+        parserOptions: {
+          ecmaVersion: 2022,
+          sourceType: 'module'
+        }
+      },
+
+      // ref
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          import {ref} from 'vue'
+          const v = ref(null)
+        </script>
+
+        <template>
+          <div ref="v"/>
+        </template>
+        `
+      }
+    ],
+
+    invalid: [
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          // imported components are also directly usable in template
+          import Foo from './Foo.vue'
+          import Bar from './Bar.vue'
+          import { ref } from 'vue'
+
+          // write Composition API code just like in a normal setup()
+          // but no need to manually return everything
+          const count = ref(0)
+          const inc = () => {
+            count.value++
+          }
+          const foo = ref(42)
+          console.log(foo.value)
+          const bar = ref(42)
+          bar.value++
+          const baz = ref(42)
+        </script>
+
+        <template>
+          <Foo :count="count" @click="inc" />
+        </template>
+        `,
+        errors: [
+          {
+            message: "'Bar' is defined but never used.",
+            line: 6
+          },
+          {
+            message: "'baz' is assigned a value but never used.",
+            line: 19
+          }
+        ]
+      },
+
+      // Resolve component name
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          import camelCase from './component.vue'
+        </script>
+
+        <template>
+          <CamelCase />
+        </template>
+        `,
+        errors: [
+          {
+            message: "'camelCase' is defined but never used.",
+            line: 4
+          }
+        ]
+      },
+
+      // Scope tests
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          if (a) {
+            const msg = 'Hello!'
+          }
+        </script>
+
+        <template>
+          <div>{{ msg }}</div>
+        </template>
+        `,
+        errors: [
+          {
+            message: "'msg' is assigned a value but never used.",
+            line: 5
+          }
+        ]
+      },
+      {
+        filename: 'test.vue',
+        code: `
+        <script setup>
+          /* eslint script-setup-uses-vars: 1 */
+          const i = 42
+          const list = [1,2,3]
+        </script>
+
+        <template>
+          <div v-for="i in list">{{ i }}</div>
+        </template>
+      `,
+        errors: [
+          {
+            message: "'i' is assigned a value but never used.",
+            line: 4
+          }
+        ]
+      },
+
+      // Not `<script setup>`
+      {
+        filename: 'test.vue',
+        code: `
+        <script>
+          /* eslint script-setup-uses-vars: 1 */
+          const msg = 'Hello!'
+        </script>
+
+        <template>
+          <div>{{ msg }}</div>
+        </template>
+        `,
+        errors: [
+          {
+            message: "'msg' is assigned a value but never used.",
+            line: 4
+          }
+        ]
+      }
+    ]
+  })
+})
diff --git a/tests/lib/rules/valid-define-emits.js b/tests/lib/rules/valid-define-emits.js
new file mode 100644
index 000000000..309375e94
--- /dev/null
+++ b/tests/lib/rules/valid-define-emits.js
@@ -0,0 +1,156 @@
+/**
+ * @author Yosuke Ota <https://github.com/ota-meshi>
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const RuleTester = require('eslint').RuleTester
+const rule = require('../../../lib/rules/valid-define-emits')
+
+// ------------------------------------------------------------------------------
+// Tests
+// ------------------------------------------------------------------------------
+
+const tester = new RuleTester({
+  parser: require.resolve('vue-eslint-parser'),
+  parserOptions: { ecmaVersion: 2015, sourceType: 'module' }
+})
+
+tester.run('valid-define-emits', rule, {
+  valid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✓ GOOD */
+        defineEmits({ notify: null })
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✓ GOOD */
+        defineEmits(['notify'])
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+        /* ✓ GOOD */
+        defineEmits<(e: 'notify')=>void>()
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script>
+        const def = { notify: null }
+      </script>
+      <script setup>
+        /* ✓ GOOD */
+        defineEmits(def)
+      </script>
+      `
+    }
+  ],
+  invalid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✗ BAD */
+        const def = { notify: null }
+        defineEmits(def)
+      </script>
+      `,
+      errors: [
+        {
+          message: '`defineEmits` are referencing locally declared variables.',
+          line: 5
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+        /* ✗ BAD */
+        defineEmits<(e: 'notify')=>void>({ submit: null })
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') },
+      errors: [
+        {
+          message: '`defineEmits` has both a type-only emit and an argument.',
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✗ BAD */
+        defineEmits({ notify: null })
+        defineEmits({ submit: null })
+      </script>
+      `,
+      errors: [
+        {
+          message: '`defineEmits` has been called multiple times.',
+          line: 4
+        },
+        {
+          message: '`defineEmits` has been called multiple times.',
+          line: 5
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script>
+      export default {
+        emits: ['notify']
+      }
+      </script>
+      <script setup>
+        /* ✗ BAD */
+        defineEmits({ submit: null })
+      </script>
+      `,
+      errors: [
+        {
+          message:
+            'Custom events are defined in both `defineEmits` and `export default {}`.',
+          line: 9
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✗ BAD */
+        defineEmits()
+      </script>
+      `,
+      errors: [
+        {
+          message: 'Custom events are not defined.',
+          line: 4
+        }
+      ]
+    }
+  ]
+})
diff --git a/tests/lib/rules/valid-define-props.js b/tests/lib/rules/valid-define-props.js
new file mode 100644
index 000000000..0bd49f171
--- /dev/null
+++ b/tests/lib/rules/valid-define-props.js
@@ -0,0 +1,156 @@
+/**
+ * @author Yosuke Ota <https://github.com/ota-meshi>
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const RuleTester = require('eslint').RuleTester
+const rule = require('../../../lib/rules/valid-define-props')
+
+// ------------------------------------------------------------------------------
+// Tests
+// ------------------------------------------------------------------------------
+
+const tester = new RuleTester({
+  parser: require.resolve('vue-eslint-parser'),
+  parserOptions: { ecmaVersion: 2015, sourceType: 'module' }
+})
+
+tester.run('valid-define-props', rule, {
+  valid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✓ GOOD */
+        defineProps({ msg: String })
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✓ GOOD */
+        defineProps(['msg'])
+      </script>
+      `
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+        /* ✓ GOOD */
+        defineProps<{ msg?:string }>()
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') }
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script>
+        const def = { msg: String }
+      </script>
+      <script setup>
+        /* ✓ GOOD */
+        defineProps(def)
+      </script>
+      `
+    }
+  ],
+  invalid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✗ BAD */
+        const def = { msg: String }
+        defineProps(def)
+      </script>
+      `,
+      errors: [
+        {
+          message: '`defineProps` are referencing locally declared variables.',
+          line: 5
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+        /* ✗ BAD */
+        defineProps<{ msg?:string }>({ msg: String })
+      </script>
+      `,
+      parserOptions: { parser: require.resolve('@typescript-eslint/parser') },
+      errors: [
+        {
+          message: '`defineProps` has both a type-only props and an argument.',
+          line: 4
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✗ BAD */
+        defineProps({ msg: String })
+        defineProps({ count: Number })
+      </script>
+      `,
+      errors: [
+        {
+          message: '`defineProps` has been called multiple times.',
+          line: 4
+        },
+        {
+          message: '`defineProps` has been called multiple times.',
+          line: 5
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script>
+      export default {
+        props: { msg: String }
+      }
+      </script>
+      <script setup>
+        /* ✗ BAD */
+        defineProps({ count: Number })
+      </script>
+      `,
+      errors: [
+        {
+          message:
+            'Props are defined in both `defineProps` and `export default {}`.',
+          line: 9
+        }
+      ]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup>
+        /* ✗ BAD */
+        defineProps()
+      </script>
+      `,
+      errors: [
+        {
+          message: 'Props are not defined.',
+          line: 4
+        }
+      ]
+    }
+  ]
+})
diff --git a/typings/eslint-plugin-vue/global.d.ts b/typings/eslint-plugin-vue/global.d.ts
index 5b185bb24..96ceee311 100644
--- a/typings/eslint-plugin-vue/global.d.ts
+++ b/typings/eslint-plugin-vue/global.d.ts
@@ -152,6 +152,12 @@ declare global {
   // ---- TS Nodes ----
 
   type TSAsExpression = VAST.TSAsExpression
+  type TSTypeParameterInstantiation = VAST.TSTypeParameterInstantiation
+  type TSPropertySignature = VAST.TSPropertySignature
+  type TSMethodSignature = VAST.TSMethodSignature
+  type TSLiteralType = VAST.TSLiteralType
+  type TSCallSignatureDeclaration = VAST.TSCallSignatureDeclaration
+  type TSFunctionType = VAST.TSFunctionType
 
   // ---- JSX Nodes ----
 
diff --git a/typings/eslint-plugin-vue/util-types/ast/es-ast.ts b/typings/eslint-plugin-vue/util-types/ast/es-ast.ts
index 1a2519a1a..26c433a2e 100644
--- a/typings/eslint-plugin-vue/util-types/ast/es-ast.ts
+++ b/typings/eslint-plugin-vue/util-types/ast/es-ast.ts
@@ -495,6 +495,7 @@ export interface CallExpression extends HasParentNode {
   callee: Expression | Super
   arguments: (Expression | SpreadElement)[]
   optional: boolean
+  typeParameters?: TS.TSTypeParameterInstantiation
 }
 export interface Super extends HasParentNode {
   type: 'Super'
diff --git a/typings/eslint-plugin-vue/util-types/ast/ts-ast.ts b/typings/eslint-plugin-vue/util-types/ast/ts-ast.ts
index 91319043b..a79d457f4 100644
--- a/typings/eslint-plugin-vue/util-types/ast/ts-ast.ts
+++ b/typings/eslint-plugin-vue/util-types/ast/ts-ast.ts
@@ -3,10 +3,90 @@
  */
 import { HasParentNode } from '../node'
 import * as ES from './es-ast'
-export type TSNode = TSAsExpression
+import { TSESTree } from '@typescript-eslint/types'
+export type TSNode =
+  | TSAsExpression
+  | TSTypeParameterInstantiation
+  | TSPropertySignature
+  | TSMethodSignatureBase
+  | TSLiteralType
+  | TSCallSignatureDeclaration
+  | TSFunctionType
 
 export interface TSAsExpression extends HasParentNode {
   type: 'TSAsExpression'
   expression: ES.Expression
-  typeAnnotation: any;
+  typeAnnotation: any
+}
+
+export interface TSTypeParameterInstantiation extends HasParentNode {
+  type: 'TSTypeParameterInstantiation'
+  params: TSESTree.TypeNode[]
+}
+
+export type TSPropertySignature =
+  | TSPropertySignatureComputedName
+  | TSPropertySignatureNonComputedName
+interface TSPropertySignatureBase extends HasParentNode {
+  type: 'TSPropertySignature'
+  key: TSESTree.PropertyName
+  optional?: boolean
+  computed: boolean
+  typeAnnotation?: TSESTree.TSTypeAnnotation
+  initializer?: Expression
+  readonly?: boolean
+  static?: boolean
+  export?: boolean
+  accessibility?: TSESTree.Accessibility
+}
+interface TSPropertySignatureComputedName extends TSPropertySignatureBase {
+  key: TSESTree.PropertyNameComputed
+  computed: true
+}
+interface TSPropertySignatureNonComputedName extends TSPropertySignatureBase {
+  key: TSESTree.PropertyNameNonComputed
+  computed: false
+}
+
+export type TSMethodSignature =
+  | TSMethodSignatureComputedName
+  | TSMethodSignatureNonComputedName
+interface TSMethodSignatureBase extends HasParentNode {
+  type: 'TSMethodSignature'
+  key: TSESTree.PropertyName
+  computed: boolean
+  params: TSESTree.Parameter[]
+  optional?: boolean
+  returnType?: TSESTree.TSTypeAnnotation
+  readonly?: boolean
+  typeParameters?: TSESTree.TSTypeParameterDeclaration
+  accessibility?: TSESTree.Accessibility
+  export?: boolean
+  static?: boolean
+  kind: 'get' | 'method' | 'set'
+}
+interface TSMethodSignatureComputedName extends TSMethodSignatureBase {
+  key: TSESTree.PropertyNameComputed
+  computed: true
+}
+interface TSMethodSignatureNonComputedName extends TSMethodSignatureBase {
+  key: TSESTree.PropertyNameNonComputed
+  computed: false
+}
+
+export interface TSLiteralType extends HasParentNode {
+  type: 'TSLiteralType'
+  literal: ES.Literal | ES.UnaryExpression | ES.UpdateExpression
+}
+
+interface TSFunctionSignatureBase extends HasParentNode {
+  params: TSESTree.Parameter[]
+  returnType?: TSESTree.TSTypeAnnotation
+  typeParameters?: TSESTree.TSTypeParameterDeclaration
+}
+export interface TSCallSignatureDeclaration extends TSFunctionSignatureBase {
+  type: 'TSCallSignatureDeclaration'
+}
+export interface TSFunctionType extends TSFunctionSignatureBase {
+  type: 'TSFunctionType'
 }
diff --git a/typings/eslint-plugin-vue/util-types/parser-services.ts b/typings/eslint-plugin-vue/util-types/parser-services.ts
index 8f6e2a625..183516770 100644
--- a/typings/eslint-plugin-vue/util-types/parser-services.ts
+++ b/typings/eslint-plugin-vue/util-types/parser-services.ts
@@ -15,7 +15,10 @@ export interface ParserServices {
   getTemplateBodyTokenStore: () => ParserServices.TokenStore
   defineTemplateBodyVisitor?: (
     templateBodyVisitor: TemplateListener,
-    scriptVisitor?: eslint.Rule.RuleListener
+    scriptVisitor?: eslint.Rule.RuleListener,
+    options?: {
+      templateBodyTriggerSelector: 'Program' | 'Program:exit'
+    }
   ) => eslint.Rule.RuleListener
   getDocumentFragment?: () => VAST.VDocumentFragment | null
 }
diff --git a/typings/eslint-plugin-vue/util-types/utils.ts b/typings/eslint-plugin-vue/util-types/utils.ts
index 6888e9a41..7258cb673 100644
--- a/typings/eslint-plugin-vue/util-types/utils.ts
+++ b/typings/eslint-plugin-vue/util-types/utils.ts
@@ -19,6 +19,10 @@ export interface VueVisitor extends VueVisitorBase {
     node: (FunctionExpression | ArrowFunctionExpression) & { parent: Property },
     obj: VueObjectData
   ): void
+  onSetupFunctionExit?(
+    node: (FunctionExpression | ArrowFunctionExpression) & { parent: Property },
+    obj: VueObjectData
+  ): void
   onRenderFunctionEnter?(
     node: (FunctionExpression | ArrowFunctionExpression) & { parent: Property },
     obj: VueObjectData
@@ -27,3 +31,126 @@ export interface VueVisitor extends VueVisitorBase {
     | ((node: VAST.ParamNode, obj: VueObjectData) => void)
     | undefined
 }
+
+type ScriptSetupVisitorBase = {
+  [T in keyof NodeListenerMap]?: (node: NodeListenerMap[T]) => void
+}
+export interface ScriptSetupVisitor extends ScriptSetupVisitorBase {
+  onDefinePropsEnter?(
+    node: CallExpression,
+    props: (ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]
+  ): void
+  onDefinePropsExit?(
+    node: CallExpression,
+    props: (ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]
+  ): void
+  onDefineEmitsEnter?(
+    node: CallExpression,
+    props: (ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]
+  ): void
+  onDefineEmitsExit?(
+    node: CallExpression,
+    props: (ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]
+  ): void
+  [query: string]:
+    | ((node: VAST.ParamNode) => void)
+    | ((
+        node: CallExpression,
+        props: (ComponentArrayProp | ComponentObjectProp | ComponentTypeProp)[]
+      ) => void)
+    | ((
+        node: CallExpression,
+        props: (ComponentArrayEmit | ComponentObjectEmit | ComponentTypeEmit)[]
+      ) => void)
+    | undefined
+}
+
+type ComponentArrayPropDetectName = {
+  type: 'array'
+  key: Literal | TemplateLiteral
+  propName: string
+  value: null
+  node: Expression | SpreadElement
+}
+type ComponentArrayPropUnknownName = {
+  type: 'array'
+  key: null
+  propName: null
+  value: null
+  node: Expression | SpreadElement
+}
+export type ComponentArrayProp =
+  | ComponentArrayPropDetectName
+  | ComponentArrayPropUnknownName
+
+type ComponentObjectPropDetectName = {
+  type: 'object'
+  key: Expression
+  propName: string
+  value: Expression
+  node: Property
+}
+type ComponentObjectPropUnknownName = {
+  type: 'object'
+  key: null
+  propName: null
+  value: Expression
+  node: Property
+}
+export type ComponentObjectProp =
+  | ComponentObjectPropDetectName
+  | ComponentObjectPropUnknownName
+
+export type ComponentTypeProp = {
+  type: 'type'
+  key: Identifier
+  propName: string
+  value: null
+  node: TSPropertySignature | TSMethodSignature
+
+  required: boolean
+  types: string[]
+}
+
+type ComponentArrayEmitDetectName = {
+  type: 'array'
+  key: Literal | TemplateLiteral
+  emitName: string
+  value: null
+  node: Expression | SpreadElement
+}
+type ComponentArrayEmitUnknownName = {
+  type: 'array'
+  key: null
+  emitName: null
+  value: null
+  node: Expression | SpreadElement
+}
+export type ComponentArrayEmit =
+  | ComponentArrayEmitDetectName
+  | ComponentArrayEmitUnknownName
+type ComponentObjectEmitDetectName = {
+  type: 'object'
+  key: Expression
+  emitName: string
+  value: Expression
+  node: Property
+}
+type ComponentObjectEmitUnknownName = {
+  type: 'object'
+  key: null
+  emitName: null
+  value: Expression
+  node: Property
+}
+export type ComponentObjectEmit =
+  | ComponentObjectEmitDetectName
+  | ComponentObjectEmitUnknownName
+
+export type ComponentTypeEmit = {
+  type: 'type'
+  key: TSLiteralType
+  emitName: string
+  value: null
+  node: TSCallSignatureDeclaration | TSFunctionType
+}

<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html xmlns='http://www.w3.org/1999/xhtml'>
<head>
<title>pFad - Phonifier reborn</title>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
</head>
<body>
<h1>Pfad - The Proxy pFad of &#169; 2024 Garber Painting. All rights reserved.</h1>


<!-- Disclaimer -->
<p>Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.</p>
<br>
<p>Alternative Proxies:</p><p><a href="http://rainy.clevelandohioweatherforecast.com/php-proxy/index.php?q=https://github.com/vuejs/eslint-plugin-vue/compare/vuejs:49d34c9...vuejs:0ee61cc.diff" target="_blank">Alternative Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/index.php?u=https://github.com/vuejs/eslint-plugin-vue/compare/vuejs:49d34c9...vuejs:0ee61cc.diff" target="_blank">pFad Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v3index.php?u=https://github.com/vuejs/eslint-plugin-vue/compare/vuejs:49d34c9...vuejs:0ee61cc.diff" target="_blank">pFad v3 Proxy</a></p><p><a href="http://rainy.clevelandohioweatherforecast.com/pFad/v4index.php?u=https://github.com/vuejs/eslint-plugin-vue/compare/vuejs:49d34c9...vuejs:0ee61cc.diff" target="_blank">pFad v4 Proxy</a></p></body>
</html>