From c4b20cac194301393f2a53f14639e5624e481681 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Mon, 5 Sep 2022 21:08:52 +0200
Subject: [PATCH 01/25] add rule template

---
 docs/rules/force-types-on-object-props.md     | 30 ++++++++++++
 lib/rules/force-types-on-object-props.js      | 45 ++++++++++++++++++
 .../lib/rules/force-types-on-object-props.js  | 46 +++++++++++++++++++
 3 files changed, 121 insertions(+)
 create mode 100644 docs/rules/force-types-on-object-props.md
 create mode 100644 lib/rules/force-types-on-object-props.js
 create mode 100644 tests/lib/rules/force-types-on-object-props.js

diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/force-types-on-object-props.md
new file mode 100644
index 000000000..70497daa1
--- /dev/null
+++ b/docs/rules/force-types-on-object-props.md
@@ -0,0 +1,30 @@
+---
+pageClass: rule-details
+sidebarDepth: 0
+title: vue/force-types-on-object-props
+description: xxx
+---
+# vue/force-types-on-object-props
+
+> xxx
+
+- :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+
+## :book: Rule Details
+
+This rule ....
+
+<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
+
+```vue
+<template>
+
+</template>
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
new file mode 100644
index 000000000..fb737487e
--- /dev/null
+++ b/lib/rules/force-types-on-object-props.js
@@ -0,0 +1,45 @@
+/**
+ * @author *****your name*****
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
+
+const utils = require('../utils')
+
+// ------------------------------------------------------------------------------
+// Helpers
+// ------------------------------------------------------------------------------
+
+// ...
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '',
+      categories: undefined,
+      url: ''
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      // ...
+    }
+  },
+  /** @param {RuleContext} context */
+  create(context) {
+    // ...
+
+    return utils.defineTemplateBodyVisitor(context, {
+      // ...
+    })
+  }
+}
diff --git a/tests/lib/rules/force-types-on-object-props.js b/tests/lib/rules/force-types-on-object-props.js
new file mode 100644
index 000000000..b069eab37
--- /dev/null
+++ b/tests/lib/rules/force-types-on-object-props.js
@@ -0,0 +1,46 @@
+/**
+ * @author *****your name*****
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const RuleTester = require('eslint').RuleTester
+const rule = require('../../../lib/rules/force-types-on-object-props')
+
+const tester = new RuleTester({
+  parser: require.resolve('vue-eslint-parser'),
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module'
+  }
+})
+
+tester.run('force-types-on-object-props', rule, {
+  valid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+
+      </template>
+      `
+    },
+  ],
+  invalid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <template>
+
+      </template>
+      `,
+      errors: [
+        {
+          message: '...',
+          line: 'line',
+          column: 'col'
+        },
+      ]
+    }
+  ]
+})

From 49d0f30d741c4a8f8591e0c6ad839c57462ebac5 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Mon, 5 Sep 2022 21:22:38 +0200
Subject: [PATCH 02/25] prepare documentation

---
 docs/rules/force-types-on-object-props.md | 73 +++++++++++++++++++++--
 1 file changed, 68 insertions(+), 5 deletions(-)

diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/force-types-on-object-props.md
index 70497daa1..f316b23ae 100644
--- a/docs/rules/force-types-on-object-props.md
+++ b/docs/rules/force-types-on-object-props.md
@@ -12,19 +12,82 @@ description: xxx
 
 ## :book: Rule Details
 
-This rule ....
+Prevent missing type declaration of not primitive objects in a TypeScript projects.
+
+Bad:
 
 <eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
 
-```vue
-<template>
+```js
+export default {
+  props: {
+    prop: {
+      type: Object,
+    },
+  },
+}
+```
+
+</eslint-code-block>
 
-</template>
+<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
+
+```ts
+export default {
+  props: {
+    prop: {
+      type: Array
+    }
+  }
+}
 ```
 
 </eslint-code-block>
 
-## :wrench: Options
+Good:
+
+<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
+
+```ts
+export default {
+  props: {
+    prop: {
+      type: Object as Props<Anything>,
+    }
+  }
+}
+```
+
+</eslint-code-block>
+
+<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
+
+```ts
+export default {
+  props: {
+    prop: {
+      type: String, // or any other primitive type
+    }
+  }
+}
+```
+
+</eslint-code-block>
+
+
+### Options
 
 Nothing.
 
+## When Not To Use It
+
+When you're not using TypeScript in the project.
+
+## Further Reading
+
+Nothing
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/force-types-on-object-props.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/force-types-on-object-props.js)

From 9a5320b3d13b2931c6ecfbc2feca15e7df21b534 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Mon, 19 Sep 2022 23:51:09 +0200
Subject: [PATCH 03/25] prepare force types on object implementation

---
 docs/rules/force-types-on-object-props.md     |   2 +-
 lib/rules/force-types-on-object-props.js      | 118 ++++++++++++++----
 .../lib/rules/force-types-on-object-props.js  |  92 ++++++++++----
 3 files changed, 165 insertions(+), 47 deletions(-)

diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/force-types-on-object-props.md
index f316b23ae..01b029854 100644
--- a/docs/rules/force-types-on-object-props.md
+++ b/docs/rules/force-types-on-object-props.md
@@ -81,7 +81,7 @@ Nothing.
 
 ## When Not To Use It
 
-When you're not using TypeScript in the project.
+When you're not using TypeScript in the project****.
 
 ## Further Reading
 
diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index fb737487e..e6fa875c6 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -1,45 +1,119 @@
 /**
- * @author *****your name*****
+ * @author Przemysław Jan Beigert
  * See LICENSE file in root directory for full license.
  */
 'use strict'
 
-// ------------------------------------------------------------------------------
-// Requirements
-// ------------------------------------------------------------------------------
-
-const utils = require('../utils')
-
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
 
-// ...
+/**
+ * Check if all keys and values from second object are resent in first object
+ *
+ * @param {{ [key: string]: any }} a object to
+ * @param {{ [key: string]: any }} b The string to escape.
+ * @returns {boolean} Returns the escaped string.
+ */
+const isLooksLike = (a, b) =>
+  a &&
+  b &&
+  Object.keys(b).every((bKey) => {
+    const bVal = b[bKey]
+    const aVal = a[bKey]
+    if (typeof bVal === 'function') {
+      return bVal(aVal)
+    }
+    return bVal == null || /^[bns]/.test(typeof bVal)
+      ? bVal === aVal
+      : isLooksLike(aVal, bVal)
+  })
 
-// ------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // Rule Definition
-// ------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 module.exports = {
   meta: {
-    type: 'problem',
+    type: 'suggestion',
     docs: {
-      description: '',
-      categories: undefined,
-      url: ''
+      description: 'enforce user to add type declaration to object props',
+      categories: ['type safe'],
+      recommended: false,
+      url: 'https://eslint.vuejs.org/rules/force-types-on-object-props.html'
     },
     fixable: null,
-    schema: [],
-    messages: {
-      // ...
-    }
+    schema: []
   },
   /** @param {RuleContext} context */
   create(context) {
-    // ...
+    return {
+      /** @param {ExportDefaultDeclaration} node */
+      ExportDefaultDeclaration(node) {
+        if (node.declaration.type !== 'ObjectExpression') {
+          return
+        }
+        if (!Array.isArray(node.declaration.properties)) {
+          return
+        }
+
+        const property = node.declaration.properties.find(
+          (property) =>
+            property.type === 'Property' &&
+            isLooksLike(property.key, { type: 'Identifier', name: 'props' }) &&
+            property.value.type === 'ObjectExpression'
+        )
 
-    return utils.defineTemplateBodyVisitor(context, {
-      // ...
-    })
+        if (
+          !property ||
+          property.type === 'SpreadElement' ||
+          !('properties' in property.value)
+        ) {
+          return
+        }
+        const properties = property.value.properties
+          .filter(
+            (prop) =>
+              prop.type === 'Property' && prop.value.type === 'ObjectExpression'
+          )
+          .map((prop) =>
+            prop.value.properties.find((propValueProperty) =>
+              isLooksLike(propValueProperty.key, {
+                type: 'Identifier',
+                name: 'type'
+              })
+            )
+          )
+        for (const prop of properties) {
+          if (!prop) {
+            break
+          }
+          if (isLooksLike(prop.value, { type: 'Identifier', name: 'Object' })) {
+            context.report({
+              node: prop,
+              message: 'Object props has to contains type.'
+            })
+          }
+          if (prop.value.type === 'TSAsExpression') {
+            const { typeAnnotation } = prop.value
+            if (
+              [
+                'TSAnyKeyword',
+                'TSTypeLiteral',
+                'TSUnknownKeyword',
+                'TSObjectKeyword'
+              ].includes(typeAnnotation.type) ||
+              !typeAnnotation.typeName ||
+              typeAnnotation.typeName.name !== 'Prop'
+            ) {
+              context.report({
+                node: prop,
+                message: 'Object props has to contains type.'
+              })
+            }
+          }
+        }
+      }
+    }
   }
 }
diff --git a/tests/lib/rules/force-types-on-object-props.js b/tests/lib/rules/force-types-on-object-props.js
index b069eab37..5b7b8848d 100644
--- a/tests/lib/rules/force-types-on-object-props.js
+++ b/tests/lib/rules/force-types-on-object-props.js
@@ -7,39 +7,83 @@
 const RuleTester = require('eslint').RuleTester
 const rule = require('../../../lib/rules/force-types-on-object-props')
 
