@@ -168,6 +168,8 @@ definePage({
 
 With the `sfc-typed-router` Volar plugin, TypeScript checks `props` against the params of the route and against the props of the page component. In the example above, `props: true` gives an error if the component declares a required prop that the params do not supply, or if the types do not match (e.g. `userId: string` with the `int` parser).
 
+With `props: true`, the plugin also adds the params of the route to the type of `defineProps()`, so `defineProps<{ extra?: string }>()` is typed as `defineProps<RouteParams & { extra?: string }>()`. This only changes the types.
+
 ## With Data Loaders
 
 If you use [Data Loaders](../data-loaders/), install the plugin **before** the router:
 
@@ -89,6 +89,7 @@ export {
   type DefinePageQueryParamOptions,
   type DefinePageQueryParamOptionsAny as _DefinePageQueryParamOptionsAny,
   type PathParamNamesForFilePath as _PathParamNamesForFilePath,
+  type RoutePropsForFilePath as _RoutePropsForFilePath,
 } from './runtime'
 
 // Data loaders exports
 
@@ -78,6 +78,16 @@ export type RouteLocationForFilePath<FilePath extends string> = [
   ? RouteLocationNormalizedLoadedGeneric
   : RouteLocationNormalizedLoaded<RouteNamesForFilePath<FilePath>>
 
+/**
+ * Props that `definePage({ props: true })` passes to a page component: the
+ * params of the routes that render the page file. The `sfc-typed-router`
+ * Volar plugin injects it into `defineProps()`.
+ *
+ * @internal
+ */
+export type RoutePropsForFilePath<FilePath extends string> =
+  RouteLocationForFilePath<FilePath>['params']
+
 /**
  * Merges route records.
  *
 
@@ -89,4 +89,75 @@ describe('sfc-typed-router volar plugin', () => {
     const code = `definePage<'a.vue'>({})`
     expect(transform(code)).toBe(code)
   })
+
+  describe('defineProps() with `props: true`', () => {
+    const ROUTE_PROPS = `import('vue-router/experimental')._RoutePropsForFilePath<'src/pages/users/sub-[first]-[second].vue'>`
+
+    /** Gets the `defineProps()` statement out of the transformed code. */
+    function transformProps(code: string, opts?: { lang?: string }) {
+      return transform(code, opts).split('\n')[0]
+    }
+
+    it('adds the route props as the type argument', () => {
+      expect(
+        transformProps(
+          `const props = defineProps()\ndefinePage({ props: true })`
+        )
+      ).toBe(`const props = defineProps<${ROUTE_PROPS}>()`)
+    })
+
+    it('intersects the route props with an inline type argument', () => {
+      expect(
+        transformProps(
+          `const props = defineProps<{ myProp: string; other: number }>()\ndefinePage({ props: true })`
+        )
+      ).toBe(
+        `const props = defineProps<${ROUTE_PROPS} & ({ myProp: string; other: number })>()`
+      )
+    })
+
+    it('intersects the route props with combined type references', () => {
+      expect(
+        transformProps(
+          `const props = defineProps<A & Omit<B, 'c'> | C>()\ndefinePage({ props: true })`
+        )
+      ).toBe(
+        `const props = defineProps<${ROUTE_PROPS} & (A & Omit<B, 'c'> | C)>()`
+      )
+    })
+
+    it('works with withDefaults() and definePage() first', () => {
+      expect(
+        transform(
+          `definePage({ props: true })\nconst props = withDefaults(defineProps<Props>(), { a: 1 })`
+        ).split('\n')[1]
+      ).toBe(
+        `const props = withDefaults(defineProps<${ROUTE_PROPS} & (Props)>(), { a: 1 })`
+      )
+    })
+
+    it('does nothing without `props: true`', () => {
+      for (const code of [
+        `const props = defineProps()\ndefinePage({ props: false })`,
+        `const props = defineProps()\ndefinePage({ props: to => to.params })`,
+        `const props = defineProps()\ndefinePage({})`,
+        `const props = defineProps()`,
+      ]) {
+        expect(transformProps(code)).toBe(code.split('\n')[0])
+      }
+    })
+
+    it('leaves runtime props declarations untouched', () => {
+      expect(
+        transformProps(
+          `const props = defineProps(['a'])\ndefinePage({ props: true })`
+        )
+      ).toBe(`const props = defineProps(['a'])`)
+    })
+
+    it('does nothing in a js script', () => {
+      const code = `const props = defineProps()\ndefinePage({ props: true })`
+      expect(transform(code, { lang: 'js' })).toBe(code)
+    })
+  })
 })
@@ -66,10 +66,41 @@ const plugin: VueLanguagePlugin<{ options?: { rootDir?: string } }> = ({
         .replace(/'/g, "\\'")
       const definePageTypeParams = `<'${escapedFilePath}', typeof import('${escapedSelfImport}').default>`
 
+      const routePropsType = `import('vue-router/experimental')._RoutePropsForFilePath<'${escapedFilePath}'>`
+
+      // `definePage()` can come after `defineProps()`
+      const hasPropsTrue =
+        !!sfc.scriptSetup &&
+        !sfc.scriptSetup.lang.startsWith('js') &&
+        sfc.scriptSetup.ast.statements.some(isDefinePageWithPropsTrue)
+
       if (sfc.scriptSetup) {
         visit(sfc.scriptSetup.ast)
       }
 
+      function isDefinePageWithPropsTrue(statement: ts.Statement) {
+        if (
+          !ts.isExpressionStatement(statement) ||
+          !ts.isCallExpression(statement.expression) ||
+          !ts.isIdentifier(statement.expression.expression) ||
+          ts.idText(statement.expression.expression) !== 'definePage'
+        ) {
+          return false
+        }
+        const [arg] = statement.expression.arguments
+        return (
+          !!arg &&
+          ts.isObjectLiteralExpression(arg) &&
+          arg.properties.some(
+            prop =>
+              ts.isPropertyAssignment(prop) &&
+              ts.isIdentifier(prop.name) &&
+              ts.idText(prop.name) === 'props' &&
+              prop.initializer.kind === ts.SyntaxKind.TrueKeyword
+          )
+        )
+      }
+
       function visit(node: ts.Node) {
         if (
           ts.isCallExpression(node) &&
@@ -139,6 +170,40 @@ const plugin: VueLanguagePlugin<{ options?: { rootDir?: string } }> = ({
             node.expression.end,
             definePageTypeParams
           )
+        } else if (
+          hasPropsTrue &&
+          ts.isCallExpression(node) &&
+          ts.isIdentifier(node.expression) &&
+          ts.idText(node.expression) === 'defineProps' &&
+          !node.arguments.length
+        ) {
+          // `props: true` passes the route params as props
+          const [typeArg] = node.typeArguments ?? []
+          if (typeArg) {
+            const { start } = getStartEnd(typeArg, sfc.scriptSetup!.ast)
+            replaceSourceRange(
+              embeddedCode.content,
+              sfc.scriptSetup!.name,
+              start,
+              start,
+              `${routePropsType} & (`
+            )
+            replaceSourceRange(
+              embeddedCode.content,
+              sfc.scriptSetup!.name,
+              typeArg.end,
+              typeArg.end,
+              `)`
+            )
+          } else {
+            replaceSourceRange(
+              embeddedCode.content,
+              sfc.scriptSetup!.name,
+              node.expression.end,
+              node.expression.end,
+              `<${routePropsType}>`
+            )
+          }
         } else {
           ts.forEachChild(node, visit)
         }