-const tester = new RuleTester({
+const template = (prop) => `
+<template></template>
+<script>
+export default {
+}
+</script>  
+`
+
+const ruleTester = new RuleTester({
   parser: require.resolve('vue-eslint-parser'),
-  parserOptions: {
-    ecmaVersion: 2020,
-    sourceType: 'module'
-  }
+  parserOptions: { ecmaVersion: 2015 }
 })
 
-tester.run('force-types-on-object-props', rule, {
+ruleTester.run('force-types-on-object-props', rule, {
   valid: [
-    {
-      filename: 'test.vue',
-      code: `
-      <template>
-
-      </template>
-      `
-    },
+    `
+  <script lang="ts">
+  export default {
+  }
+  </script>  	
+`,
+    `
+  <script lang="ts">
+  export default {
+    props: {}
+  }
+  </script>  	
+`,
+    template('type: Object as Prop<{}>'),
+    template('type: String'),
+    template('type: Number'),
+    template('type: Boolean'),
+    template('type: [String, Number, Boolean]')
   ],
   invalid: [
     {
-      filename: 'test.vue',
-      code: `
-      <template>
-
-      </template>
-      `,
+      code: template('type: Object'),
+      errors: [
+        {
+          message: 'Object props has to be typed'
+        }
+      ]
+    },
+    {
+      code: template('type: Object as any'),
+      errors: [
+        {
+          message:
+            'Object props should be typed like this: "type: Object as Prop<T>"'
+        }
+      ]
+    },
+    {
+      code: template('type: Object as {}'),
+      errors: [
+        {
+          message:
+            'Object props should be typed like this: "type: Object as Prop<T>"'
+        }
+      ]
+    },
+    {
+      code: template('type: Object as unknown'),
+      errors: [
+        {
+          message:
+            'Object props should be typed like this: "type: Object as Prop<T>"'
+        }
+      ]
+    },
+    {
+      code: template('type: Object as string'),
       errors: [
         {
-          message: '...',
-          line: 'line',
-          column: 'col'
-        },
+          message:
+            'Object props should be typed like this: "type: Object as Prop<T>"'
+        }
       ]
     }
   ]

From bfa7a9fa1a994e38dd2fb39db7851763a6246272 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Mon, 3 Oct 2022 20:43:40 +0200
Subject: [PATCH 04/25] fix some unit tests

---
 lib/rules/force-types-on-object-props.js      |  2 +-
 .../lib/rules/force-types-on-object-props.js  | 27 +++++++++++--------
 2 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index e6fa875c6..ead912e0b 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -86,7 +86,7 @@ module.exports = {
           )
         for (const prop of properties) {
           if (!prop) {
-            break
+            continue
           }
           if (isLooksLike(prop.value, { type: 'Identifier', name: 'Object' })) {
             context.report({
diff --git a/tests/lib/rules/force-types-on-object-props.js b/tests/lib/rules/force-types-on-object-props.js
index 53fefd917..608d2eac0 100644
--- a/tests/lib/rules/force-types-on-object-props.js
+++ b/tests/lib/rules/force-types-on-object-props.js
@@ -8,16 +8,25 @@ const RuleTester = require('eslint').RuleTester
 const rule = require('../../../lib/rules/force-types-on-object-props')
 
 const template = (prop) => `
-<template></template>
-<script>
+<script lang="ts">
+import { Prop } from 'vue/types/options';
 export default {
+	props: {
+		prop: {
+			${prop}
+		}
+	}
 }
 </script>  
 `
 
 const ruleTester = new RuleTester({
   parser: require.resolve('vue-eslint-parser'),
-  parserOptions: { ecmaVersion: 2015,   sourceType: 'module' }
+  parserOptions: {
+    ecmaVersion: 2015,
+    sourceType: 'module',
+    parser: '@typescript-eslint/parser'
+  }
 })
 
 ruleTester.run('force-types-on-object-props', rule, {
@@ -54,8 +63,7 @@ ruleTester.run('force-types-on-object-props', rule, {
       code: template('type: Object as any'),
       errors: [
         {
-          message:
-            'Object props should be typed like this: "type: Object as Prop<T>"'
+          message: 'Object props has to contains type.'
         }
       ]
     },
@@ -63,8 +71,7 @@ ruleTester.run('force-types-on-object-props', rule, {
       code: template('type: Object as {}'),
       errors: [
         {
-          message:
-            'Object props should be typed like this: "type: Object as Prop<T>"'
+          message: 'Object props has to contains type.'
         }
       ]
     },
@@ -72,8 +79,7 @@ ruleTester.run('force-types-on-object-props', rule, {
       code: template('type: Object as unknown'),
       errors: [
         {
-          message:
-            'Object props should be typed like this: "type: Object as Prop<T>"'
+          message: 'Object props has to contains type.'
         }
       ]
     },
@@ -81,8 +87,7 @@ ruleTester.run('force-types-on-object-props', rule, {
       code: template('type: Object as string'),
       errors: [
         {
-          message:
-            'Object props should be typed like this: "type: Object as Prop<T>"'
+          message: 'Object props has to contains type.'
         }
       ]
     }

From 92c09a8885d513d9be3834b978658c9e0731ef80 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Mon, 20 Feb 2023 19:59:04 +0100
Subject: [PATCH 05/25] remove double blank lines

---
 docs/rules/force-types-on-object-props.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/force-types-on-object-props.md
index 01b029854..077b1a84e 100644
--- a/docs/rules/force-types-on-object-props.md
+++ b/docs/rules/force-types-on-object-props.md
@@ -74,7 +74,6 @@ export default {
 
 </eslint-code-block>
 
-
 ### Options
 
 Nothing.

From 95aa2a35a40a57d13cdc61e9fb7824a9a1277805 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Mon, 20 Feb 2023 20:02:31 +0100
Subject: [PATCH 06/25] set proper category

---
 lib/rules/force-types-on-object-props.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index ead912e0b..4c07b9dcd 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -38,7 +38,7 @@ module.exports = {
     type: 'suggestion',
     docs: {
       description: 'enforce user to add type declaration to object props',
-      categories: ['type safe'],
+      categories: ['Internal'],
       recommended: false,
       url: 'https://eslint.vuejs.org/rules/force-types-on-object-props.html'
     },

From 96eb868a66440d43d16fade32ca03388718fde31 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Mon, 20 Feb 2023 20:06:08 +0100
Subject: [PATCH 07/25] update docs

---
 docs/rules/force-types-on-object-props.md | 9 +++++----
 docs/rules/index.md                       | 1 +
 lib/index.js                              | 1 +
 lib/rules/force-types-on-object-props.js  | 2 +-
 4 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/force-types-on-object-props.md
index 077b1a84e..c44069b0e 100644
--- a/docs/rules/force-types-on-object-props.md
+++ b/docs/rules/force-types-on-object-props.md
@@ -2,13 +2,14 @@
 pageClass: rule-details
 sidebarDepth: 0
 title: vue/force-types-on-object-props
-description: xxx
+description: enforce user to add type declaration to object props
 ---
 # vue/force-types-on-object-props
 
-> xxx
+> enforce user to add type declaration to object props
 
 - :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- :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"`.
 
 ## :book: Rule Details
 
@@ -78,11 +79,11 @@ export default {
 
 Nothing.
 
-## When Not To Use It
+## :mute: When Not To Use It
 
 When you're not using TypeScript in the project****.
 
-## Further Reading
+## :books: Further Reading
 
 Nothing
 
diff --git a/docs/rules/index.md b/docs/rules/index.md
index b23f68427..a3ce78b34 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -28,6 +28,7 @@ Rules in this category are enabled for all presets provided by eslint-plugin-vue
 | Rule ID | Description |    |    |
 |:--------|:------------|:--:|:--:|
 | [vue/comment-directive](./comment-directive.md) | support comment-directives in `<template>` |  | :warning: |
+| [vue/force-types-on-object-props](./force-types-on-object-props.md) | enforce user to add type declaration to object props |  | :hammer: |
 | [vue/jsx-uses-vars](./jsx-uses-vars.md) | prevent variables used in JSX to be marked as unused |  | :warning: |
 
 </rules-table>
diff --git a/lib/index.js b/lib/index.js
index aef60a604..32adf4bc5 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -35,6 +35,7 @@ module.exports = {
     'dot-notation': require('./rules/dot-notation'),
     eqeqeq: require('./rules/eqeqeq'),
     'first-attribute-linebreak': require('./rules/first-attribute-linebreak'),
+    'force-types-on-object-props': require('./rules/force-types-on-object-props'),
     'func-call-spacing': require('./rules/func-call-spacing'),
     'html-button-has-type': require('./rules/html-button-has-type'),
     'html-closing-bracket-newline': require('./rules/html-closing-bracket-newline'),
diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index 4c07b9dcd..086ad7124 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -38,7 +38,7 @@ module.exports = {
     type: 'suggestion',
     docs: {
       description: 'enforce user to add type declaration to object props',
-      categories: ['Internal'],
+      categories: ['base'],
       recommended: false,
       url: 'https://eslint.vuejs.org/rules/force-types-on-object-props.html'
     },

From 9264f634b806a5406eb3ede7e4c55f77d8ff28e1 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Thu, 23 Feb 2023 09:03:35 +0100
Subject: [PATCH 08/25] Apply suggestions from code review

Co-authored-by: Flo Edelmann <git@flo-edelmann.de>
---
 docs/rules/force-types-on-object-props.md | 54 +++--------------------
 lib/rules/force-types-on-object-props.js  |  6 +--
 2 files changed, 10 insertions(+), 50 deletions(-)

diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/force-types-on-object-props.md
index c44069b0e..7182412d7 100644
--- a/docs/rules/force-types-on-object-props.md
+++ b/docs/rules/force-types-on-object-props.md
@@ -13,39 +13,7 @@ description: enforce user to add type declaration to object props
 
 ## :book: Rule Details
 
-Prevent missing type declaration of not primitive objects in a TypeScript projects.
-
-Bad:
-
-<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
-
-```js
-export default {
-  props: {
-    prop: {
-      type: Object,
-    },
-  },
-}
-```
-
-</eslint-code-block>
-
-<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
-
-```ts
-export default {
-  props: {
-    prop: {
-      type: Array
-    }
-  }
-}
-```
-
-</eslint-code-block>
-
-Good:
+Prevent missing type declarations for non-primitive object props in TypeScript projects.
 
 <eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
 
@@ -53,20 +21,12 @@ Good:
 export default {
   props: {
     prop: {
+      // ✗ BAD
+      type: Object,
+      type: Array,
+      
+      // ✓ GOOD
       type: Object as Props<Anything>,
-    }
-  }
-}
-```
-
-</eslint-code-block>
-
-<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
-
-```ts
-export default {
-  props: {
-    prop: {
       type: String, // or any other primitive type
     }
   }
@@ -81,7 +41,7 @@ Nothing.
 
 ## :mute: When Not To Use It
 
-When you're not using TypeScript in the project****.
+When you're not using TypeScript in the project.
 
 ## :books: Further Reading
 
diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index 086ad7124..0af4edd19 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -37,8 +37,8 @@ module.exports = {
   meta: {
     type: 'suggestion',
     docs: {
-      description: 'enforce user to add type declaration to object props',
-      categories: ['base'],
+      description: 'enforce adding type declarations to object props',
+      categories: ['suggestion'],
       recommended: false,
       url: 'https://eslint.vuejs.org/rules/force-types-on-object-props.html'
     },
@@ -108,7 +108,7 @@ module.exports = {
             ) {
               context.report({
                 node: prop,
-                message: 'Object props has to contains type.'
+                message: 'Expected type annotation on object prop.'
               })
             }
           }

From 1183f8f44e64c24c75f35c90cb81387f6f409724 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Thu, 23 Feb 2023 09:24:13 +0100
Subject: [PATCH 09/25] add new test case

---
 lib/rules/force-types-on-object-props.js       |  2 +-
 tests/lib/rules/force-types-on-object-props.js | 18 +++++++++++-------
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index 0af4edd19..c6c2d7dea 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -91,7 +91,7 @@ module.exports = {
           if (isLooksLike(prop.value, { type: 'Identifier', name: 'Object' })) {
             context.report({
               node: prop,
-              message: 'Object props has to contains type.'
+              message: 'Expected type annotation on object prop.'
             })
           }
           if (prop.value.type === 'TSAsExpression') {
diff --git a/tests/lib/rules/force-types-on-object-props.js b/tests/lib/rules/force-types-on-object-props.js
index 608d2eac0..940214560 100644
--- a/tests/lib/rules/force-types-on-object-props.js
+++ b/tests/lib/rules/force-types-on-object-props.js
@@ -44,18 +44,22 @@ ruleTester.run('force-types-on-object-props', rule, {
   }
   </script>  	
 `,
-    template('type: Object as Prop<{}>'),
     template('type: String'),
+    template('foo: String,'),
     template('type: Number'),
     template('type: Boolean'),
-    template('type: [String, Number, Boolean]')
+    template('type: [String, Number, Boolean]'),
+    template('foo: someFunction(),'),
+    template('foo: { type: Object as () => User }'),
+    template('type: Object as Prop<{}>'),
+    template('foo: { type: Object as PropType<User> },'),
   ],
   invalid: [
     {
       code: template('type: Object'),
       errors: [
         {
-          message: 'Object props has to contains type.'
+          message: 'Expected type annotation on object prop.'
         }
       ]
     },
@@ -63,7 +67,7 @@ ruleTester.run('force-types-on-object-props', rule, {
       code: template('type: Object as any'),
       errors: [
         {
-          message: 'Object props has to contains type.'
+          message: 'Expected type annotation on object prop.'
         }
       ]
     },
@@ -71,7 +75,7 @@ ruleTester.run('force-types-on-object-props', rule, {
       code: template('type: Object as {}'),
       errors: [
         {
-          message: 'Object props has to contains type.'
+          message: 'Expected type annotation on object prop.'
         }
       ]
     },
@@ -79,7 +83,7 @@ ruleTester.run('force-types-on-object-props', rule, {
       code: template('type: Object as unknown'),
       errors: [
         {
-          message: 'Object props has to contains type.'
+          message: 'Expected type annotation on object prop.'
         }
       ]
     },
@@ -87,7 +91,7 @@ ruleTester.run('force-types-on-object-props', rule, {
       code: template('type: Object as string'),
       errors: [
         {
-          message: 'Object props has to contains type.'
+          message: 'Expected type annotation on object prop.'
         }
       ]
     }

From 75fc8253205412c929d3b16e84bbd9e46b095aed Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Thu, 23 Feb 2023 10:19:09 +0100
Subject: [PATCH 10/25] add new test case & update docs

---
 lib/rules/force-types-on-object-props.js      |  2 +-
 .../lib/rules/force-types-on-object-props.js  | 84 ++++++++++++++-----
 2 files changed, 65 insertions(+), 21 deletions(-)

diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index c6c2d7dea..5d2f24034 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -104,7 +104,7 @@ module.exports = {
                 'TSObjectKeyword'
               ].includes(typeAnnotation.type) ||
               !typeAnnotation.typeName ||
-              typeAnnotation.typeName.name !== 'Prop'
+              !['Prop', 'PropType'].includes(typeAnnotation.typeName.name)
             ) {
               context.report({
                 node: prop,
diff --git a/tests/lib/rules/force-types-on-object-props.js b/tests/lib/rules/force-types-on-object-props.js
index 940214560..a7323acd9 100644
--- a/tests/lib/rules/force-types-on-object-props.js
+++ b/tests/lib/rules/force-types-on-object-props.js
@@ -1,5 +1,5 @@
 /**
- * @author *****your name*****
+ * @author Przemysław Jan Beigert
  * See LICENSE file in root directory for full license.
  */
 'use strict'
@@ -18,7 +18,8 @@ export default {
 	}
 }
 </script>  
-`
+`;
+
 
 const ruleTester = new RuleTester({
   parser: require.resolve('vue-eslint-parser'),
@@ -27,7 +28,11 @@ const ruleTester = new RuleTester({
     sourceType: 'module',
     parser: '@typescript-eslint/parser'
   }
-})
+});
+
+const expectedError = {
+  message: 'Expected type annotation on object prop.'
+};
 
 ruleTester.run('force-types-on-object-props', rule, {
   valid: [
@@ -43,6 +48,18 @@ ruleTester.run('force-types-on-object-props', rule, {
     props: {}
   }
   </script>  	
+`,
+`
+<script setup>
+const props = defineProps(['foo']);
+</script>
+`,
+`
+<script setup>
+const props = defineProps({
+  foo: String
+});
+</script>
 `,
     template('type: String'),
     template('foo: String,'),
@@ -58,42 +75,69 @@ ruleTester.run('force-types-on-object-props', rule, {
     {
       code: template('type: Object'),
       errors: [
-        {
-          message: 'Expected type annotation on object prop.'
-        }
+        expectedError
+      ]
+    },
+    {
+      code: template('type: Object,'),
+      errors: [
+        expectedError
       ]
     },
     {
       code: template('type: Object as any'),
       errors: [
-        {
-          message: 'Expected type annotation on object prop.'
-        }
+        expectedError
+      ]
+    },
+    {
+      code: template('type: Object as any,'),
+      errors: [
+        expectedError
       ]
     },
+
     {
       code: template('type: Object as {}'),
       errors: [
-        {
-          message: 'Expected type annotation on object prop.'
-        }
+        expectedError
+      ]
+    },
+    {
+      code: template('type: Object as {},'),
+      errors: [
+        expectedError
       ]
     },
     {
       code: template('type: Object as unknown'),
       errors: [
-        {
-          message: 'Expected type annotation on object prop.'
-        }
+        expectedError
       ]
     },
     {
-      code: template('type: Object as string'),
+      code: template('type: Object as () => any'),
       errors: [
-        {
-          message: 'Expected type annotation on object prop.'
-        }
+        expectedError
       ]
-    }
+    },
+    {
+      code: template('type: Object as () => any,'),
+      errors: [
+        expectedError
+      ]
+    },
+    {
+      code: template('type: Object as () => unknown'),
+      errors: [
+        expectedError
+      ]
+    },
+    {
+      code: template('type: Object as () => unknown,'),
+      errors: [
+        expectedError
+      ]
+    },
   ]
 })

From 9161964f768dffbe9adf5a69fea61e7faf696f5b Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Tue, 28 Feb 2023 16:17:08 +0100
Subject: [PATCH 11/25] rewrite force-types-on-object-props

---
 lib/rules/force-types-on-object-props.js      | 174 +++++----
 .../lib/rules/force-types-on-object-props.js  | 363 +++++++++++++-----
 2 files changed, 379 insertions(+), 158 deletions(-)

diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index 5d2f24034..8be54f89c 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -4,6 +4,11 @@
  */
 'use strict'
 
+const utils = require('../utils')
+/**
+ * @typedef {import('../utils').ComponentProp} ComponentProp
+ */
+
 // ------------------------------------------------------------------------------
 // Helpers
 // ------------------------------------------------------------------------------
@@ -29,6 +34,97 @@ const isLooksLike = (a, b) =>
       : isLooksLike(aVal, bVal)
   })
 
+/**
+ * @param {ComponentProp} property
+ * @param {RuleContext} context
+ */
+const checkProperty = (property, context) => {
+  if (!property.value) {
+    return
+  }
+
+  if (
+    isLooksLike(property.value, { type: 'Identifier', name: 'Object' }) &&
+    property.node.value.type !== 'TSAsExpression'
+  ) {
+    context.report({
+      node: property.node,
+      message: 'Expected type annotation on object prop.'
+    })
+  }
+
+  if (
+    property.type === 'object' &&
+    property.value.type === 'ObjectExpression' &&
+    property.node.value.type === 'ObjectExpression'
+  ) {
+    const typePropert = property.node.value.properties.find(
+      (prop) =>
+        prop.type === 'Property' &&
+        prop.key.type === 'Identifier' &&
+        prop.key.name === 'type'
+    )
+    if (
+      typePropert &&
+      typePropert.type === 'Property' &&
+      isLooksLike(typePropert.value, { type: 'Identifier', name: 'Object' })
+    ) {
+      context.report({
+        node: property.node,
+        message: 'Expected type annotation on object prop.'
+      })
+    }
+  }
+
+  if (property.node.value.type === 'ObjectExpression') {
+    for (const prop of property.node.value.properties) {
+      if (prop.type !== 'Property') {
+        continue
+      }
+      if (prop.key.type !== 'Identifier' || prop.key.name !== 'type') {
+        continue
+      }
+      if (prop.value.type !== 'TSAsExpression') {
+        continue
+      }
+
+      const { typeAnnotation } = prop.value
+      if (
+        ['TSAnyKeyword', 'TSUnknownKeyword'].includes(typeAnnotation.type) ||
+        !typeAnnotation.typeName ||
+        !['Prop', 'PropType'].includes(typeAnnotation.typeName.name)
+      ) {
+        context.report({
+          node: property.node,
+          message: 'Expected type annotation on object prop.'
+        })
+      }
+    }
+  }
+
+  if (property.node.value.type === 'TSAsExpression') {
+    const { typeAnnotation } = property.node.value
+    if (typeAnnotation.type === 'TSFunctionType') {
+      return
+    }
+    if (
+      [
+        'TSAnyKeyword',
+        'TSTypeLiteral',
+        'TSUnknownKeyword',
+        'TSObjectKeyword'
+      ].includes(typeAnnotation.type) ||
+      !typeAnnotation.typeName ||
+      !['Prop', 'PropType'].includes(typeAnnotation.typeName.name)
+    ) {
+      context.report({
+        node: property.node,
+        message: 'Expected type annotation on object prop.'
+      })
+    }
+  }
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -47,73 +143,21 @@ module.exports = {
   },
   /** @param {RuleContext} context */
   create(context) {
-    return {
-      /** @param {ExportDefaultDeclaration} node */
-      ExportDefaultDeclaration(node) {
-        if (node.declaration.type !== 'ObjectExpression') {
-          return
-        }
-        if (!Array.isArray(node.declaration.properties)) {
-          return
+    return utils.compositingVisitors(
+      utils.defineScriptSetupVisitor(context, {
+        onDefinePropsEnter(_node, props) {
+          for (const prop of props) {
+            checkProperty(prop, context)
+          }
         }
+      }),
+      utils.executeOnVue(context, (obj) => {
+        const props = utils.getComponentPropsFromOptions(obj)
 
-        const property = node.declaration.properties.find(
-          (property) =>
-            property.type === 'Property' &&
-            isLooksLike(property.key, { type: 'Identifier', name: 'props' }) &&
-            property.value.type === 'ObjectExpression'
-        )
-
-        if (
-          !property ||
-          property.type === 'SpreadElement' ||
-          !('properties' in property.value)
-        ) {
-          return
-        }
-        const properties = property.value.properties
-          .filter(
-            (prop) =>
-              prop.type === 'Property' && prop.value.type === 'ObjectExpression'
-          )
-          .map((prop) =>
-            prop.value.properties.find((propValueProperty) =>
-              isLooksLike(propValueProperty.key, {
-                type: 'Identifier',
-                name: 'type'
-              })
-            )
-          )
-        for (const prop of properties) {
-          if (!prop) {
-            continue
-          }
-          if (isLooksLike(prop.value, { type: 'Identifier', name: 'Object' })) {
-            context.report({
-              node: prop,
-              message: 'Expected type annotation on object prop.'
-            })
-          }
-          if (prop.value.type === 'TSAsExpression') {
-            const { typeAnnotation } = prop.value
-            if (
-              [
-                'TSAnyKeyword',
-                'TSTypeLiteral',
-                'TSUnknownKeyword',
-                'TSObjectKeyword'
-              ].includes(typeAnnotation.type) ||
-              !typeAnnotation.typeName ||
-              !['Prop', 'PropType'].includes(typeAnnotation.typeName.name)
-            ) {
-              context.report({
-                node: prop,
-                message: 'Expected type annotation on object prop.'
-              })
-            }
-          }
+        for (const prop of props) {
+          checkProperty(prop, context)
         }
-      }
-    }
+      })
+    )
   }
 }
diff --git a/tests/lib/rules/force-types-on-object-props.js b/tests/lib/rules/force-types-on-object-props.js
index a7323acd9..0461572ef 100644
--- a/tests/lib/rules/force-types-on-object-props.js
+++ b/tests/lib/rules/force-types-on-object-props.js
@@ -7,137 +7,314 @@
 const RuleTester = require('eslint').RuleTester
 const rule = require('../../../lib/rules/force-types-on-object-props')
 
-const template = (prop) => `
-<script lang="ts">
-import { Prop } from 'vue/types/options';
+const templateExport = (prop) => `
 export default {
-	props: {
-		prop: {
-			${prop}
-		}
-	}
+  props: ${prop}
 }
-</script>  
-`;
+`
 
+const templateSetup = (prop) => `
+<script setup lang="ts">
+defineProps(
+  ${prop}
+)
+</script>
+`
 
-const ruleTester = new RuleTester({
+const templateExtend = (prop) => `
+export default Vue.extend({
+  props: 
+    ${prop}
+});
+`
+
+const ruleTester = new RuleTester(/*{
   parser: require.resolve('vue-eslint-parser'),
   parserOptions: {
-    ecmaVersion: 2015,
+    ecmaVersion: 6,
     sourceType: 'module',
     parser: '@typescript-eslint/parser'
   }
-});
+}*/)
 
 const expectedError = {
   message: 'Expected type annotation on object prop.'
-};
+}
 
 ruleTester.run('force-types-on-object-props', rule, {
   valid: [
-    `
-  <script lang="ts">
-  export default {
-  }
-  </script>  	
-`,
-    `
-  <script lang="ts">
-  export default {
-    props: {}
-  }
-  </script>  	
-`,
-`
-<script setup>
-const props = defineProps(['foo']);
-</script>
-`,
-`
-<script setup>
-const props = defineProps({
-  foo: String
-});
-</script>
-`,
-    template('type: String'),
-    template('foo: String,'),
-    template('type: Number'),
-    template('type: Boolean'),
-    template('type: [String, Number, Boolean]'),
-    template('foo: someFunction(),'),
-    template('foo: { type: Object as () => User }'),
-    template('type: Object as Prop<{}>'),
-    template('foo: { type: Object as PropType<User> },'),
+    // empty
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExport('{}')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExtend('{}')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateSetup('{}'),
+      parser: require.resolve('vue-eslint-parser')
+    },
+    // primitive props
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExport('{ foo: String }')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExtend('{ foo: String }')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateSetup('{ foo: String }'),
+      parser: require.resolve('vue-eslint-parser')
+    },
+    // union
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExport('{ foo: [Number, String, Boolean] }')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExtend('{ foo: [Number, String, Boolean] }')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateSetup('{ foo: [Number, String, Boolean] }'),
+      parser: require.resolve('vue-eslint-parser')
+    },
+    // function
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExport('{ foo: someFunction() }')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExtend('{ foo: someFunction() }')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateSetup('{ foo: someFunction() }'),
+      parser: require.resolve('vue-eslint-parser')
+    },
+    // typed object
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExport('{ foo: Object as PropType<User> }'),
+      parser: require.resolve('@typescript-eslint/parser')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: templateExtend('{ foo: Object as PropType<User> }'),
+      parser: require.resolve('@typescript-eslint/parser')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      code: templateSetup('{ foo: Object as PropType<User> }'),
+      parser: require.resolve('vue-eslint-parser')
+    },
+
+    {
+      filename: 'test.vue',
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      code: templateExport('{ foo: Object as () => User }'),
+      parser: require.resolve('@typescript-eslint/parser')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      code: templateExtend('{ foo: Object as () => User }'),
+      parser: require.resolve('@typescript-eslint/parser')
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      code: templateSetup('{ foo: Object as () => User }'),
+      parser: require.resolve('vue-eslint-parser')
+    }
+
+    // // `,
+    //     // template('type: String'),
+    //     // template('foo: String,'),
+    //     // template('type: Number'),
+    //     // template('type: Boolean'),
+    //     // template('type: [String, Number, Boolean]'),
+    //     // template('foo: someFunction(),'),
+    //     // template('foo: { type: Object as () => User }'),
+    //     // template('type: Object as Prop<{}>'),
+    //     // template('foo: { type: Object as PropType<User> },'),
   ],
   invalid: [
     {
-      code: template('type: Object'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: templateSetup('{ foo: Object }'),
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
     },
     {
-      code: template('type: Object,'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: templateExport('{ foo: Object }'),
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      errors: [expectedError]
     },
     {
-      code: template('type: Object as any'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: templateExtend('{ foo: Object }'),
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      errors: [expectedError]
     },
     {
-      code: template('type: Object as any,'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: templateExtend('{ foo: { type: Object } }'),
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      errors: [expectedError]
     },
-
     {
-      code: template('type: Object as {}'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: templateExport('{ foo: { type: Object } }'),
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      errors: [expectedError]
     },
     {
-      code: template('type: Object as {},'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: templateSetup('{ foo: { type: Object } }'),
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
     },
+    // any
     {
-      code: template('type: Object as unknown'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: templateSetup('{ foo: { type: Object as any} }'),
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
     },
     {
-      code: template('type: Object as () => any'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: `
+      <script lang="ts">
+        export default {
+          props: {
+            foo: { type: Object as any }
+          }
+        };
+        </script>
+      `,
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
     },
     {
-      code: template('type: Object as () => any,'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: `
+      <script lang="ts">
+        export default Vue.extend({
+          props: {
+            foo: { type: Object as any }
+          }
+        });
+        </script>
+      `,
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
     },
+    // unknown
     {
-      code: template('type: Object as () => unknown'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: templateSetup('{ foo: { type: Object as unknown} }'),
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
     },
     {
-      code: template('type: Object as () => unknown,'),
-      errors: [
-        expectedError
-      ]
+      filename: 'test.vue',
+      code: `
+      <script lang="ts">
+        export default {
+          props: {
+            foo: { type: Object as unknown }
+          }
+        };
+        </script>
+      `,
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
     },
+    {
+      filename: 'test.vue',
+      code: `
+      <script lang="ts">
+        export default Vue.extend({
+          props: {
+            foo: { type: Object as unknown }
+          }
+        });
+        </script>
+      `,
+      parserOptions: {
+        ecmaVersion: 6,
+        sourceType: 'module',
+        parser: require.resolve('@typescript-eslint/parser')
+      },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
+    }
   ]
 })

From 1aa1de6bb0a75d7ef594a7130bfe5d54619c28e7 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Tue, 28 Feb 2023 16:26:38 +0100
Subject: [PATCH 12/25] update docs

---
 docs/rules/force-types-on-object-props.md | 4 ++--
 docs/rules/index.md                       | 2 +-
 lib/configs/base.js                       | 1 +
 lib/rules/force-types-on-object-props.js  | 2 +-
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/force-types-on-object-props.md
index 7182412d7..f8af13dfe 100644
--- a/docs/rules/force-types-on-object-props.md
+++ b/docs/rules/force-types-on-object-props.md
@@ -2,11 +2,11 @@
 pageClass: rule-details
 sidebarDepth: 0
 title: vue/force-types-on-object-props
-description: enforce user to add type declaration to object props
+description: enforce adding type declarations to object props
 ---
 # vue/force-types-on-object-props
 
-> enforce user to add type declaration to object props
+> enforce adding type declarations to object props
 
 - :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
 - :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"`.
diff --git a/docs/rules/index.md b/docs/rules/index.md
index a3ce78b34..9995b04da 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -28,7 +28,7 @@ Rules in this category are enabled for all presets provided by eslint-plugin-vue
 | Rule ID | Description |    |    |
 |:--------|:------------|:--:|:--:|
 | [vue/comment-directive](./comment-directive.md) | support comment-directives in `<template>` |  | :warning: |
-| [vue/force-types-on-object-props](./force-types-on-object-props.md) | enforce user to add type declaration to object props |  | :hammer: |
+| [vue/force-types-on-object-props](./force-types-on-object-props.md) | enforce adding type declarations to object props |  | :hammer: |
 | [vue/jsx-uses-vars](./jsx-uses-vars.md) | prevent variables used in JSX to be marked as unused |  | :warning: |
 
 </rules-table>
diff --git a/lib/configs/base.js b/lib/configs/base.js
index 3724461e2..7e40f89bd 100644
--- a/lib/configs/base.js
+++ b/lib/configs/base.js
@@ -16,6 +16,7 @@ module.exports = {
   plugins: ['vue'],
   rules: {
     'vue/comment-directive': 'error',
+    'vue/force-types-on-object-props': 'error',
     'vue/jsx-uses-vars': 'error'
   }
 }
diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index 8be54f89c..435681c85 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -134,7 +134,7 @@ module.exports = {
     type: 'suggestion',
     docs: {
       description: 'enforce adding type declarations to object props',
-      categories: ['suggestion'],
+      categories: ['base'],
       recommended: false,
       url: 'https://eslint.vuejs.org/rules/force-types-on-object-props.html'
     },

From 534a2f60bf294ade30510180315337bec8cbc52a Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Wed, 22 Mar 2023 13:39:45 +0100
Subject: [PATCH 13/25] rewrite rule

---
 docs/rules/force-types-on-object-props.md     |   3 +-
 docs/rules/index.md                           |   2 +-
 lib/configs/base.js                           |   1 -
 lib/rules/force-types-on-object-props.js      |  35 +---
 .../lib/rules/force-types-on-object-props.js  | 197 ++++++++++++------
 5 files changed, 141 insertions(+), 97 deletions(-)

diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/force-types-on-object-props.md
index f8af13dfe..65ff4ab56 100644
--- a/docs/rules/force-types-on-object-props.md
+++ b/docs/rules/force-types-on-object-props.md
@@ -9,7 +9,6 @@ description: enforce adding type declarations to object props
 > enforce adding type declarations to object props
 
 - :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
-- :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"`.
 
 ## :book: Rule Details
 
@@ -26,7 +25,7 @@ export default {
       type: Array,
       
       // ✓ GOOD
-      type: Object as Props<Anything>,
+      type: Object as PropType<Anything>,
       type: String, // or any other primitive type
     }
   }
diff --git a/docs/rules/index.md b/docs/rules/index.md
index 9995b04da..1957f8f96 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -28,7 +28,6 @@ Rules in this category are enabled for all presets provided by eslint-plugin-vue
 | Rule ID | Description |    |    |
 |:--------|:------------|:--:|:--:|
 | [vue/comment-directive](./comment-directive.md) | support comment-directives in `<template>` |  | :warning: |
-| [vue/force-types-on-object-props](./force-types-on-object-props.md) | enforce adding type declarations to object props |  | :hammer: |
 | [vue/jsx-uses-vars](./jsx-uses-vars.md) | prevent variables used in JSX to be marked as unused |  | :warning: |
 
 </rules-table>
@@ -216,6 +215,7 @@ For example:
 | [vue/define-emits-declaration](./define-emits-declaration.md) | enforce declaration style of `defineEmits` |  | :hammer: |
 | [vue/define-macros-order](./define-macros-order.md) | enforce order of `defineEmits` and `defineProps` compiler macros | :wrench: | :lipstick: |
 | [vue/define-props-declaration](./define-props-declaration.md) | enforce declaration style of `defineProps` |  | :hammer: |
+| [vue/force-types-on-object-props](./force-types-on-object-props.md) | enforce adding type declarations to object props |  | :hammer: |
 | [vue/html-button-has-type](./html-button-has-type.md) | disallow usage of button without an explicit type attribute |  | :hammer: |
 | [vue/html-comment-content-newline](./html-comment-content-newline.md) | enforce unified line brake in HTML comments | :wrench: | :lipstick: |
 | [vue/html-comment-content-spacing](./html-comment-content-spacing.md) | enforce unified spacing in HTML comments | :wrench: | :lipstick: |
diff --git a/lib/configs/base.js b/lib/configs/base.js
index 7e40f89bd..3724461e2 100644
--- a/lib/configs/base.js
+++ b/lib/configs/base.js
@@ -16,7 +16,6 @@ module.exports = {
   plugins: ['vue'],
   rules: {
     'vue/comment-directive': 'error',
-    'vue/force-types-on-object-props': 'error',
     'vue/jsx-uses-vars': 'error'
   }
 }
diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/force-types-on-object-props.js
index 435681c85..87cf53a3f 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/force-types-on-object-props.js
@@ -13,27 +13,6 @@ const utils = require('../utils')
 // Helpers
 // ------------------------------------------------------------------------------
 
-/**
- * Check if all keys and values from second object are resent in first object
- *
- * @param {{ [key: string]: any }} a object to
- * @param {{ [key: string]: any }} b The string to escape.
- * @returns {boolean} Returns the escaped string.
- */
-const isLooksLike = (a, b) =>
-  a &&
-  b &&
-  Object.keys(b).every((bKey) => {
-    const bVal = b[bKey]
-    const aVal = a[bKey]
-    if (typeof bVal === 'function') {
-      return bVal(aVal)
-    }
-    return bVal == null || /^[bns]/.test(typeof bVal)
-      ? bVal === aVal
-      : isLooksLike(aVal, bVal)
-  })
-
 /**
  * @param {ComponentProp} property
  * @param {RuleContext} context
@@ -44,7 +23,8 @@ const checkProperty = (property, context) => {
   }
 
   if (
-    isLooksLike(property.value, { type: 'Identifier', name: 'Object' }) &&
+    property.value.type === 'Identifier' &&
+    property.value.name === 'Object' &&
     property.node.value.type !== 'TSAsExpression'
   ) {
     context.report({
@@ -58,16 +38,17 @@ const checkProperty = (property, context) => {
     property.value.type === 'ObjectExpression' &&
     property.node.value.type === 'ObjectExpression'
   ) {
-    const typePropert = property.node.value.properties.find(
+    const typeProperty = property.node.value.properties.find(
       (prop) =>
         prop.type === 'Property' &&
         prop.key.type === 'Identifier' &&
         prop.key.name === 'type'
     )
     if (
-      typePropert &&
-      typePropert.type === 'Property' &&
-      isLooksLike(typePropert.value, { type: 'Identifier', name: 'Object' })
+      typeProperty &&
+      typeProperty.type === 'Property' &&
+      typeProperty.value.type === 'Identifier' &&
+      typeProperty.value.name === 'Object'
     ) {
       context.report({
         node: property.node,
@@ -134,7 +115,7 @@ module.exports = {
     type: 'suggestion',
     docs: {
       description: 'enforce adding type declarations to object props',
-      categories: ['base'],
+      categories: undefined,
       recommended: false,
       url: 'https://eslint.vuejs.org/rules/force-types-on-object-props.html'
     },
diff --git a/tests/lib/rules/force-types-on-object-props.js b/tests/lib/rules/force-types-on-object-props.js
index 0461572ef..94ccefb71 100644
--- a/tests/lib/rules/force-types-on-object-props.js
+++ b/tests/lib/rules/force-types-on-object-props.js
@@ -7,35 +7,7 @@
 const RuleTester = require('eslint').RuleTester
 const rule = require('../../../lib/rules/force-types-on-object-props')
 
-const templateExport = (prop) => `
-export default {
-  props: ${prop}
-}
-`
-
-const templateSetup = (prop) => `
-<script setup lang="ts">
-defineProps(
-  ${prop}
-)
-</script>
-`
-
-const templateExtend = (prop) => `
-export default Vue.extend({
-  props: 
-    ${prop}
-});
-`
-
-const ruleTester = new RuleTester(/*{
-  parser: require.resolve('vue-eslint-parser'),
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: 'module',
-    parser: '@typescript-eslint/parser'
-  }
-}*/)
+const ruleTester = new RuleTester()
 
 const expectedError = {
   message: 'Expected type annotation on object prop.'
@@ -47,81 +19,137 @@ ruleTester.run('force-types-on-object-props', rule, {
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExport('{}')
+      code: `
+      export default {
+        props: {}
+      }
+      `
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExtend('{}')
+      code: `
+      export default Vue.extend({
+        props: {}
+      });
+      `
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateSetup('{}'),
+      code: `
+      <script setup lang="ts">
+      defineProps({});
+      </script>
+      `,
       parser: require.resolve('vue-eslint-parser')
     },
     // primitive props
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExport('{ foo: String }')
+      code: `
+      export default {
+        props: { foo: String }
+      }
+      `
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExtend('{ foo: String }')
+      code: `
+      export default Vue.extend({
+        props: { foo: String }
+      });
+      `
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateSetup('{ foo: String }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: String });
+      </script>
+      `,
       parser: require.resolve('vue-eslint-parser')
     },
     // union
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExport('{ foo: [Number, String, Boolean] }')
+      code: `
+      export default {
+        props: { foo: [Number, String, Boolean] }
+      }
+      `
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExtend('{ foo: [Number, String, Boolean] }')
+      code: `
+      export default Vue.extend({
+        props: { foo: [Number, String, Boolean] }
+      });
+      `
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateSetup('{ foo: [Number, String, Boolean] }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: [Number, String, Boolean] });
+      </script>
+      `,
       parser: require.resolve('vue-eslint-parser')
     },
     // function
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExport('{ foo: someFunction() }')
+      code: `
+      export default {
+        props: { foo: someFunction() }
+      }
+      `
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExtend('{ foo: someFunction() }')
+      code: `
+      export default Vue.extend({
+        props: { foo: someFunction() }
+      });
+      `
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateSetup('{ foo: someFunction() }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: someFunction() });
+      </script>
+      `,
       parser: require.resolve('vue-eslint-parser')
     },
     // typed object
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExport('{ foo: Object as PropType<User> }'),
+      code: `
+      export default {
+        props: { foo: Object as PropType<User> }
+      }
+      `,
       parser: require.resolve('@typescript-eslint/parser')
     },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      code: templateExtend('{ foo: Object as PropType<User> }'),
+      code: `
+      export default Vue.extend({
+        props: { foo: Object as PropType<User> }
+      });
+      `,
       parser: require.resolve('@typescript-eslint/parser')
     },
     {
@@ -131,7 +159,11 @@ ruleTester.run('force-types-on-object-props', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      code: templateSetup('{ foo: Object as PropType<User> }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: Object as PropType<User> });
+      </script>
+      `,
       parser: require.resolve('vue-eslint-parser')
     },
 
@@ -142,7 +174,11 @@ ruleTester.run('force-types-on-object-props', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      code: templateExport('{ foo: Object as () => User }'),
+      code: `
+      export default {
+        props: { foo: Object as () => User }
+      }
+      `,
       parser: require.resolve('@typescript-eslint/parser')
     },
     {
@@ -152,7 +188,11 @@ ruleTester.run('force-types-on-object-props', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      code: templateExtend('{ foo: Object as () => User }'),
+      code: `
+      export default Vue.extend({
+        props: { foo: Object as () => User }
+      });
+      `,
       parser: require.resolve('@typescript-eslint/parser')
     },
     {
@@ -162,56 +202,73 @@ ruleTester.run('force-types-on-object-props', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      code: templateSetup('{ foo: Object as () => User }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: Object as () => User });
+      </script>
+      `,
       parser: require.resolve('vue-eslint-parser')
     }
-
-    // // `,
-    //     // template('type: String'),
-    //     // template('foo: String,'),
-    //     // template('type: Number'),
-    //     // template('type: Boolean'),
-    //     // template('type: [String, Number, Boolean]'),
-    //     // template('foo: someFunction(),'),
-    //     // template('foo: { type: Object as () => User }'),
-    //     // template('type: Object as Prop<{}>'),
-    //     // template('foo: { type: Object as PropType<User> },'),
   ],
   invalid: [
     {
       filename: 'test.vue',
-      code: templateSetup('{ foo: Object }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: Object });
+      </script>
+      `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       parser: require.resolve('vue-eslint-parser'),
       errors: [expectedError]
     },
     {
       filename: 'test.vue',
-      code: templateExport('{ foo: Object }'),
+      code: `
+      export default {
+        props: { foo: Object }
+      }
+      `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       errors: [expectedError]
     },
     {
       filename: 'test.vue',
-      code: templateExtend('{ foo: Object }'),
+      code: `
+      export default Vue.extend({
+        props: { foo: Object }
+      });
+      `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       errors: [expectedError]
     },
     {
       filename: 'test.vue',
-      code: templateExtend('{ foo: { type: Object } }'),
+      code: `
+      export default Vue.extend({
+        props: { foo: { type: Object } }
+      });
+      `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       errors: [expectedError]
     },
     {
       filename: 'test.vue',
-      code: templateExport('{ foo: { type: Object } }'),
+      code: `
+      export default {
+        props: { foo: { type: Object } }
+      }
+      `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       errors: [expectedError]
     },
     {
       filename: 'test.vue',
-      code: templateSetup('{ foo: { type: Object } }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: { type: Object } });
+      </script>
+      `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       parser: require.resolve('vue-eslint-parser'),
       errors: [expectedError]
@@ -219,7 +276,11 @@ ruleTester.run('force-types-on-object-props', rule, {
     // any
     {
       filename: 'test.vue',
-      code: templateSetup('{ foo: { type: Object as any} }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: { type: Object as any } });
+      </script>
+      `,
       parserOptions: {
         ecmaVersion: 6,
         sourceType: 'module',
@@ -269,7 +330,11 @@ ruleTester.run('force-types-on-object-props', rule, {
     // unknown
     {
       filename: 'test.vue',
-      code: templateSetup('{ foo: { type: Object as unknown} }'),
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: { type: Object as unknown } });
+      </script>
+      `,
       parserOptions: {
         ecmaVersion: 6,
         sourceType: 'module',

From 9e375c09c8b3102c32d91fbe37d62c9ddb09b181 Mon Sep 17 00:00:00 2001
From: Przemyslaw Jan Beigert <przemyslaw.jan.beigert@gmail.com>
Date: Mon, 5 Jun 2023 13:06:11 +0200
Subject: [PATCH 14/25] rename rule

---
 docs/rules/index.md                                    |  2 +-
 ...-object-props.md => require-type-on-object-prop.md} | 10 +++++-----
 lib/index.js                                           |  2 +-
 ...-object-props.js => require-type-on-object-prop.js} |  2 +-
 ...-object-props.js => require-type-on-object-prop.js} |  4 ++--
 5 files changed, 10 insertions(+), 10 deletions(-)
 rename docs/rules/{force-types-on-object-props.md => require-type-on-object-prop.md} (80%)
 rename lib/rules/{force-types-on-object-props.js => require-type-on-object-prop.js} (97%)
 rename tests/lib/rules/{force-types-on-object-props.js => require-type-on-object-prop.js} (98%)

diff --git a/docs/rules/index.md b/docs/rules/index.md
index 1957f8f96..8a8da5697 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -215,7 +215,7 @@ For example:
 | [vue/define-emits-declaration](./define-emits-declaration.md) | enforce declaration style of `defineEmits` |  | :hammer: |
 | [vue/define-macros-order](./define-macros-order.md) | enforce order of `defineEmits` and `defineProps` compiler macros | :wrench: | :lipstick: |
 | [vue/define-props-declaration](./define-props-declaration.md) | enforce declaration style of `defineProps` |  | :hammer: |
-| [vue/force-types-on-object-props](./force-types-on-object-props.md) | enforce adding type declarations to object props |  | :hammer: |
+| [vue/require-type-on-object-prop](./require-type-on-object-prop.md) | enforce adding type declarations to object props |  | :hammer: |
 | [vue/html-button-has-type](./html-button-has-type.md) | disallow usage of button without an explicit type attribute |  | :hammer: |
 | [vue/html-comment-content-newline](./html-comment-content-newline.md) | enforce unified line brake in HTML comments | :wrench: | :lipstick: |
 | [vue/html-comment-content-spacing](./html-comment-content-spacing.md) | enforce unified spacing in HTML comments | :wrench: | :lipstick: |
diff --git a/docs/rules/force-types-on-object-props.md b/docs/rules/require-type-on-object-prop.md
similarity index 80%
rename from docs/rules/force-types-on-object-props.md
rename to docs/rules/require-type-on-object-prop.md
index 65ff4ab56..49561b600 100644
--- a/docs/rules/force-types-on-object-props.md
+++ b/docs/rules/require-type-on-object-prop.md
@@ -1,10 +1,10 @@
 ---
 pageClass: rule-details
 sidebarDepth: 0
-title: vue/force-types-on-object-props
+title: vue/require-type-on-object-prop
 description: enforce adding type declarations to object props
 ---
-# vue/force-types-on-object-props
+# vue/require-type-on-object-prop
 
 > enforce adding type declarations to object props
 
@@ -14,7 +14,7 @@ description: enforce adding type declarations to object props
 
 Prevent missing type declarations for non-primitive object props in TypeScript projects.
 
-<eslint-code-block :rules="{'vue/force-types-on-object-props': ['error']}">
+<eslint-code-block :rules="{'vue/require-type-on-object-prop': ['error']}">
 
 ```ts
 export default {
@@ -48,5 +48,5 @@ Nothing
 
 ## :mag: Implementation
 
-- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/force-types-on-object-props.js)
-- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/force-types-on-object-props.js)
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/require-type-on-object-prop.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/require-type-on-object-prop.js)
diff --git a/lib/index.js b/lib/index.js
index 32adf4bc5..8166a5a7a 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -35,7 +35,7 @@ module.exports = {
     'dot-notation': require('./rules/dot-notation'),
     eqeqeq: require('./rules/eqeqeq'),
     'first-attribute-linebreak': require('./rules/first-attribute-linebreak'),
-    'force-types-on-object-props': require('./rules/force-types-on-object-props'),
+    'require-type-on-object-prop': require('./rules/require-type-on-object-prop'),
     'func-call-spacing': require('./rules/func-call-spacing'),
     'html-button-has-type': require('./rules/html-button-has-type'),
     'html-closing-bracket-newline': require('./rules/html-closing-bracket-newline'),
diff --git a/lib/rules/force-types-on-object-props.js b/lib/rules/require-type-on-object-prop.js
similarity index 97%
rename from lib/rules/force-types-on-object-props.js
rename to lib/rules/require-type-on-object-prop.js
index 87cf53a3f..504f5b0ab 100644
--- a/lib/rules/force-types-on-object-props.js
+++ b/lib/rules/require-type-on-object-prop.js
@@ -117,7 +117,7 @@ module.exports = {
       description: 'enforce adding type declarations to object props',
       categories: undefined,
       recommended: false,
-      url: 'https://eslint.vuejs.org/rules/force-types-on-object-props.html'
+      url: 'https://eslint.vuejs.org/rules/require-type-on-object-prop.html'
     },
     fixable: null,
     schema: []
diff --git a/tests/lib/rules/force-types-on-object-props.js b/tests/lib/rules/require-type-on-object-prop.js
similarity index 98%
rename from tests/lib/rules/force-types-on-object-props.js
rename to tests/lib/rules/require-type-on-object-prop.js
index 94ccefb71..30b0f8fbe 100644
--- a/tests/lib/rules/force-types-on-object-props.js
+++ b/tests/lib/rules/require-type-on-object-prop.js
@@ -5,7 +5,7 @@
 'use strict'
 
 const RuleTester = require('eslint').RuleTester
-const rule = require('../../../lib/rules/force-types-on-object-props')
+const rule = require('../../../lib/rules/require-type-on-object-prop')
 
 const ruleTester = new RuleTester()
 
@@ -13,7 +13,7 @@ const expectedError = {
   message: 'Expected type annotation on object prop.'
 }
 
-ruleTester.run('force-types-on-object-props', rule, {
+ruleTester.run('require-type-on-object-prop', rule, {
   valid: [
     // empty
     {

From fa6900603ffb1292982370ec2fdb8bc0ea6b6a92 Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 15:59:48 +0200
Subject: [PATCH 15/25] Fix TypeScript type inference

---
 lib/rules/require-type-on-object-prop.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/rules/require-type-on-object-prop.js b/lib/rules/require-type-on-object-prop.js
index 504f5b0ab..087c1be25 100644
--- a/lib/rules/require-type-on-object-prop.js
+++ b/lib/rules/require-type-on-object-prop.js
@@ -18,7 +18,7 @@ const utils = require('../utils')
  * @param {RuleContext} context
  */
 const checkProperty = (property, context) => {
-  if (!property.value) {
+  if (!('value' in property)) {
     return
   }
 

From 6398ced95e03818e0830ded23cc1139b93a4837b Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 16:12:36 +0200
Subject: [PATCH 16/25] Also report untyped array props

---
 docs/rules/require-type-on-object-prop.md     |  1 +
 lib/rules/require-type-on-object-prop.js      |  7 +++++--
 .../lib/rules/require-type-on-object-prop.js  | 21 +++++++++++++++++++
 3 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/docs/rules/require-type-on-object-prop.md b/docs/rules/require-type-on-object-prop.md
index 49561b600..58c146544 100644
--- a/docs/rules/require-type-on-object-prop.md
+++ b/docs/rules/require-type-on-object-prop.md
@@ -26,6 +26,7 @@ export default {
       
       // ✓ GOOD
       type: Object as PropType<Anything>,
+      type: Array as PropType<Anything[]>,
       type: String, // or any other primitive type
     }
   }
diff --git a/lib/rules/require-type-on-object-prop.js b/lib/rules/require-type-on-object-prop.js
index 087c1be25..f00b399bd 100644
--- a/lib/rules/require-type-on-object-prop.js
+++ b/lib/rules/require-type-on-object-prop.js
@@ -13,6 +13,9 @@ const utils = require('../utils')
 // Helpers
 // ------------------------------------------------------------------------------
 
+/** @param {Identifier} node */
+const isObjectProp = (node) => node.name === 'Object' || node.name === 'Array'
+
 /**
  * @param {ComponentProp} property
  * @param {RuleContext} context
@@ -24,7 +27,7 @@ const checkProperty = (property, context) => {
 
   if (
     property.value.type === 'Identifier' &&
-    property.value.name === 'Object' &&
+    isObjectProp(property.value) &&
     property.node.value.type !== 'TSAsExpression'
   ) {
     context.report({
@@ -48,7 +51,7 @@ const checkProperty = (property, context) => {
       typeProperty &&
       typeProperty.type === 'Property' &&
       typeProperty.value.type === 'Identifier' &&
-      typeProperty.value.name === 'Object'
+      isObjectProp(typeProperty.value)
     ) {
       context.report({
         node: property.node,
diff --git a/tests/lib/rules/require-type-on-object-prop.js b/tests/lib/rules/require-type-on-object-prop.js
index 30b0f8fbe..1481bfdaf 100644
--- a/tests/lib/rules/require-type-on-object-prop.js
+++ b/tests/lib/rules/require-type-on-object-prop.js
@@ -142,6 +142,16 @@ ruleTester.run('require-type-on-object-prop', rule, {
       `,
       parser: require.resolve('@typescript-eslint/parser')
     },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: `
+      export default {
+        props: { foo: Array as PropType<User[]> }
+      }
+      `,
+      parser: require.resolve('@typescript-eslint/parser')
+    },
     {
       filename: 'test.vue',
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
@@ -222,6 +232,17 @@ ruleTester.run('require-type-on-object-prop', rule, {
       parser: require.resolve('vue-eslint-parser'),
       errors: [expectedError]
     },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: Array });
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
+    },
     {
       filename: 'test.vue',
       code: `

From 30145fd17a7093374d6ba876a312e912d9f00835 Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 16:20:39 +0200
Subject: [PATCH 17/25] Fix docs

---
 docs/rules/require-type-on-object-prop.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/docs/rules/require-type-on-object-prop.md b/docs/rules/require-type-on-object-prop.md
index 58c146544..245b7e679 100644
--- a/docs/rules/require-type-on-object-prop.md
+++ b/docs/rules/require-type-on-object-prop.md
@@ -16,7 +16,8 @@ Prevent missing type declarations for non-primitive object props in TypeScript p
 
 <eslint-code-block :rules="{'vue/require-type-on-object-prop': ['error']}">
 
-```ts
+```vue
+<script lang="ts">
 export default {
   props: {
     prop: {
@@ -31,7 +32,7 @@ export default {
     }
   }
 }
-```
+</script>
 
 </eslint-code-block>
 

From d6d87f2ca24985984e664de07a376443c039aee8 Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 16:20:52 +0200
Subject: [PATCH 18/25] Regenerate docs

---
 docs/rules/index.md | 2 +-
 lib/index.js        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/rules/index.md b/docs/rules/index.md
index 0c97310d0..33e77fa40 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -215,7 +215,6 @@ For example:
 | [vue/define-emits-declaration](./define-emits-declaration.md) | enforce declaration style of `defineEmits` |  | :hammer: |
 | [vue/define-macros-order](./define-macros-order.md) | enforce order of `defineEmits` and `defineProps` compiler macros | :wrench: | :lipstick: |
 | [vue/define-props-declaration](./define-props-declaration.md) | enforce declaration style of `defineProps` |  | :hammer: |
-| [vue/require-type-on-object-prop](./require-type-on-object-prop.md) | enforce adding type declarations to object props |  | :hammer: |
 | [vue/html-button-has-type](./html-button-has-type.md) | disallow usage of button without an explicit type attribute |  | :hammer: |
 | [vue/html-comment-content-newline](./html-comment-content-newline.md) | enforce unified line brake in HTML comments | :wrench: | :lipstick: |
 | [vue/html-comment-content-spacing](./html-comment-content-spacing.md) | enforce unified spacing in HTML comments | :wrench: | :lipstick: |
@@ -268,6 +267,7 @@ For example:
 | [vue/require-macro-variable-name](./require-macro-variable-name.md) | require a certain macro variable name | :bulb: | :hammer: |
 | [vue/require-name-property](./require-name-property.md) | require a name property in Vue components | :bulb: | :hammer: |
 | [vue/require-prop-comment](./require-prop-comment.md) | require props to have a comment |  | :hammer: |
+| [vue/require-type-on-object-prop](./require-type-on-object-prop.md) | enforce adding type declarations to object props |  | :hammer: |
 | [vue/require-typed-ref](./require-typed-ref.md) | require `ref` and `shallowRef` functions to be strongly typed |  | :hammer: |
 | [vue/script-indent](./script-indent.md) | enforce consistent indentation in `<script>` | :wrench: | :lipstick: |
 | [vue/sort-keys](./sort-keys.md) | enforce sort-keys in a manner that is compatible with order-in-components |  | :hammer: |
diff --git a/lib/index.js b/lib/index.js
index 15e198621..0bec3e742 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -36,7 +36,6 @@ module.exports = {
     'dot-notation': require('./rules/dot-notation'),
     eqeqeq: require('./rules/eqeqeq'),
     'first-attribute-linebreak': require('./rules/first-attribute-linebreak'),
-    'require-type-on-object-prop': require('./rules/require-type-on-object-prop'),
     'func-call-spacing': require('./rules/func-call-spacing'),
     'html-button-has-type': require('./rules/html-button-has-type'),
     'html-closing-bracket-newline': require('./rules/html-closing-bracket-newline'),
@@ -192,6 +191,7 @@ module.exports = {
     'require-render-return': require('./rules/require-render-return'),
     'require-slots-as-functions': require('./rules/require-slots-as-functions'),
     'require-toggle-inside-transition': require('./rules/require-toggle-inside-transition'),
+    'require-type-on-object-prop': require('./rules/require-type-on-object-prop'),
     'require-typed-ref': require('./rules/require-typed-ref'),
     'require-v-for-key': require('./rules/require-v-for-key'),
     'require-valid-default-prop': require('./rules/require-valid-default-prop'),

From e5794b0eb5a738528296ecb15fe456311ce26817 Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 16:23:59 +0200
Subject: [PATCH 19/25] Rename to `vue/require-typed-object-prop`

---
 docs/rules/index.md                                    |  2 +-
 ...-on-object-prop.md => require-typed-object-prop.md} | 10 +++++-----
 lib/index.js                                           |  2 +-
 ...-on-object-prop.js => require-typed-object-prop.js} |  2 +-
 ...-on-object-prop.js => require-typed-object-prop.js} |  4 ++--
 5 files changed, 10 insertions(+), 10 deletions(-)
 rename docs/rules/{require-type-on-object-prop.md => require-typed-object-prop.md} (80%)
 rename lib/rules/{require-type-on-object-prop.js => require-typed-object-prop.js} (98%)
 rename tests/lib/rules/{require-type-on-object-prop.js => require-typed-object-prop.js} (98%)

diff --git a/docs/rules/index.md b/docs/rules/index.md
index 33e77fa40..b0f7d8418 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -267,7 +267,7 @@ For example:
 | [vue/require-macro-variable-name](./require-macro-variable-name.md) | require a certain macro variable name | :bulb: | :hammer: |
 | [vue/require-name-property](./require-name-property.md) | require a name property in Vue components | :bulb: | :hammer: |
 | [vue/require-prop-comment](./require-prop-comment.md) | require props to have a comment |  | :hammer: |
-| [vue/require-type-on-object-prop](./require-type-on-object-prop.md) | enforce adding type declarations to object props |  | :hammer: |
+| [vue/require-typed-object-prop](./require-typed-object-prop.md) | enforce adding type declarations to object props |  | :hammer: |
 | [vue/require-typed-ref](./require-typed-ref.md) | require `ref` and `shallowRef` functions to be strongly typed |  | :hammer: |
 | [vue/script-indent](./script-indent.md) | enforce consistent indentation in `<script>` | :wrench: | :lipstick: |
 | [vue/sort-keys](./sort-keys.md) | enforce sort-keys in a manner that is compatible with order-in-components |  | :hammer: |
diff --git a/docs/rules/require-type-on-object-prop.md b/docs/rules/require-typed-object-prop.md
similarity index 80%
rename from docs/rules/require-type-on-object-prop.md
rename to docs/rules/require-typed-object-prop.md
index 245b7e679..05402f35c 100644
--- a/docs/rules/require-type-on-object-prop.md
+++ b/docs/rules/require-typed-object-prop.md
@@ -1,10 +1,10 @@
 ---
 pageClass: rule-details
 sidebarDepth: 0
-title: vue/require-type-on-object-prop
+title: vue/require-typed-object-prop
 description: enforce adding type declarations to object props
 ---
-# vue/require-type-on-object-prop
+# vue/require-typed-object-prop
 
 > enforce adding type declarations to object props
 
@@ -14,7 +14,7 @@ description: enforce adding type declarations to object props
 
 Prevent missing type declarations for non-primitive object props in TypeScript projects.
 
-<eslint-code-block :rules="{'vue/require-type-on-object-prop': ['error']}">
+<eslint-code-block :rules="{'vue/require-typed-object-prop': ['error']}">
 
 ```vue
 <script lang="ts">
@@ -50,5 +50,5 @@ Nothing
 
 ## :mag: Implementation
 
-- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/require-type-on-object-prop.js)
-- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/require-type-on-object-prop.js)
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/require-typed-object-prop.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/require-typed-object-prop.js)
diff --git a/lib/index.js b/lib/index.js
index 0bec3e742..c7aa8c961 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -191,7 +191,7 @@ module.exports = {
     'require-render-return': require('./rules/require-render-return'),
     'require-slots-as-functions': require('./rules/require-slots-as-functions'),
     'require-toggle-inside-transition': require('./rules/require-toggle-inside-transition'),
-    'require-type-on-object-prop': require('./rules/require-type-on-object-prop'),
+    'require-typed-object-prop': require('./rules/require-typed-object-prop'),
     'require-typed-ref': require('./rules/require-typed-ref'),
     'require-v-for-key': require('./rules/require-v-for-key'),
     'require-valid-default-prop': require('./rules/require-valid-default-prop'),
diff --git a/lib/rules/require-type-on-object-prop.js b/lib/rules/require-typed-object-prop.js
similarity index 98%
rename from lib/rules/require-type-on-object-prop.js
rename to lib/rules/require-typed-object-prop.js
index f00b399bd..106a0167c 100644
--- a/lib/rules/require-type-on-object-prop.js
+++ b/lib/rules/require-typed-object-prop.js
@@ -120,7 +120,7 @@ module.exports = {
       description: 'enforce adding type declarations to object props',
       categories: undefined,
       recommended: false,
-      url: 'https://eslint.vuejs.org/rules/require-type-on-object-prop.html'
+      url: 'https://eslint.vuejs.org/rules/require-typed-object-prop.html'
     },
     fixable: null,
     schema: []
diff --git a/tests/lib/rules/require-type-on-object-prop.js b/tests/lib/rules/require-typed-object-prop.js
similarity index 98%
rename from tests/lib/rules/require-type-on-object-prop.js
rename to tests/lib/rules/require-typed-object-prop.js
index 1481bfdaf..ed1376412 100644
--- a/tests/lib/rules/require-type-on-object-prop.js
+++ b/tests/lib/rules/require-typed-object-prop.js
@@ -5,7 +5,7 @@
 'use strict'
 
 const RuleTester = require('eslint').RuleTester
-const rule = require('../../../lib/rules/require-type-on-object-prop')
+const rule = require('../../../lib/rules/require-typed-object-prop')
 
 const ruleTester = new RuleTester()
 
@@ -13,7 +13,7 @@ const expectedError = {
   message: 'Expected type annotation on object prop.'
 }
 
-ruleTester.run('require-type-on-object-prop', rule, {
+ruleTester.run('require-typed-object-prop', rule, {
   valid: [
     // empty
     {

From a0bc1c108db2c8a913e17e3e685f54468e26fee8 Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 16:25:19 +0200
Subject: [PATCH 20/25] Fix docs

---
 docs/rules/require-typed-object-prop.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/rules/require-typed-object-prop.md b/docs/rules/require-typed-object-prop.md
index 05402f35c..ad81f010e 100644
--- a/docs/rules/require-typed-object-prop.md
+++ b/docs/rules/require-typed-object-prop.md
@@ -33,6 +33,7 @@ export default {
   }
 }
 </script>
+```
 
 </eslint-code-block>
 

From bbe3a6149a9bbcc8907a95a7bd7d3c973694f6f4 Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 16:32:52 +0200
Subject: [PATCH 21/25] Better docs

---
 docs/rules/require-typed-object-prop.md | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/docs/rules/require-typed-object-prop.md b/docs/rules/require-typed-object-prop.md
index ad81f010e..a238a3e1b 100644
--- a/docs/rules/require-typed-object-prop.md
+++ b/docs/rules/require-typed-object-prop.md
@@ -20,16 +20,14 @@ Prevent missing type declarations for non-primitive object props in TypeScript p
 <script lang="ts">
 export default {
   props: {
-    prop: {
-      // ✗ BAD
-      type: Object,
-      type: Array,
+    // ✗ BAD
+    bad1: Object,
+    bad2: { type: Array },
       
-      // ✓ GOOD
-      type: Object as PropType<Anything>,
-      type: Array as PropType<Anything[]>,
-      type: String, // or any other primitive type
-    }
+    // ✓ GOOD
+    good1: Object as PropType<Anything>,
+    good2: { type: Array as PropType<Anything[]> },
+    good3: [String, Boolean], // or any other primitive type
   }
 }
 </script>

From 31009cf167e86edf804d7e80762f6fe67e77251f Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 17:19:56 +0200
Subject: [PATCH 22/25] Simplify logic and treat `as any` and `as unknown` as
 valid

---
 lib/rules/require-typed-object-prop.js       | 142 ++++++--------
 tests/lib/rules/require-typed-object-prop.js | 193 +++++++++++--------
 2 files changed, 166 insertions(+), 169 deletions(-)

diff --git a/lib/rules/require-typed-object-prop.js b/lib/rules/require-typed-object-prop.js
index 106a0167c..07b6d039e 100644
--- a/lib/rules/require-typed-object-prop.js
+++ b/lib/rules/require-typed-object-prop.js
@@ -5,106 +5,80 @@
 'use strict'
 
 const utils = require('../utils')
-/**
- * @typedef {import('../utils').ComponentProp} ComponentProp
- */
-
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/** @param {Identifier} node */
-const isObjectProp = (node) => node.name === 'Object' || node.name === 'Array'
 
 /**
- * @param {ComponentProp} property
  * @param {RuleContext} context
+ * @param {Identifier} node
  */
-const checkProperty = (property, context) => {
-  if (!('value' in property)) {
-    return
-  }
-
-  if (
-    property.value.type === 'Identifier' &&
-    isObjectProp(property.value) &&
-    property.node.value.type !== 'TSAsExpression'
-  ) {
+const checkPropertyIdentifierType = (context, node) => {
+  if (node.name === 'Object' || node.name === 'Array') {
     context.report({
-      node: property.node,
+      node,
       message: 'Expected type annotation on object prop.'
     })
   }
+}
 
-  if (
-    property.type === 'object' &&
-    property.value.type === 'ObjectExpression' &&
-    property.node.value.type === 'ObjectExpression'
-  ) {
-    const typeProperty = property.node.value.properties.find(
-      (prop) =>
-        prop.type === 'Property' &&
-        prop.key.type === 'Identifier' &&
-        prop.key.name === 'type'
-    )
-    if (
-      typeProperty &&
-      typeProperty.type === 'Property' &&
-      typeProperty.value.type === 'Identifier' &&
-      isObjectProp(typeProperty.value)
-    ) {
-      context.report({
-        node: property.node,
-        message: 'Expected type annotation on object prop.'
-      })
+/**
+ * @param {RuleContext} context
+ * @param {ArrayExpression} node
+ */
+const checkPropertyArrayType = (context, node) => {
+  for (const element of node.elements) {
+    if (element?.type === 'Identifier') {
+      checkPropertyIdentifierType(context, element)
     }
   }
+}
 
-  if (property.node.value.type === 'ObjectExpression') {
-    for (const prop of property.node.value.properties) {
-      if (prop.type !== 'Property') {
-        continue
-      }
-      if (prop.key.type !== 'Identifier' || prop.key.name !== 'type') {
-        continue
-      }
-      if (prop.value.type !== 'TSAsExpression') {
-        continue
-      }
+/**
+ * @param {RuleContext} context
+ * @param {ObjectExpression} node
+ */
+const checkPropertyObjectType = (context, node) => {
+  const typeProperty = node.properties.find(
+    (prop) =>
+      prop.type === 'Property' &&
+      prop.key.type === 'Identifier' &&
+      prop.key.name === 'type'
+  )
+  if (!typeProperty || typeProperty.type !== 'Property') {
+    return
+  }
 
-      const { typeAnnotation } = prop.value
-      if (
-        ['TSAnyKeyword', 'TSUnknownKeyword'].includes(typeAnnotation.type) ||
-        !typeAnnotation.typeName ||
-        !['Prop', 'PropType'].includes(typeAnnotation.typeName.name)
-      ) {
-        context.report({
-          node: property.node,
-          message: 'Expected type annotation on object prop.'
-        })
-      }
-    }
+  if (typeProperty.value.type === 'Identifier') {
+    // `foo: { type: String }`
+    checkPropertyIdentifierType(context, typeProperty.value)
+  } else if (typeProperty.value.type === 'ArrayExpression') {
+    // `foo: { type: [String, Boolean] }`
+    checkPropertyArrayType(context, typeProperty.value)
   }
+}
 
-  if (property.node.value.type === 'TSAsExpression') {
-    const { typeAnnotation } = property.node.value
-    if (typeAnnotation.type === 'TSFunctionType') {
-      return
+/**
+ * @param {import('../utils').ComponentProp} property
+ * @param {RuleContext} context
+ */
+const checkProperty = (property, context) => {
+  if (property.type !== 'object') {
+    return
+  }
+
+  switch (property.node.value.type) {
+    case 'Identifier': {
+      // e.g. `foo: String`
+      checkPropertyIdentifierType(context, property.node.value)
+      break
     }
-    if (
-      [
-        'TSAnyKeyword',
-        'TSTypeLiteral',
-        'TSUnknownKeyword',
-        'TSObjectKeyword'
-      ].includes(typeAnnotation.type) ||
-      !typeAnnotation.typeName ||
-      !['Prop', 'PropType'].includes(typeAnnotation.typeName.name)
-    ) {
-      context.report({
-        node: property.node,
-        message: 'Expected type annotation on object prop.'
-      })
+    case 'ArrayExpression': {
+      // e.g. `foo: [String, Boolean]`
+      checkPropertyArrayType(context, property.node.value)
+      break
+    }
+    case 'ObjectExpression': {
+      // e.g. `foo: { type: … }`
+      checkPropertyObjectType(context, property.node.value)
+      return
     }
   }
 }
diff --git a/tests/lib/rules/require-typed-object-prop.js b/tests/lib/rules/require-typed-object-prop.js
index ed1376412..f563cbb0e 100644
--- a/tests/lib/rules/require-typed-object-prop.js
+++ b/tests/lib/rules/require-typed-object-prop.js
@@ -44,6 +44,35 @@ ruleTester.run('require-typed-object-prop', rule, {
       `,
       parser: require.resolve('vue-eslint-parser')
     },
+    // array props
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: `
+      export default {
+        props: ['foo']
+      }
+      `
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: `
+      export default Vue.extend({
+        props: ['foo']
+      });
+      `
+    },
+    {
+      filename: 'test.vue',
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      code: `
+      <script setup lang="ts">
+      defineProps(['foo']);
+      </script>
+      `,
+      parser: require.resolve('vue-eslint-parser')
+    },
     // primitive props
     {
       filename: 'test.vue',
@@ -218,81 +247,6 @@ ruleTester.run('require-typed-object-prop', rule, {
       </script>
       `,
       parser: require.resolve('vue-eslint-parser')
-    }
-  ],
-  invalid: [
-    {
-      filename: 'test.vue',
-      code: `
-      <script setup lang="ts">
-      defineProps({ foo: Object });
-      </script>
-      `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
-    },
-    {
-      filename: 'test.vue',
-      code: `
-      <script setup lang="ts">
-      defineProps({ foo: Array });
-      </script>
-      `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
-    },
-    {
-      filename: 'test.vue',
-      code: `
-      export default {
-        props: { foo: Object }
-      }
-      `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      errors: [expectedError]
-    },
-    {
-      filename: 'test.vue',
-      code: `
-      export default Vue.extend({
-        props: { foo: Object }
-      });
-      `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      errors: [expectedError]
-    },
-    {
-      filename: 'test.vue',
-      code: `
-      export default Vue.extend({
-        props: { foo: { type: Object } }
-      });
-      `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      errors: [expectedError]
-    },
-    {
-      filename: 'test.vue',
-      code: `
-      export default {
-        props: { foo: { type: Object } }
-      }
-      `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      errors: [expectedError]
-    },
-    {
-      filename: 'test.vue',
-      code: `
-      <script setup lang="ts">
-      defineProps({ foo: { type: Object } });
-      </script>
-      `,
-      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
     },
     // any
     {
@@ -307,8 +261,7 @@ ruleTester.run('require-typed-object-prop', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
+      parser: require.resolve('vue-eslint-parser')
     },
     {
       filename: 'test.vue',
@@ -326,8 +279,7 @@ ruleTester.run('require-typed-object-prop', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
+      parser: require.resolve('vue-eslint-parser')
     },
     {
       filename: 'test.vue',
@@ -345,8 +297,7 @@ ruleTester.run('require-typed-object-prop', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
+      parser: require.resolve('vue-eslint-parser')
     },
     // unknown
     {
@@ -361,8 +312,7 @@ ruleTester.run('require-typed-object-prop', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
+      parser: require.resolve('vue-eslint-parser')
     },
     {
       filename: 'test.vue',
@@ -380,8 +330,7 @@ ruleTester.run('require-typed-object-prop', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
-      parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
+      parser: require.resolve('vue-eslint-parser')
     },
     {
       filename: 'test.vue',
@@ -399,6 +348,80 @@ ruleTester.run('require-typed-object-prop', rule, {
         sourceType: 'module',
         parser: require.resolve('@typescript-eslint/parser')
       },
+      parser: require.resolve('vue-eslint-parser')
+    }
+  ],
+  invalid: [
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: Object });
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: Array });
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      parser: require.resolve('vue-eslint-parser'),
+      errors: [expectedError]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      export default {
+        props: { foo: Object }
+      }
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      errors: [expectedError]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      export default Vue.extend({
+        props: { foo: Object }
+      });
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      errors: [expectedError]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      export default Vue.extend({
+        props: { foo: { type: Object } }
+      });
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      errors: [expectedError]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      export default {
+        props: { foo: { type: Object } }
+      }
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
+      errors: [expectedError]
+    },
+    {
+      filename: 'test.vue',
+      code: `
+      <script setup lang="ts">
+      defineProps({ foo: { type: Object } });
+      </script>
+      `,
+      parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       parser: require.resolve('vue-eslint-parser'),
       errors: [expectedError]
     }

From 934030ba2692d90da739a28d3a04cf0cc0ae435c Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 17:24:02 +0200
Subject: [PATCH 23/25] Rename variables

---
 lib/rules/require-typed-object-prop.js | 46 +++++++++++++-------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/lib/rules/require-typed-object-prop.js b/lib/rules/require-typed-object-prop.js
index 07b6d039e..9227d9ffd 100644
--- a/lib/rules/require-typed-object-prop.js
+++ b/lib/rules/require-typed-object-prop.js
@@ -8,12 +8,12 @@ const utils = require('../utils')
 
 /**
  * @param {RuleContext} context
- * @param {Identifier} node
+ * @param {Identifier} identifierNode
  */
-const checkPropertyIdentifierType = (context, node) => {
-  if (node.name === 'Object' || node.name === 'Array') {
+const checkPropIdentifierType = (context, identifierNode) => {
+  if (identifierNode.name === 'Object' || identifierNode.name === 'Array') {
     context.report({
-      node,
+      node: identifierNode,
       message: 'Expected type annotation on object prop.'
     })
   }
@@ -21,22 +21,22 @@ const checkPropertyIdentifierType = (context, node) => {
 
 /**
  * @param {RuleContext} context
- * @param {ArrayExpression} node
+ * @param {ArrayExpression} arrayNode
  */
-const checkPropertyArrayType = (context, node) => {
-  for (const element of node.elements) {
-    if (element?.type === 'Identifier') {
-      checkPropertyIdentifierType(context, element)
+const checkPropArrayType = (context, arrayNode) => {
+  for (const elementNode of arrayNode.elements) {
+    if (elementNode?.type === 'Identifier') {
+      checkPropIdentifierType(context, elementNode)
     }
   }
 }
 
 /**
  * @param {RuleContext} context
- * @param {ObjectExpression} node
+ * @param {ObjectExpression} objectNode
  */
-const checkPropertyObjectType = (context, node) => {
-  const typeProperty = node.properties.find(
+const checkPropObjectType = (context, objectNode) => {
+  const typeProperty = objectNode.properties.find(
     (prop) =>
       prop.type === 'Property' &&
       prop.key.type === 'Identifier' &&
@@ -48,36 +48,36 @@ const checkPropertyObjectType = (context, node) => {
 
   if (typeProperty.value.type === 'Identifier') {
     // `foo: { type: String }`
-    checkPropertyIdentifierType(context, typeProperty.value)
+    checkPropIdentifierType(context, typeProperty.value)
   } else if (typeProperty.value.type === 'ArrayExpression') {
     // `foo: { type: [String, Boolean] }`
-    checkPropertyArrayType(context, typeProperty.value)
+    checkPropArrayType(context, typeProperty.value)
   }
 }
 
 /**
- * @param {import('../utils').ComponentProp} property
+ * @param {import('../utils').ComponentProp} prop
  * @param {RuleContext} context
  */
-const checkProperty = (property, context) => {
-  if (property.type !== 'object') {
+const checkProp = (prop, context) => {
+  if (prop.type !== 'object') {
     return
   }
 
-  switch (property.node.value.type) {
+  switch (prop.node.value.type) {
     case 'Identifier': {
       // e.g. `foo: String`
-      checkPropertyIdentifierType(context, property.node.value)
+      checkPropIdentifierType(context, prop.node.value)
       break
     }
     case 'ArrayExpression': {
       // e.g. `foo: [String, Boolean]`
-      checkPropertyArrayType(context, property.node.value)
+      checkPropArrayType(context, prop.node.value)
       break
     }
     case 'ObjectExpression': {
       // e.g. `foo: { type: … }`
-      checkPropertyObjectType(context, property.node.value)
+      checkPropObjectType(context, prop.node.value)
       return
     }
   }
@@ -105,7 +105,7 @@ module.exports = {
       utils.defineScriptSetupVisitor(context, {
         onDefinePropsEnter(_node, props) {
           for (const prop of props) {
-            checkProperty(prop, context)
+            checkProp(prop, context)
           }
         }
       }),
@@ -113,7 +113,7 @@ module.exports = {
         const props = utils.getComponentPropsFromOptions(obj)
 
         for (const prop of props) {
-          checkProperty(prop, context)
+          checkProp(prop, context)
         }
       })
     )

From 7143dc53234b53f9e2ef4b77895184b326d3b6b5 Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 18:16:12 +0200
Subject: [PATCH 24/25] Add suggestions to rule, use message IDs

---
 docs/rules/index.md                          |   2 +-
 docs/rules/require-typed-object-prop.md      |   1 +
 lib/rules/require-typed-object-prop.js       |  33 ++-
 tests/lib/rules/require-typed-object-prop.js | 214 ++++++++++++++++++-
 4 files changed, 236 insertions(+), 14 deletions(-)

diff --git a/docs/rules/index.md b/docs/rules/index.md
index b0f7d8418..cc94b716b 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -267,7 +267,7 @@ For example:
 | [vue/require-macro-variable-name](./require-macro-variable-name.md) | require a certain macro variable name | :bulb: | :hammer: |
 | [vue/require-name-property](./require-name-property.md) | require a name property in Vue components | :bulb: | :hammer: |
 | [vue/require-prop-comment](./require-prop-comment.md) | require props to have a comment |  | :hammer: |
-| [vue/require-typed-object-prop](./require-typed-object-prop.md) | enforce adding type declarations to object props |  | :hammer: |
+| [vue/require-typed-object-prop](./require-typed-object-prop.md) | enforce adding type declarations to object props | :bulb: | :hammer: |
 | [vue/require-typed-ref](./require-typed-ref.md) | require `ref` and `shallowRef` functions to be strongly typed |  | :hammer: |
 | [vue/script-indent](./script-indent.md) | enforce consistent indentation in `<script>` | :wrench: | :lipstick: |
 | [vue/sort-keys](./sort-keys.md) | enforce sort-keys in a manner that is compatible with order-in-components |  | :hammer: |
diff --git a/docs/rules/require-typed-object-prop.md b/docs/rules/require-typed-object-prop.md
index a238a3e1b..09212004e 100644
--- a/docs/rules/require-typed-object-prop.md
+++ b/docs/rules/require-typed-object-prop.md
@@ -9,6 +9,7 @@ description: enforce adding type declarations to object props
 > enforce adding type declarations to object props
 
 - :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+- :bulb: Some problems reported by this rule are manually fixable by editor [suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).
 
 ## :book: Rule Details
 
diff --git a/lib/rules/require-typed-object-prop.js b/lib/rules/require-typed-object-prop.js
index 9227d9ffd..dda7b8346 100644
--- a/lib/rules/require-typed-object-prop.js
+++ b/lib/rules/require-typed-object-prop.js
@@ -12,9 +12,32 @@ const utils = require('../utils')
  */
 const checkPropIdentifierType = (context, identifierNode) => {
   if (identifierNode.name === 'Object' || identifierNode.name === 'Array') {
+    const arrayTypeSuggestion = identifierNode.name === 'Array' ? '[]' : ''
     context.report({
       node: identifierNode,
-      message: 'Expected type annotation on object prop.'
+      messageId: 'expectedTypeAnnotation',
+      suggest: [
+        {
+          messageId: 'addTypeAnnotation',
+          data: { type: `any${arrayTypeSuggestion}` },
+          fix(fixer) {
+            return fixer.insertTextAfter(
+              identifierNode,
+              ` as PropType<any${arrayTypeSuggestion}>`
+            )
+          }
+        },
+        {
+          messageId: 'addTypeAnnotation',
+          data: { type: `unknown${arrayTypeSuggestion}` },
+          fix(fixer) {
+            return fixer.insertTextAfter(
+              identifierNode,
+              ` as PropType<unknown${arrayTypeSuggestion}>`
+            )
+          }
+        }
+      ]
     })
   }
 }
@@ -97,7 +120,13 @@ module.exports = {
       url: 'https://eslint.vuejs.org/rules/require-typed-object-prop.html'
     },
     fixable: null,
-    schema: []
+    schema: [],
+    // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions -- `context.report` with suggestion is not recognized in `checkPropIdentifierType`
+    hasSuggestions: true,
+    messages: {
+      expectedTypeAnnotation: 'Expected type annotation on object prop.',
+      addTypeAnnotation: 'Add `{{ type }}` type annotation.'
+    }
   },
   /** @param {RuleContext} context */
   create(context) {
diff --git a/tests/lib/rules/require-typed-object-prop.js b/tests/lib/rules/require-typed-object-prop.js
index f563cbb0e..5d93965a5 100644
--- a/tests/lib/rules/require-typed-object-prop.js
+++ b/tests/lib/rules/require-typed-object-prop.js
@@ -9,10 +9,6 @@ const rule = require('../../../lib/rules/require-typed-object-prop')
 
 const ruleTester = new RuleTester()
 
-const expectedError = {
-  message: 'Expected type annotation on object prop.'
-}
-
 ruleTester.run('require-typed-object-prop', rule, {
   valid: [
     // empty
@@ -361,7 +357,35 @@ ruleTester.run('require-typed-object-prop', rule, {
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
+      errors: [
+        {
+          messageId: 'expectedTypeAnnotation',
+          line: 3,
+          column: 26,
+          endLine: 3,
+          endColumn: 32,
+          suggestions: [
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'any' },
+              output: `
+      <script setup lang="ts">
+      defineProps({ foo: Object as PropType<any> });
+      </script>
+      `
+            },
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'unknown' },
+              output: `
+      <script setup lang="ts">
+      defineProps({ foo: Object as PropType<unknown> });
+      </script>
+      `
+            }
+          ]
+        }
+      ]
     },
     {
       filename: 'test.vue',
@@ -372,7 +396,35 @@ ruleTester.run('require-typed-object-prop', rule, {
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
+      errors: [
+        {
+          messageId: 'expectedTypeAnnotation',
+          line: 3,
+          column: 26,
+          endLine: 3,
+          endColumn: 31,
+          suggestions: [
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'any[]' },
+              output: `
+      <script setup lang="ts">
+      defineProps({ foo: Array as PropType<any[]> });
+      </script>
+      `
+            },
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'unknown[]' },
+              output: `
+      <script setup lang="ts">
+      defineProps({ foo: Array as PropType<unknown[]> });
+      </script>
+      `
+            }
+          ]
+        }
+      ]
     },
     {
       filename: 'test.vue',
@@ -382,7 +434,35 @@ ruleTester.run('require-typed-object-prop', rule, {
       }
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      errors: [expectedError]
+      errors: [
+        {
+          messageId: 'expectedTypeAnnotation',
+          line: 3,
+          column: 23,
+          endLine: 3,
+          endColumn: 29,
+          suggestions: [
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'any' },
+              output: `
+      export default {
+        props: { foo: Object as PropType<any> }
+      }
+      `
+            },
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'unknown' },
+              output: `
+      export default {
+        props: { foo: Object as PropType<unknown> }
+      }
+      `
+            }
+          ]
+        }
+      ]
     },
     {
       filename: 'test.vue',
@@ -392,7 +472,35 @@ ruleTester.run('require-typed-object-prop', rule, {
       });
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      errors: [expectedError]
+      errors: [
+        {
+          messageId: 'expectedTypeAnnotation',
+          line: 3,
+          column: 23,
+          endLine: 3,
+          endColumn: 29,
+          suggestions: [
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'any' },
+              output: `
+      export default Vue.extend({
+        props: { foo: Object as PropType<any> }
+      });
+      `
+            },
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'unknown' },
+              output: `
+      export default Vue.extend({
+        props: { foo: Object as PropType<unknown> }
+      });
+      `
+            }
+          ]
+        }
+      ]
     },
     {
       filename: 'test.vue',
@@ -402,7 +510,35 @@ ruleTester.run('require-typed-object-prop', rule, {
       });
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      errors: [expectedError]
+      errors: [
+        {
+          messageId: 'expectedTypeAnnotation',
+          line: 3,
+          column: 31,
+          endLine: 3,
+          endColumn: 37,
+          suggestions: [
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'any' },
+              output: `
+      export default Vue.extend({
+        props: { foo: { type: Object as PropType<any> } }
+      });
+      `
+            },
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'unknown' },
+              output: `
+      export default Vue.extend({
+        props: { foo: { type: Object as PropType<unknown> } }
+      });
+      `
+            }
+          ]
+        }
+      ]
     },
     {
       filename: 'test.vue',
@@ -412,7 +548,35 @@ ruleTester.run('require-typed-object-prop', rule, {
       }
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
-      errors: [expectedError]
+      errors: [
+        {
+          messageId: 'expectedTypeAnnotation',
+          line: 3,
+          column: 31,
+          endLine: 3,
+          endColumn: 37,
+          suggestions: [
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'any' },
+              output: `
+      export default {
+        props: { foo: { type: Object as PropType<any> } }
+      }
+      `
+            },
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'unknown' },
+              output: `
+      export default {
+        props: { foo: { type: Object as PropType<unknown> } }
+      }
+      `
+            }
+          ]
+        }
+      ]
     },
     {
       filename: 'test.vue',
@@ -423,7 +587,35 @@ ruleTester.run('require-typed-object-prop', rule, {
       `,
       parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       parser: require.resolve('vue-eslint-parser'),
-      errors: [expectedError]
+      errors: [
+        {
+          messageId: 'expectedTypeAnnotation',
+          line: 3,
+          column: 34,
+          endLine: 3,
+          endColumn: 40,
+          suggestions: [
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'any' },
+              output: `
+      <script setup lang="ts">
+      defineProps({ foo: { type: Object as PropType<any> } });
+      </script>
+      `
+            },
+            {
+              messageId: 'addTypeAnnotation',
+              data: { type: 'unknown' },
+              output: `
+      <script setup lang="ts">
+      defineProps({ foo: { type: Object as PropType<unknown> } });
+      </script>
+      `
+            }
+          ]
+        }
+      ]
     }
   ]
 })

From dbd17e3371e17861cee7552f294a2684aa3b1f9a Mon Sep 17 00:00:00 2001
From: Flo Edelmann <git@flo-edelmann.de>
Date: Wed, 21 Jun 2023 18:18:03 +0200
Subject: [PATCH 25/25] Simplify docs

---
 docs/rules/require-typed-object-prop.md | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/docs/rules/require-typed-object-prop.md b/docs/rules/require-typed-object-prop.md
index 09212004e..3c9fbaac4 100644
--- a/docs/rules/require-typed-object-prop.md
+++ b/docs/rules/require-typed-object-prop.md
@@ -36,7 +36,7 @@ export default {
 
 </eslint-code-block>
 
-### Options
+## :wrench: Options
 
 Nothing.
 
@@ -44,10 +44,6 @@ Nothing.
 
 When you're not using TypeScript in the project.
 
-## :books: Further Reading
-
-Nothing
-
 ## :mag: Implementation
 
 - [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/require-typed-object-prop.js)