From 5c1b6c3078984d9c83c5de1344b18beb891d0fbb Mon Sep 17 00:00:00 2001
From: Eduardo San Martin Morote <posva13@gmail.com>
Date: Wed, 12 Jun 2024 16:31:53 +0200
Subject: [PATCH] fix(types): use native vue-router types

BREAKING CHANGE: TODO: write changelog once the changes are confirmed
---
 client.d.ts                                 |  73 +-------
 examples/nuxt/pages/users/[id].vue          |   2 +-
 package.json                                |   2 +-
 playground/env.d.ts                         |  21 +--
 playground/package.json                     |   6 +-
 playground/src/App.vue                      |   7 +-
 playground/src/pages/[...path]+.vue         |  18 ++
 playground/src/pages/[...path].vue          |   4 +-
 playground/src/pages/users/[id].vue         |   6 +-
 playground/src/router.ts                    |  15 +-
 playground/tsconfig.json                    |   3 -
 playground/typed-router.d.ts                |  18 +-
 pnpm-lock.yaml                              |  23 ++-
 src/codegen/generateDTS.ts                  |  17 +-
 src/codegen/generateRouteMap.spec.ts        |   1 -
 src/codegen/generateRouteMap.ts             |  33 ----
 src/codegen/vueRouterModule.ts              |   4 +-
 src/core/definePage.ts                      |   7 +-
 src/data-loaders/createDataLoader.ts        |   5 +-
 src/data-loaders/defineColadaLoader.spec.ts |   2 +-
 src/data-loaders/defineColadaLoader.ts      |  31 ++--
 src/data-loaders/defineLoader.spec.ts       |   7 +-
 src/data-loaders/defineLoader.ts            |  21 ++-
 src/data-loaders/defineQueryLoader.spec.ts  |   1 +
 src/data-loaders/defineQueryLoader.ts       |   1 +
 src/data-loaders/defineVueFireLoader.ts     |   1 +
 src/data-loaders/meta-extensions.spec.ts    |  87 ---------
 src/data-loaders/meta-extensions.test-d.ts  |  83 +++++++++
 src/data-loaders/navigation-guard.spec.ts   |   4 +-
 src/data-loaders/navigation-guard.ts        | 196 ++++++++++----------
 src/data-loaders/utils.ts                   |   5 +-
 src/type-extensions/RouterLink.ts           |  86 ---------
 src/type-extensions/RouterTyped.test-d.ts   |   9 +-
 src/type-extensions/navigationGuards.ts     | 111 -----------
 src/type-extensions/routeLocation.test-d.ts |   5 +-
 src/type-extensions/routeLocation.ts        | 165 ----------------
 src/type-extensions/router.ts               | 167 -----------------
 src/type-extensions/types-config.ts         |  16 --
 src/types.ts                                |  63 -------
 tests/data-loaders/tester.ts                |  74 ++++----
 tests/utils.ts                              |   5 -
 tests/vitest-mock-warn.ts                   |  10 +-
 vitest.config.ts                            |   1 -
 43 files changed, 355 insertions(+), 1061 deletions(-)
 create mode 100644 playground/src/pages/[...path]+.vue
 delete mode 100644 src/data-loaders/meta-extensions.spec.ts
 create mode 100644 src/data-loaders/meta-extensions.test-d.ts
 delete mode 100644 src/type-extensions/RouterLink.ts
 delete mode 100644 src/type-extensions/navigationGuards.ts
 delete mode 100644 src/type-extensions/routeLocation.ts
 delete mode 100644 src/type-extensions/router.ts
 delete mode 100644 src/type-extensions/types-config.ts

diff --git a/client.d.ts b/client.d.ts
index f0b172001..107591b74 100644
--- a/client.d.ts
+++ b/client.d.ts
@@ -7,86 +7,19 @@ declare module 'vue-router/auto-routes' {
   export const routes: RouteRecordRaw[]
 }
 
-declare module 'unplugin-vue-router/types' {
-  import type { RouteNamedMap } from 'vue-router/auto-routes'
-  export interface TypesConfig {
-    RouteNamedMap: RouteNamedMap
-  }
-}
-
 declare module 'vue-router' {
-  import type {
-    NavigationGuardTyped,
-    NavigationGuardWithThisTyped,
-    RouteLocationNormalizedLoadedTypedList,
-    _RouterTyped,
-    RouterLinkTyped,
-  } from 'unplugin-vue-router/types'
-
   import type { RouteNamedMap } from 'vue-router/auto-routes'
-  export interface TypesConfig {
-    beforeRouteEnter: NavigationGuardWithThisTyped<undefined, RouteNamedMap>
-    beforeRouteUpdate: NavigationGuardTyped<RouteNamedMap>
-    beforeRouteLeave: NavigationGuardTyped<RouteNamedMap>
 
-    $route: RouteLocationNormalizedLoadedTypedList<RouteNamedMap>[keyof RouteNamedMap]
-    $router: _RouterTyped<RouteNamedMap>
-
-    RouterLink: RouterLinkTyped<RouteNamedMap>
+  export interface TypesConfig {
+    RouteNamedMap: RouteNamedMap
   }
 }
 
 declare module 'vue-router/auto' {
-  import type { RouteNamedMap } from 'vue-router/auto-routes'
-  import type {
-    _RouterTyped,
-    _RouterOptions,
-    RouteLocationNormalizedLoadedTypedList,
-    NavigationGuardTyped,
-    RouterLinkPropsTyped,
-    RouterLinkTyped,
-    UseLinkFnTyped,
-  } from 'unplugin-vue-router/types'
-
   // reexport all types that are not augmented by unplugin-vue-router
   export * from 'vue-router'
-  // Augmented types to override the ones exported by vue-router
-  export type {
-    Router,
-    RouteLocationNormalized,
-    RouteRecordName,
-    RouteLocationNormalizedLoaded,
-    RouteLocation,
-    RouteLocationAsRelativePath,
-    RouteLocationRaw,
-    RouteLocationResolved,
-    RouteParams,
-    RouteParamsRaw,
-    NavigationGuard,
-    NavigationGuardWithThis,
-  } from 'unplugin-vue-router/types'
-
-  /**
-   * @deprecated use `Router` instead. This type will be a different one in the next major version.
-   */
-  export type RouterTyped = _RouterTyped<RouteNamedMap>
-  export function useRouter(): _RouterTyped<RouteNamedMap>
-  export function useRoute<
-    Name extends keyof RouteNamedMap = keyof RouteNamedMap,
-  >(name?: Name): RouteLocationNormalizedLoadedTypedList<RouteNamedMap>[Name]
-  export const useLink: UseLinkFnTyped<RouteNamedMap>
-  export function onBeforeRouteLeave(
-    guard: NavigationGuardTyped<RouteNamedMap>
-  ): void
-  export function onBeforeRouteUpdate(
-    guard: NavigationGuardTyped<RouteNamedMap>
-  ): void
-  export const RouterLink: RouterLinkTyped<RouteNamedMap>
-  export const RouterLinkProps: RouterLinkPropsTyped<RouteNamedMap>
-  export function createRouter(
-    options: _RouterOptions
-  ): _RouterTyped<RouteNamedMap>
 
+  // TODO: deprecate vue-router/auto
   export {
     // Experimental Data Fetching
     definePage,
diff --git a/examples/nuxt/pages/users/[id].vue b/examples/nuxt/pages/users/[id].vue
index 474a61ee0..9f81cce44 100644
--- a/examples/nuxt/pages/users/[id].vue
+++ b/examples/nuxt/pages/users/[id].vue
@@ -1,5 +1,5 @@
 <script lang="ts">
-import { defineBasicLoader } from 'unplugin-vue-router/runtime'
+import { defineBasicLoader } from 'unplugin-vue-router/data-loaders/basic'
 const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
 export const useUserData = defineBasicLoader(
diff --git a/package.json b/package.json
index d8563a877..862284ad4 100644
--- a/package.json
+++ b/package.json
@@ -212,7 +212,7 @@
     "vitepress": "1.2.3",
     "vitest": "^1.6.0",
     "vue": "^3.4.27",
-    "vue-router": "4.3.2",
+    "vue-router": "4.4.0-alpha.2",
     "vue-router-mock": "^1.1.0",
     "vue-tsc": "^2.0.21",
     "vuefire": "^3.1.23",
diff --git a/playground/env.d.ts b/playground/env.d.ts
index e0cbed987..dabd0deba 100644
--- a/playground/env.d.ts
+++ b/playground/env.d.ts
@@ -1,21 +1,2 @@
 /// <reference types="vite/client" />
-
-// manual extension of route types
-declare module 'vue-router/auto-routes' {
-  import type {
-    RouteRecordInfo,
-    ParamValue,
-    ParamValueOneOrMore,
-    ParamValueZeroOrMore,
-    ParamValueZeroOrOne,
-  } from 'unplugin-vue-router'
-
-  export interface RouteNamedMap {
-    'custom-dynamic-name': RouteRecordInfo<
-      'custom-dynamic-name',
-      '/added-during-runtime/[...path]',
-      { path: ParamValue<true> },
-      { path: ParamValue<false> }
-    >
-  }
-}
+/// <reference types="unplugin-vue-router/client" />
diff --git a/playground/package.json b/playground/package.json
index 214cb5664..5402a3122 100644
--- a/playground/package.json
+++ b/playground/package.json
@@ -13,13 +13,13 @@
     "json-server": "^0.17.4",
     "unplugin-vue-router": "workspace:*",
     "vite": "^5.2.13",
-    "vite-plugin-inspect": "^0.8.4",
-    "vue": "^3.4.27"
+    "vite-plugin-inspect": "^0.8.4"
   },
   "dependencies": {
     "@tanstack/vue-query": "^5.41.0",
     "mande": "^2.0.9",
     "pinia": "^2.1.7",
-    "vue": "^3.4.27"
+    "vue": "^3.4.27",
+    "vue-router": "4.4.0-alpha.2"
   }
 }
diff --git a/playground/src/App.vue b/playground/src/App.vue
index 97d1f6d0d..1a612866f 100644
--- a/playground/src/App.vue
+++ b/playground/src/App.vue
@@ -1,11 +1,10 @@
 <script setup lang="ts">
-import { useLink, useRoute } from 'vue-router/auto'
-import type { RouteNamedMap } from 'vue-router/auto-routes'
+import { useLink, useRoute } from 'vue-router'
 import type {
   RouteLocationNormalizedLoaded,
   RouteLocationResolved,
   RouteLocation,
-} from 'vue-router/auto'
+} from 'vue-router'
 import { ref } from 'vue'
 import { routes } from 'vue-router/auto-routes'
 
@@ -90,7 +89,7 @@ const customRoute = useRoute('/deep/nesting/works/custom-path')
         <button @click="$router.push('/oeu')">Click</button>
         <RouterLink to="/named-route" v-slot="{ route }">
           :name param is:
-          {{ (route as RouteLocationNormalizedLoaded<'/[name]'>).params.name }}
+          {{ (route as RouteLocationResolved<'/[name]'>).params.name }}
         </RouterLink>
       </nav>
     </div>
diff --git a/playground/src/pages/[...path]+.vue b/playground/src/pages/[...path]+.vue
new file mode 100644
index 000000000..d0adc6d52
--- /dev/null
+++ b/playground/src/pages/[...path]+.vue
@@ -0,0 +1,18 @@
+<script lang="ts" setup>
+import { useRoute } from 'vue-router/auto'
+
+const route = useRoute('/[...path]+')
+</script>
+
+<template>
+  <main>
+    <h1>Not Found</h1>
+    <p>{{ route.params.path }} does not exist.</p>
+  </main>
+</template>
+
+<route>
+{
+  "props": true
+}
+</route>
diff --git a/playground/src/pages/[...path].vue b/playground/src/pages/[...path].vue
index 0f60689a4..e8bf8e24e 100644
--- a/playground/src/pages/[...path].vue
+++ b/playground/src/pages/[...path].vue
@@ -1,7 +1,9 @@
 <template>
   <main>
     <h1>Not Found</h1>
-    <p>{{ $route.params.path }} does not exist.</p>
+    <p>
+      {{ $route.name === '/[...path]' && $route.params.path }} does not exist.
+    </p>
   </main>
 </template>
 
diff --git a/playground/src/pages/users/[id].vue b/playground/src/pages/users/[id].vue
index 2fb0fcc41..8e362643c 100644
--- a/playground/src/pages/users/[id].vue
+++ b/playground/src/pages/users/[id].vue
@@ -1,5 +1,6 @@
 <script lang="ts">
 import { defineColadaLoader } from 'unplugin-vue-router/data-loaders/pinia-colada'
+import type { RouteLocationNormalized } from 'vue-router'
 export const myExport = 'OUTSIDE SETUP TEST'
 
 const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
@@ -47,8 +48,9 @@ const { data: user2 } = useOldData()
 
 definePage({
   beforeEnter(to) {
-    if (Number.isNaN(Number(to.params.id))) {
-      console.log('invalid param id', to.params.id)
+    const { id } = (to as RouteLocationNormalized<'/users/[id]'>).params
+    if (Number.isNaN(Number(id))) {
+      console.log('invalid param id', id)
       return false
     }
   },
diff --git a/playground/src/router.ts b/playground/src/router.ts
index cc13f0a31..eb6be73de 100644
--- a/playground/src/router.ts
+++ b/playground/src/router.ts
@@ -1,5 +1,6 @@
-import { createRouter, createWebHistory } from 'vue-router/auto'
+import { createRouter, createWebHistory } from 'vue-router'
 import { routes } from 'vue-router/auto-routes'
+import type { RouteRecordInfo, ParamValue } from 'vue-router'
 
 export const router = createRouter({
   history: createWebHistory(),
@@ -16,3 +17,15 @@ if (import.meta.hot) {
     console.log(mod!.router.getRoutes())
   })
 }
+
+// manual extension of route types
+declare module 'vue-router/auto-routes' {
+  export interface RouteNamedMap {
+    'custom-dynamic-name': RouteRecordInfo<
+      'custom-dynamic-name',
+      '/added-during-runtime/[...path]',
+      { path: ParamValue<true> },
+      { path: ParamValue<false> }
+    >
+  }
+}
diff --git a/playground/tsconfig.json b/playground/tsconfig.json
index 7f6e74a87..7e8bb135d 100644
--- a/playground/tsconfig.json
+++ b/playground/tsconfig.json
@@ -28,9 +28,6 @@
         "../src/data-loaders/pinia-colada"
       ],
     },
-    "types": [
-      "unplugin-vue-router/client"
-    ],
   },
   "vueCompilerOptions": {
     "plugins": [
diff --git a/playground/typed-router.d.ts b/playground/typed-router.d.ts
index 67200b92f..edfa3b3ea 100644
--- a/playground/typed-router.d.ts
+++ b/playground/typed-router.d.ts
@@ -5,15 +5,15 @@
 // It's recommended to commit this file.
 // Make sure to add this file to your tsconfig.json file as an "includes" or "files" entry.
 
-declare module 'vue-router/auto-routes' {
-  import type {
-    RouteRecordInfo,
-    ParamValue,
-    ParamValueOneOrMore,
-    ParamValueZeroOrMore,
-    ParamValueZeroOrOne,
-  } from 'unplugin-vue-router/types'
+import type {
+  RouteRecordInfo,
+  ParamValue,
+  ParamValueOneOrMore,
+  ParamValueZeroOrMore,
+  ParamValueZeroOrOne,
+} from 'vue-router'
 
+declare module 'vue-router/auto-routes' {
   /**
    * Route name map generated by unplugin-vue-router
    */
@@ -21,6 +21,7 @@ declare module 'vue-router/auto-routes' {
     'home': RouteRecordInfo<'home', '/', Record<never, never>, Record<never, never>>,
     '/[name]': RouteRecordInfo<'/[name]', '/:name', { name: ParamValue<true> }, { name: ParamValue<false> }>,
     '/[...path]': RouteRecordInfo<'/[...path]', '/:path(.*)', { path: ParamValue<true> }, { path: ParamValue<false> }>,
+    '/[...path]+': RouteRecordInfo<'/[...path]+', '/:path(.*)+', { path: ParamValueOneOrMore<true> }, { path: ParamValueOneOrMore<false> }>,
     '/@[profileId]': RouteRecordInfo<'/@[profileId]', '/@:profileId', { profileId: ParamValue<true> }, { profileId: ParamValue<false> }>,
     '/about': RouteRecordInfo<'/about', '/about', Record<never, never>, Record<never, never>>,
     '/about.extra.nested': RouteRecordInfo<'/about.extra.nested', '/about/extra/nested', Record<never, never>, Record<never, never>>,
@@ -65,3 +66,4 @@ declare module 'vue-router/auto-routes' {
     '/with-extension': RouteRecordInfo<'/with-extension', '/with-extension', Record<never, never>, Record<never, never>>,
   }
 }
+
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 3b82a5fb8..06f5d0ab6 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -148,11 +148,11 @@ importers:
         specifier: ^3.4.27
         version: 3.4.27(typescript@5.4.5)
       vue-router:
-        specifier: 4.3.2
-        version: 4.3.2(vue@3.4.27(typescript@5.4.5))
+        specifier: 4.4.0-alpha.2
+        version: 4.4.0-alpha.2(vue@3.4.27(typescript@5.4.5))
       vue-router-mock:
         specifier: ^1.1.0
-        version: 1.1.0(vue-router@4.3.2(vue@3.4.27(typescript@5.4.5)))(vue@3.4.27(typescript@5.4.5))
+        version: 1.1.0(vue-router@4.4.0-alpha.2(vue@3.4.27(typescript@5.4.5)))(vue@3.4.27(typescript@5.4.5))
       vue-tsc:
         specifier: ^2.0.21
         version: 2.0.21(typescript@5.4.5)
@@ -189,6 +189,9 @@ importers:
       vue:
         specifier: ^3.4.27
         version: 3.4.27(typescript@5.4.5)
+      vue-router:
+        specifier: 4.4.0-alpha.2
+        version: 4.4.0-alpha.2(vue@3.4.27(typescript@5.4.5))
     devDependencies:
       '@vitejs/plugin-vue':
         specifier: ^5.0.5
@@ -5742,6 +5745,11 @@ packages:
     peerDependencies:
       vue: ^3.2.0
 
+  vue-router@4.4.0-alpha.2:
+    resolution: {integrity: sha512-UDEWQIKLkMISuQIMCAxdkBPZufPRvWo7W8AunETZxqtG3h7WknFVgox4dYrA0a3h2EjYhgtXIZ+bA5PKvfBbLg==}
+    peerDependencies:
+      vue: ^3.2.0
+
   vue-template-compiler@2.7.16:
     resolution: {integrity: sha512-AYbUWAJHLGGQM7+cNTELw+KsOG9nl2CnSv467WobS5Cv9uk3wFcnr1Etsz2sEIHEZvw1U+o9mRlEO6QbZvUPGQ==}
 
@@ -12539,16 +12547,21 @@ snapshots:
     dependencies:
       vue: 3.4.27(typescript@5.4.5)
 
-  vue-router-mock@1.1.0(vue-router@4.3.2(vue@3.4.27(typescript@5.4.5)))(vue@3.4.27(typescript@5.4.5)):
+  vue-router-mock@1.1.0(vue-router@4.4.0-alpha.2(vue@3.4.27(typescript@5.4.5)))(vue@3.4.27(typescript@5.4.5)):
     dependencies:
       vue: 3.4.27(typescript@5.4.5)
-      vue-router: 4.3.2(vue@3.4.27(typescript@5.4.5))
+      vue-router: 4.4.0-alpha.2(vue@3.4.27(typescript@5.4.5))
 
   vue-router@4.3.2(vue@3.4.27(typescript@5.4.5)):
     dependencies:
       '@vue/devtools-api': 6.6.1
       vue: 3.4.27(typescript@5.4.5)
 
+  vue-router@4.4.0-alpha.2(vue@3.4.27(typescript@5.4.5)):
+    dependencies:
+      '@vue/devtools-api': 6.6.1
+      vue: 3.4.27(typescript@5.4.5)
+
   vue-template-compiler@2.7.16:
     dependencies:
       de-indent: 1.0.2
diff --git a/src/codegen/generateDTS.ts b/src/codegen/generateDTS.ts
index a70113051..926dc800d 100644
--- a/src/codegen/generateDTS.ts
+++ b/src/codegen/generateDTS.ts
@@ -1,5 +1,4 @@
 export function generateDTS({
-  vueRouterModule,
   routesModule,
   routeNamedMap,
 }: {
@@ -15,15 +14,15 @@ export function generateDTS({
 // It's recommended to commit this file.
 // Make sure to add this file to your tsconfig.json file as an "includes" or "files" entry.
 
-declare module '${routesModule}' {
-  import type {
-    RouteRecordInfo,
-    ParamValue,
-    ParamValueOneOrMore,
-    ParamValueZeroOrMore,
-    ParamValueZeroOrOne,
-  } from 'unplugin-vue-router/types'
+import type {
+  RouteRecordInfo,
+  ParamValue,
+  ParamValueOneOrMore,
+  ParamValueZeroOrMore,
+  ParamValueZeroOrOne,
+} from 'vue-router'
 
+declare module '${routesModule}' {
   /**
    * Route name map generated by unplugin-vue-router
    */
diff --git a/src/codegen/generateRouteMap.spec.ts b/src/codegen/generateRouteMap.spec.ts
index b55331f37..6afb60977 100644
--- a/src/codegen/generateRouteMap.spec.ts
+++ b/src/codegen/generateRouteMap.spec.ts
@@ -2,7 +2,6 @@ import { describe, expect, it } from 'vitest'
 import { generateRouteNamedMap } from './generateRouteMap'
 import { PrefixTree } from '../core/tree'
 import { resolveOptions } from '../options'
-import { resolve } from 'pathe'
 
 const DEFAULT_OPTIONS = resolveOptions({})
 
diff --git a/src/codegen/generateRouteMap.ts b/src/codegen/generateRouteMap.ts
index f72869809..6a2a2bd77 100644
--- a/src/codegen/generateRouteMap.ts
+++ b/src/codegen/generateRouteMap.ts
@@ -1,10 +1,3 @@
-import type {
-  RouteMeta,
-  RouteParamsRaw,
-  RouteParams,
-  RouterLinkProps as _RouterLinkProps,
-  RouteRecord,
-} from 'vue-router'
 import type { TreeNode } from '../core/tree'
 import { generateRouteParams } from './generateRouteParams'
 
@@ -32,29 +25,3 @@ export function generateRouteRecordInfo(node: TreeNode) {
     node.fullPath
   }', ${generateRouteParams(node, true)}, ${generateRouteParams(node, false)}>`
 }
-
-/**
- * Helper type to define a Typed `RouteRecord`
- * @see {@link RouteRecord}
- */
-export interface RouteRecordInfo<
-  Name extends string = string,
-  Path extends string = string,
-  // TODO: could probably be inferred from the Params
-  ParamsRaw extends RouteParamsRaw = RouteParamsRaw,
-  Params extends RouteParams = RouteParams,
-  Meta extends RouteMeta = RouteMeta,
-> {
-  name: Name
-  path: Path
-  paramsRaw: ParamsRaw
-  params: Params
-  // TODO: implement meta with a defineRoute macro
-  meta: Meta
-}
-
-/**
- * Generic version of RouteNamedMap.
- * @internal
- */
-export type _RouteMapGeneric = Record<string, RouteRecordInfo>
diff --git a/src/codegen/vueRouterModule.ts b/src/codegen/vueRouterModule.ts
index 076835756..1f431615f 100644
--- a/src/codegen/vueRouterModule.ts
+++ b/src/codegen/vueRouterModule.ts
@@ -4,8 +4,8 @@ import type { ResolvedOptions } from '../options'
 
 // cannot be resolved.
 export function generateVueRouterProxy(
-  routesModule: string,
-  options: ResolvedOptions,
+  _routesModule: string,
+  _options: ResolvedOptions,
   { addPiniaColada }: { addPiniaColada: boolean }
 ) {
   return `
diff --git a/src/core/definePage.ts b/src/core/definePage.ts
index ba65ef881..80ac25157 100644
--- a/src/core/definePage.ts
+++ b/src/core/definePage.ts
@@ -45,7 +45,7 @@ export function definePageTransform({
   const sfc = parseSFC(code, id)
   if (!sfc.scriptSetup) return
 
-  const { script, scriptSetup, getSetupAst } = sfc
+  const { scriptSetup, getSetupAst } = sfc
   const setupAst = getSetupAst()
 
   const definePageNodes = (setupAst?.body || ([] as Node[]))
@@ -178,10 +178,11 @@ export function extractDefinePageNameAndPath(
   return routeInfo
 }
 
-function extractRouteAlias(
+// TODO: use
+export function extractRouteAlias(
   aliasValue: ObjectProperty['value'],
   id: string
-): string[] | undefined {
+): string[] | void {
   if (
     aliasValue.type !== 'StringLiteral' &&
     aliasValue.type !== 'ArrayExpression'
diff --git a/src/data-loaders/createDataLoader.ts b/src/data-loaders/createDataLoader.ts
index cf25e663e..b0b316108 100644
--- a/src/data-loaders/createDataLoader.ts
+++ b/src/data-loaders/createDataLoader.ts
@@ -2,10 +2,7 @@ import { type ShallowRef } from 'vue'
 import type { IS_USE_DATA_LOADER_KEY, STAGED_NO_VALUE } from './meta-extensions'
 import { type _PromiseMerged } from './utils'
 import { type NavigationResult } from './navigation-guard'
-import type {
-  RouteLocationNormalizedLoaded,
-  Router,
-} from 'unplugin-vue-router/types'
+import type { RouteLocationNormalizedLoaded, Router } from 'vue-router'
 import { type _Awaitable } from '../utils'
 
 /**
diff --git a/src/data-loaders/defineColadaLoader.spec.ts b/src/data-loaders/defineColadaLoader.spec.ts
index 81dc3a03e..a310bc051 100644
--- a/src/data-loaders/defineColadaLoader.spec.ts
+++ b/src/data-loaders/defineColadaLoader.spec.ts
@@ -144,7 +144,7 @@ describe(
     it('updates data loader data if internal data changes', async () => {
       const query = vi.fn().mockResolvedValue('data')
 
-      const { router, useData, app } = singleLoaderOneRoute(
+      const { router, useData } = singleLoaderOneRoute(
         defineColadaLoader({
           query,
           key: () => ['id'],
diff --git a/src/data-loaders/defineColadaLoader.ts b/src/data-loaders/defineColadaLoader.ts
index 1f87707bd..5f458bb72 100644
--- a/src/data-loaders/defineColadaLoader.ts
+++ b/src/data-loaders/defineColadaLoader.ts
@@ -1,14 +1,11 @@
 import {
+  RouteMap,
   useRoute,
   useRouter,
   type LocationQuery,
-  type Router as UntypedRouter,
+  type RouteLocationNormalizedLoaded,
+  type Router,
 } from 'vue-router'
-import type {
-  RouteLocationNormalizedLoaded,
-  RouteRecordName,
-  Router,
-} from 'unplugin-vue-router/types'
 import type {
   DataLoaderContextBase,
   DataLoaderEntryBase,
@@ -57,7 +54,7 @@ import {
  * @param options - options to configure the data loader
  */
 export function defineColadaLoader<
-  Name extends RouteRecordName,
+  Name extends keyof RouteMap,
   Data,
   isLazy extends boolean,
 >(
@@ -65,14 +62,14 @@ export function defineColadaLoader<
   options: DefineDataColadaLoaderOptions<isLazy, Name, Data>
 ): UseDataLoaderColada<isLazy, Data>
 export function defineColadaLoader<Data, isLazy extends boolean>(
-  options: DefineDataColadaLoaderOptions<isLazy, RouteRecordName, Data>
+  options: DefineDataColadaLoaderOptions<isLazy, keyof RouteMap, Data>
 ): UseDataLoaderColada<isLazy, Data>
 
 export function defineColadaLoader<Data, isLazy extends boolean>(
   nameOrOptions:
-    | RouteRecordName
-    | DefineDataColadaLoaderOptions<isLazy, RouteRecordName, Data>,
-  _options?: DefineDataColadaLoaderOptions<isLazy, RouteRecordName, Data>
+    | keyof RouteMap
+    | DefineDataColadaLoaderOptions<isLazy, keyof RouteMap, Data>,
+  _options?: DefineDataColadaLoaderOptions<isLazy, keyof RouteMap, Data>
 ): UseDataLoaderColada<isLazy, Data> {
   // TODO: make it DEV only and remove the first argument in production mode
   // resolve option overrides
@@ -80,7 +77,7 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
     _options ||
     (nameOrOptions as DefineDataColadaLoaderOptions<
       isLazy,
-      RouteRecordName,
+      keyof RouteMap,
       Data
     >)
   const loader = _options.query
@@ -89,13 +86,13 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
     ...DEFAULT_DEFINE_LOADER_OPTIONS,
     ..._options,
     commit: _options?.commit || 'after-load',
-  } as DefineDataColadaLoaderOptions<isLazy, RouteRecordName, Data>
+  } as DefineDataColadaLoaderOptions<isLazy, keyof RouteMap, Data>
 
   let isInitial = true
 
   function load(
     to: RouteLocationNormalizedLoaded,
-    router: UntypedRouter,
+    router: Router,
     parent?: DataLoaderEntryBase,
     reload?: boolean
   ): Promise<void> {
@@ -329,7 +326,7 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
     // work with nested data loaders
     const [parentEntry, _router, _route] = getCurrentContext()
     // fallback to the global router and routes for useDataLoaders used within components
-    const router = (_router as UntypedRouter) || useRouter()
+    const router = _router || useRouter()
     const route = _route || (useRoute() as RouteLocationNormalizedLoaded)
 
     const entries = router[
@@ -447,7 +444,7 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
 
 export interface DefineDataColadaLoaderOptions<
   isLazy extends boolean,
-  Name extends RouteRecordName,
+  Name extends keyof RouteMap,
   Data,
 > extends DefineDataLoaderOptionsBase<isLazy>,
     Omit<UseQueryOptions<unknown>, 'query' | 'key'> {
@@ -558,7 +555,7 @@ const DEFAULT_DEFINE_LOADER_OPTIONS = {
   server: true,
   commit: 'after-load',
 } satisfies Omit<
-  DefineDataColadaLoaderOptions<boolean, RouteRecordName, unknown>,
+  DefineDataColadaLoaderOptions<boolean, keyof RouteMap, unknown>,
   'key' | 'query'
 >
 
diff --git a/src/data-loaders/defineLoader.spec.ts b/src/data-loaders/defineLoader.spec.ts
index 8710cbaa2..b094ef773 100644
--- a/src/data-loaders/defineLoader.spec.ts
+++ b/src/data-loaders/defineLoader.spec.ts
@@ -158,7 +158,8 @@ describe(
             loaders: [l1, l2],
           },
         })
-        const wrapper = mount(RouterViewMock, {
+
+        mount(RouterViewMock, {
           global: {
             plugins: [
               [
@@ -184,7 +185,7 @@ describe(
         const spy = vi
           .fn<[to: RouteLocationNormalizedLoaded], Promise<string>>()
           .mockResolvedValue('initial')
-        const { wrapper, app, router, useData } = singleLoaderOneRoute(
+        const { router, useData } = singleLoaderOneRoute(
           defineBasicLoader(spy, { key: 'root' })
         )
         router[INITIAL_DATA_KEY] = { root: 'initial' }
@@ -199,7 +200,7 @@ describe(
         const spy = vi
           .fn<[to: RouteLocationNormalizedLoaded], Promise<string>>()
           .mockImplementation(async (to) => to.query.p as string)
-        const { wrapper, app, router, useData } = singleLoaderOneRoute(
+        const { router, useData } = singleLoaderOneRoute(
           defineBasicLoader(spy, { key: 'root' })
         )
 
diff --git a/src/data-loaders/defineLoader.ts b/src/data-loaders/defineLoader.ts
index d5211c7a0..bb016f28b 100644
--- a/src/data-loaders/defineLoader.ts
+++ b/src/data-loaders/defineLoader.ts
@@ -1,9 +1,10 @@
-import { useRoute, useRouter, type Router as UntypedRouter } from 'vue-router'
-import type {
-  RouteLocationNormalizedLoaded,
-  RouteRecordName,
-  Router,
-} from 'unplugin-vue-router/types'
+import {
+  type RouteLocationNormalizedLoaded,
+  type RouteMap,
+  useRoute,
+  useRouter,
+  type Router,
+} from 'vue-router'
 import type {
   DataLoaderContextBase,
   DataLoaderEntryBase,
@@ -41,7 +42,7 @@ import { shallowRef } from 'vue'
  * @param options - options to configure the data loader
  */
 export function defineBasicLoader<
-  Name extends RouteRecordName,
+  Name extends keyof RouteMap,
   Data,
   isLazy extends boolean,
 >(
@@ -63,7 +64,7 @@ export function defineBasicLoader<Data, isLazy extends boolean>(
 ): UseDataLoaderBasic<isLazy, Data>
 
 export function defineBasicLoader<Data, isLazy extends boolean>(
-  nameOrLoader: RouteRecordName | DefineLoaderFn<Data, DataLoaderContext>,
+  nameOrLoader: keyof RouteMap | DefineLoaderFn<Data, DataLoaderContext>,
   _loaderOrOptions?:
     | DefineDataLoaderOptions<isLazy>
     | DefineLoaderFn<Data, DataLoaderContext>,
@@ -86,7 +87,7 @@ export function defineBasicLoader<Data, isLazy extends boolean>(
 
   function load(
     to: RouteLocationNormalizedLoaded,
-    router: UntypedRouter,
+    router: Router,
     parent?: DataLoaderEntryBase
   ): Promise<void> {
     const entries = router[LOADER_ENTRIES_KEY]!
@@ -276,7 +277,7 @@ export function defineBasicLoader<Data, isLazy extends boolean>(
     // work with nested data loaders
     const [parentEntry, _router, _route] = getCurrentContext()
     // fallback to the global router and routes for useDataLoaders used within components
-    const router = (_router as UntypedRouter) || useRouter()
+    const router = _router || useRouter()
     const route = _route || (useRoute() as RouteLocationNormalizedLoaded)
 
     const entries = router[LOADER_ENTRIES_KEY]!
diff --git a/src/data-loaders/defineQueryLoader.spec.ts b/src/data-loaders/defineQueryLoader.spec.ts
index f546521a6..bf814c1cf 100644
--- a/src/data-loaders/defineQueryLoader.spec.ts
+++ b/src/data-loaders/defineQueryLoader.spec.ts
@@ -1,3 +1,4 @@
+// @ts-nocheck TODO: remove this line when implementing
 /**
  * @vitest-environment happy-dom
  */
diff --git a/src/data-loaders/defineQueryLoader.ts b/src/data-loaders/defineQueryLoader.ts
index 9210f2370..c5f926ea0 100644
--- a/src/data-loaders/defineQueryLoader.ts
+++ b/src/data-loaders/defineQueryLoader.ts
@@ -1,3 +1,4 @@
+// @ts-nocheck TODO: remove this line when implementing
 import { useRoute, useRouter } from 'vue-router'
 import {
   DataLoaderContextBase,
diff --git a/src/data-loaders/defineVueFireLoader.ts b/src/data-loaders/defineVueFireLoader.ts
index 51eed0530..1b8736c76 100644
--- a/src/data-loaders/defineVueFireLoader.ts
+++ b/src/data-loaders/defineVueFireLoader.ts
@@ -1,3 +1,4 @@
+// @ts-nocheck TODO: remove when implementing
 import {
   RouteLocationNormalizedLoaded,
   Router,
diff --git a/src/data-loaders/meta-extensions.spec.ts b/src/data-loaders/meta-extensions.spec.ts
deleted file mode 100644
index 35b39c942..000000000
--- a/src/data-loaders/meta-extensions.spec.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { describe, it } from 'vitest'
-import { defineComponent } from 'vue'
-import { createRouter, createMemoryHistory } from 'vue-router'
-import { defineBasicLoader } from './defineLoader'
-
-// TODO: transform into a test-d file
-
-describe('meta-extensions', () => {
-  it('has tds', () => {})
-})
-
-async function _dts() {
-  const component = defineComponent({})
-  const router = createRouter({
-    history: createMemoryHistory(),
-    routes: [
-      // empty
-      {
-        path: '/',
-        component,
-        meta: {
-          loaders: [],
-        },
-      },
-
-      // mixed
-      {
-        path: '/',
-        component,
-        meta: {
-          loaders: [
-            defineBasicLoader(async () => ({ name: 'foo' })),
-            defineBasicLoader(async () => ({ name: 'foo' }), {}),
-            defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
-            defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
-          ],
-        },
-      },
-
-      // only lazy: true
-      {
-        path: '/',
-        component,
-        meta: {
-          loaders: [
-            defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
-            defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
-          ],
-        },
-      },
-
-      // only lazy: false
-      {
-        path: '/',
-        component,
-        meta: {
-          loaders: [
-            defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
-            defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
-          ],
-        },
-      },
-    ],
-  })
-
-  router.addRoute({
-    path: '/',
-    component,
-    meta: {
-      loaders: [
-        defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
-        defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
-      ],
-    },
-  })
-
-  router.addRoute({
-    path: '/',
-    component,
-    meta: {
-      loaders: [
-        defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
-        defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
-      ],
-    },
-  })
-}
diff --git a/src/data-loaders/meta-extensions.test-d.ts b/src/data-loaders/meta-extensions.test-d.ts
new file mode 100644
index 000000000..5c7f1ee58
--- /dev/null
+++ b/src/data-loaders/meta-extensions.test-d.ts
@@ -0,0 +1,83 @@
+import { describe, it } from 'vitest'
+import { defineComponent } from 'vue'
+import { createRouter, createMemoryHistory } from 'vue-router'
+import { defineBasicLoader } from './defineLoader'
+
+describe('meta-extensions', () => {
+  it('works', () => {
+    const component = defineComponent({})
+    const router = createRouter({
+      history: createMemoryHistory(),
+      routes: [
+        // empty
+        {
+          path: '/',
+          component,
+          meta: {
+            loaders: [],
+          },
+        },
+
+        // mixed
+        {
+          path: '/',
+          component,
+          meta: {
+            loaders: [
+              defineBasicLoader(async () => ({ name: 'foo' })),
+              defineBasicLoader(async () => ({ name: 'foo' }), {}),
+              defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
+              defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
+            ],
+          },
+        },
+
+        // only lazy: true
+        {
+          path: '/',
+          component,
+          meta: {
+            loaders: [
+              defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
+              defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
+            ],
+          },
+        },
+
+        // only lazy: false
+        {
+          path: '/',
+          component,
+          meta: {
+            loaders: [
+              defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
+              defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
+            ],
+          },
+        },
+      ],
+    })
+
+    router.addRoute({
+      path: '/',
+      component,
+      meta: {
+        loaders: [
+          defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
+          defineBasicLoader(async () => ({ name: 'foo' }), { lazy: false }),
+        ],
+      },
+    })
+
+    router.addRoute({
+      path: '/',
+      component,
+      meta: {
+        loaders: [
+          defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
+          defineBasicLoader(async () => ({ name: 'foo' }), { lazy: true }),
+        ],
+      },
+    })
+  })
+})
diff --git a/src/data-loaders/navigation-guard.spec.ts b/src/data-loaders/navigation-guard.spec.ts
index b27f42248..38d40e4c6 100644
--- a/src/data-loaders/navigation-guard.spec.ts
+++ b/src/data-loaders/navigation-guard.spec.ts
@@ -184,7 +184,7 @@ describe('navigation-guard', () => {
       },
     })
 
-    const p = router.push('/fetch')
+    router.push('/fetch')
     await vi.runAllTimersAsync()
     l1.resolve()
     await vi.runAllTimersAsync()
@@ -208,7 +208,7 @@ describe('navigation-guard', () => {
       },
     })
 
-    const p = router.push('/fetch')
+    router.push('/fetch')
     await vi.runAllTimersAsync()
     expect(router.currentRoute.value.path).not.toBe('/fetch')
     l2.resolve()
diff --git a/src/data-loaders/navigation-guard.ts b/src/data-loaders/navigation-guard.ts
index 856baab03..1431ffd66 100644
--- a/src/data-loaders/navigation-guard.ts
+++ b/src/data-loaders/navigation-guard.ts
@@ -1,4 +1,3 @@
-import type { NavigationGuard, Router as UntypedRouter } from 'vue-router'
 import { isNavigationFailure } from 'vue-router'
 import { effectScope, type App, type EffectScope } from 'vue'
 import {
@@ -12,9 +11,11 @@ import {
 } from './meta-extensions'
 import { assign, isDataLoader, setCurrentContext } from './utils'
 import type {
+  NavigationGuard,
+  NavigationGuardReturn,
   RouteLocationNormalizedLoaded,
   Router,
-} from 'unplugin-vue-router/types'
+} from 'vue-router'
 import { type _Awaitable } from '../utils'
 import { type UseDataLoader } from './createDataLoader'
 
@@ -63,7 +64,7 @@ export function setupLoaderGuard({
   router[IS_SSR_KEY] = !!isSSR
 
   // guard to add the loaders to the meta property
-  const removeLoaderGuard = (router as UntypedRouter).beforeEach((to) => {
+  const removeLoaderGuard = router.beforeEach((to) => {
     // Abort any pending navigation. For cancelled navigations, this will happen before the `router.afterEach()`
     if (router[PENDING_LOCATION_KEY]) {
       // we could craft a navigation failure here but vue-router doesn't expose createRouterError() (yet?) and we don't
@@ -129,112 +130,105 @@ export function setupLoaderGuard({
     })
   })
 
-  const removeDataLoaderGuard = (router as UntypedRouter).beforeResolve(
-    (to) => {
-      // if we reach this guard, all properties have been set
-      const loaders = Array.from(to.meta[LOADER_SET_KEY]!) as UseDataLoader[]
-
-      // TODO: could we benefit anywhere here from verifying the signal is aborted and not call the loaders at all
-      // if (to.meta[ABORT_CONTROLLER_KEY]!.signal.aborted) {
-      //   return to.meta[ABORT_CONTROLLER_KEY]!.signal.reason ?? false
-      // }
-
-      // unset the context so all loaders are executed as root loaders
-      setCurrentContext([])
-      return Promise.all(
-        loaders.map((loader) => {
-          const { server, lazy } = loader._.options
-          // do not run on the server if specified
-          if (!server && isSSR) {
-            return
-          }
-          // keep track of loaders that should be committed after all loaders are done
-          const ret = effect.run(() =>
-            app
-              // allows inject and provide APIs
-              .runWithContext(() =>
-                loader._.load(to as RouteLocationNormalizedLoaded, router)
-              )
-          )!
-
-          // on client-side, lazy loaders are not awaited, but on server they are
-          // we already checked for the `server` option above
-          return !isSSR && lazy
-            ? undefined
-            : // return the non-lazy loader to commit changes after all loaders are done
-              ret
-        })
-      ) // let the navigation go through by returning true or void
-        .then(() => {
-          // console.log(
-          //   `✨ Navigation results "${to.fullPath}": [${to.meta[
-          //     NAVIGATION_RESULTS_KEY
-          //   ]!.map((r) => JSON.stringify(r.value)).join(', ')}]`
-          // )
-          if (to.meta[NAVIGATION_RESULTS_KEY]!.length) {
-            return selectNavigationResult(to.meta[NAVIGATION_RESULTS_KEY]!)
-          }
-        })
-        .catch((error) =>
-          error instanceof NavigationResult
-            ? error.value
-            : // let the error propagate to router.onError()
-              // we use never because the rejection means we never resolve a value and using anything else
-              // will not be valid from the navigation guard's perspective
-              Promise.reject<never>(error)
-        )
-    }
-  )
+  const removeDataLoaderGuard = router.beforeResolve((to) => {
+    // if we reach this guard, all properties have been set
+    const loaders = Array.from(to.meta[LOADER_SET_KEY]!) as UseDataLoader[]
+
+    // TODO: could we benefit anywhere here from verifying the signal is aborted and not call the loaders at all
+    // if (to.meta[ABORT_CONTROLLER_KEY]!.signal.aborted) {
+    //   return to.meta[ABORT_CONTROLLER_KEY]!.signal.reason ?? false
+    // }
+
+    // unset the context so all loaders are executed as root loaders
+    setCurrentContext([])
+    return Promise.all(
+      loaders.map((loader) => {
+        const { server, lazy } = loader._.options
+        // do not run on the server if specified
+        if (!server && isSSR) {
+          return
+        }
+        // keep track of loaders that should be committed after all loaders are done
+        const ret = effect.run(() =>
+          app
+            // allows inject and provide APIs
+            .runWithContext(() =>
+              loader._.load(to as RouteLocationNormalizedLoaded, router)
+            )
+        )!
+
+        // on client-side, lazy loaders are not awaited, but on server they are
+        // we already checked for the `server` option above
+        return !isSSR && lazy
+          ? undefined
+          : // return the non-lazy loader to commit changes after all loaders are done
+            ret
+      })
+    ) // let the navigation go through by returning true or void
+      .then(() => {
+        // console.log(
+        //   `✨ Navigation results "${to.fullPath}": [${to.meta[
+        //     NAVIGATION_RESULTS_KEY
+        //   ]!.map((r) => JSON.stringify(r.value)).join(', ')}]`
+        // )
+        if (to.meta[NAVIGATION_RESULTS_KEY]!.length) {
+          return selectNavigationResult(to.meta[NAVIGATION_RESULTS_KEY]!)
+        }
+      })
+      .catch((error) =>
+        error instanceof NavigationResult
+          ? error.value
+          : // let the error propagate to router.onError()
+            // we use never because the rejection means we never resolve a value and using anything else
+            // will not be valid from the navigation guard's perspective
+            Promise.reject<never>(error)
+      )
+  })
 
   // listen to duplicated navigation failures to reset the pendingTo and pendingLoad
   // since they won't trigger the beforeEach or beforeResolve defined above
-  const removeAfterEach = (router as UntypedRouter).afterEach(
-    (to, _from, failure) => {
-      // console.log(
-      //   `🔚 afterEach "${_from.fullPath}" -> "${to.fullPath}": ${failure?.message}`
-      // )
-      if (failure) {
-        // abort the signal of a failed navigation
-        // we need to check if it exists because the navigation guard that creates
-        // the abort controller could not be triggered depending on the failure
-        to.meta[ABORT_CONTROLLER_KEY]?.abort(failure)
-
-        if (
-          // NOTE: using a smaller version to cutoff some bytes
-          isNavigationFailure(
-            failure,
-            16 /* NavigationFailureType.duplicated */
-          )
-        ) {
-          for (const loader of to.meta[LOADER_SET_KEY]!) {
-            const entry = loader._.getEntry(router as Router)
-            entry.resetPending()
-          }
-        }
-      } else {
+  const removeAfterEach = router.afterEach((to, _from, failure) => {
+    // console.log(
+    //   `🔚 afterEach "${_from.fullPath}" -> "${to.fullPath}": ${failure?.message}`
+    // )
+    if (failure) {
+      // abort the signal of a failed navigation
+      // we need to check if it exists because the navigation guard that creates
+      // the abort controller could not be triggered depending on the failure
+      to.meta[ABORT_CONTROLLER_KEY]?.abort(failure)
+
+      if (
+        // NOTE: using a smaller version to cutoff some bytes
+        isNavigationFailure(failure, 16 /* NavigationFailureType.duplicated */)
+      ) {
         for (const loader of to.meta[LOADER_SET_KEY]!) {
-          const { commit, lazy } = loader._.options
-          if (commit === 'after-load') {
-            const entry = loader._.getEntry(router as Router)
-            // lazy loaders do not block the navigation so the navigation guard
-            // might call commit before the loader is ready
-            // on the server, entries might not even exist
-            if (entry && (!lazy || !entry.isLoading.value)) {
-              entry.commit(to as RouteLocationNormalizedLoaded)
-            }
+          const entry = loader._.getEntry(router as Router)
+          entry.resetPending()
+        }
+      }
+    } else {
+      for (const loader of to.meta[LOADER_SET_KEY]!) {
+        const { commit, lazy } = loader._.options
+        if (commit === 'after-load') {
+          const entry = loader._.getEntry(router as Router)
+          // lazy loaders do not block the navigation so the navigation guard
+          // might call commit before the loader is ready
+          // on the server, entries might not even exist
+          if (entry && (!lazy || !entry.isLoading.value)) {
+            entry.commit(to as RouteLocationNormalizedLoaded)
           }
         }
       }
+    }
 
-      // avoid this navigation being considered valid by the loaders
-      if (router[PENDING_LOCATION_KEY] === to) {
-        router[PENDING_LOCATION_KEY] = null
-      }
+    // avoid this navigation being considered valid by the loaders
+    if (router[PENDING_LOCATION_KEY] === to) {
+      router[PENDING_LOCATION_KEY] = null
     }
-  )
+  })
 
   // abort the signal on thrown errors
-  const removeOnError = (router as UntypedRouter).onError((error, to) => {
+  const removeOnError = router.onError((error, to) => {
     // same as with afterEach, we check if it exists because the navigation guard
     // that creates the abort controller could not be triggered depending on the error
     to.meta[ABORT_CONTROLLER_KEY]?.abort(error)
@@ -355,7 +349,7 @@ export interface DataLoaderPluginOptions {
   /**
    * The router instance. Adds the guards to it
    */
-  router: Router | UntypedRouter
+  router: Router
 
   isSSR?: boolean
 
@@ -366,7 +360,5 @@ export interface DataLoaderPluginOptions {
    */
   selectNavigationResult?: (
     results: NavigationResult[]
-  ) => _Awaitable<
-    Exclude<ReturnType<NavigationGuard>, Function | Promise<unknown>>
-  >
+  ) => _Awaitable<Exclude<NavigationGuardReturn, Function | Promise<unknown>>>
 }
diff --git a/src/data-loaders/utils.ts b/src/data-loaders/utils.ts
index e6999e6bd..d91e0e32e 100644
--- a/src/data-loaders/utils.ts
+++ b/src/data-loaders/utils.ts
@@ -1,9 +1,6 @@
 import type { DataLoaderEntryBase, UseDataLoader } from './createDataLoader'
 import { IS_USE_DATA_LOADER_KEY } from './meta-extensions'
-import type {
-  Router,
-  RouteLocationNormalizedLoaded,
-} from 'unplugin-vue-router/types'
+import type { Router, RouteLocationNormalizedLoaded } from 'vue-router'
 import { type LocationQuery } from 'vue-router'
 
 /**
diff --git a/src/type-extensions/RouterLink.ts b/src/type-extensions/RouterLink.ts
deleted file mode 100644
index ca8f302dc..000000000
--- a/src/type-extensions/RouterLink.ts
+++ /dev/null
@@ -1,86 +0,0 @@
-import type {
-  AllowedComponentProps,
-  ComponentCustomProps,
-  VNodeProps,
-  VNode,
-  ComputedRef,
-  UnwrapRef,
-  Ref,
-} from 'vue'
-import type {
-  NavigationFailure,
-  RouteLocationRaw,
-  RouterLinkProps as _RouterLinkProps,
-} from 'vue-router'
-import type { _RouterTyped } from './router'
-
-// TODO: could this have a name generic to type the slot? is it possible
-
-import type { _RouteMapGeneric } from '../codegen/generateRouteMap'
-import type {
-  RouteLocationAsPathTyped,
-  RouteLocationAsPathTypedList,
-  RouteLocationAsRelativeTyped,
-  RouteLocationAsRelativeTypedList,
-  RouteLocationAsString,
-  RouteLocationResolvedTypedList,
-} from './routeLocation'
-
-/**
- * Typed version of `RouterLinkProps`.
- */
-export interface RouterLinkPropsTyped<
-  RouteMap extends _RouteMapGeneric,
-  Name extends keyof RouteMap = keyof RouteMap,
-> extends Omit<_RouterLinkProps, 'to'> {
-  to:
-    | RouteLocationAsString<RouteMap>
-    | RouteLocationAsRelativeTypedList<RouteMap>[Name]
-    | RouteLocationAsPathTypedList<RouteMap>[Name]
-}
-
-/**
- * Typed version of `<RouterLink>` component.
- */
-export interface RouterLinkTyped<RouteMap extends _RouteMapGeneric> {
-  new (): {
-    $props: AllowedComponentProps &
-      ComponentCustomProps &
-      VNodeProps &
-      RouterLinkPropsTyped<RouteMap>
-
-    $slots: {
-      default: (arg: UnwrapRef<_UseLinkReturnTyped<RouteMap>>) => VNode[]
-    }
-  }
-}
-
-// TODO: should be exposed by the router instead
-/**
- * Return type of `useLink()`. Should be exposed by the router instead.
- * @internal
- */
-export interface _UseLinkReturnTyped<
-  RouteMap extends _RouteMapGeneric,
-  Name extends keyof RouteMap = keyof RouteMap,
-> {
-  route: ComputedRef<RouteLocationResolvedTypedList<RouteMap>[Name]>
-  href: ComputedRef<string>
-  isActive: ComputedRef<boolean>
-  isExactActive: ComputedRef<boolean>
-  navigate(e?: MouseEvent): Promise<void | NavigationFailure>
-}
-
-/**
- * Typed version of `useLink()`.
- */
-export interface UseLinkFnTyped<RouteMap extends _RouteMapGeneric> {
-  <Name extends keyof RouteMap = keyof RouteMap>(props: {
-    to:
-      | RouteLocationAsString<RouteMap>
-      | RouteLocationAsRelativeTyped<RouteMap, Name>
-      | RouteLocationAsPathTyped<RouteMap, Name>
-      | Ref<RouteLocationRaw>
-    replace?: boolean | undefined | Ref<boolean | undefined>
-  }): _UseLinkReturnTyped<RouteMap, Name>
-}
diff --git a/src/type-extensions/RouterTyped.test-d.ts b/src/type-extensions/RouterTyped.test-d.ts
index 23d1b6f84..d0dc7fb6a 100644
--- a/src/type-extensions/RouterTyped.test-d.ts
+++ b/src/type-extensions/RouterTyped.test-d.ts
@@ -1,16 +1,15 @@
+// @ts-nocheck: FIXME: move to vue-router and figure out how to make the types work without module augmentation
 import { describe, it, expectTypeOf } from 'vitest'
 import type {
   RouteRecordInfo,
-  _RouteMapGeneric,
-} from '../codegen/generateRouteMap'
-import type {
   ParamValue,
   ParamValueOneOrMore,
-} from '../codegen/generateRouteParams'
+  RouteMapGeneric,
+} from 'vue-router'
 import type { _RouterTyped as RouterTyped } from './router'
 import { RouteLocationTyped } from './routeLocation'
 
-function defineRouter<RM extends _RouteMapGeneric>(): RouterTyped<RM> {
+function defineRouter<RM extends RouteMapGeneric>(): RouterTyped<RM> {
   return {} as RouterTyped<RM>
 }
 
diff --git a/src/type-extensions/navigationGuards.ts b/src/type-extensions/navigationGuards.ts
deleted file mode 100644
index 848ccc7d9..000000000
--- a/src/type-extensions/navigationGuards.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-// original is
-
-import type { NavigationGuardNext, NavigationFailure } from 'vue-router'
-import type { _RouteMapGeneric } from '../codegen/generateRouteMap'
-import type {
-  _RouteLocationNormalizedLoaded,
-  RouteLocationNormalizedTypedList,
-  RouteLocationNormalizedLoadedTypedList,
-  RouteLocationAsString,
-  RouteLocationAsRelativeTypedList,
-  RouteLocationAsPathTypedList,
-} from './routeLocation'
-import type { RouteNamedMap, TypesConfig } from './types-config'
-import { type _Awaitable } from '../utils'
-
-/**
- * Return types for a Navigation Guard. Accepts a type param for the RouteMap.
- */
-type NavigationGuardReturnTyped<RouteMap extends _RouteMapGeneric> =
-  | void
-  | Error
-  | boolean
-  | RouteLocationAsString<RouteMap>
-  | RouteLocationAsRelativeTypedList<RouteMap>[keyof RouteMap]
-  | RouteLocationAsPathTypedList<RouteMap>[keyof RouteMap]
-
-/**
- * Return types for a Navigation Guard. Based on `TypesConfig`
- *
- * @see {@link TypesConfig}
- * @see {@link NavigationGuardReturnTyped}
- */
-export type NavigationGuardReturn = NavigationGuardReturnTyped<RouteNamedMap>
-
-/**
- * Typed Navigation Guard with a type parameter for `this` and another for the route map.
- */
-export interface NavigationGuardWithThisTyped<
-  T,
-  RouteMap extends _RouteMapGeneric,
-> {
-  (
-    this: T,
-    to: RouteLocationNormalizedTypedList<RouteMap>[keyof RouteMap],
-    from: RouteLocationNormalizedLoadedTypedList<RouteMap>[keyof RouteMap],
-    // intentionally not typed to make people use the return
-    next: NavigationGuardNext
-  ): _Awaitable<NavigationGuardReturnTyped<RouteMap>>
-}
-
-/**
- * Typed Navigation Guard with a type parameter for `this`. Based on `TypesConfig`
- * @see {@link TypesConfig}
- * @see {@link NavigationGuardWithThisTyped}
- */
-export interface NavigationGuardWithThis<T>
-  extends NavigationGuardWithThisTyped<T, RouteNamedMap> {}
-
-/**
- * In `router.beforeResolve((to) => {})`, the `to` is typed as `RouteLocationNormalizedLoaded`, not
- * `RouteLocationNormalized` like in `router.beforeEach()`. In practice it doesn't change much as users do not rely on
- * the difference between them but if we update the type in vue-router, we will have to update this type too.
- * @internal
- */
-export interface _NavigationGuardResolved {
-  (
-    this: undefined,
-    to: _RouteLocationNormalizedLoaded,
-    from: _RouteLocationNormalizedLoaded,
-    // intentionally not typed to make people use the return
-    next: NavigationGuardNext
-  ): _Awaitable<NavigationGuardReturn>
-}
-
-/**
- * Typed Navigation Guard. Accepts a type param for the RouteMap.
- */
-export interface NavigationGuardTyped<RouteMap extends _RouteMapGeneric> {
-  (
-    to: RouteLocationNormalizedTypedList<RouteMap>[keyof RouteMap],
-    from: RouteLocationNormalizedLoadedTypedList<RouteMap>[keyof RouteMap],
-    // intentionally not typed to make people use the return
-    next: NavigationGuardNext
-  ): _Awaitable<NavigationGuardReturnTyped<RouteMap>>
-}
-
-/**
- * Typed Navigation Guard. Based on `TypesConfig`.
- * @see {@link TypesConfig}
- * @see {@link NavigationGuardWithThisTyped}
- */
-export interface NavigationGuard extends NavigationGuardTyped<RouteNamedMap> {}
-
-/**
- * Typed Navigation Hook After. Accepts a type param for the RouteMap.
- */
-export interface NavigationHookAfterTyped<RouteMap extends _RouteMapGeneric> {
-  (
-    to: RouteLocationNormalizedTypedList<RouteMap>[keyof RouteMap],
-    from: RouteLocationNormalizedLoadedTypedList<RouteMap>[keyof RouteMap],
-    failure?: NavigationFailure | void
-  ): unknown
-}
-
-/**
- * Typed Navigation Hook After. Based on `TypesConfig`.
- * @see {@link TypesConfig}
- * @see {@link NavigationHookAfterTyped}
- */
-export interface NavigationHookAfter
-  extends NavigationHookAfterTyped<RouteNamedMap> {}
diff --git a/src/type-extensions/routeLocation.test-d.ts b/src/type-extensions/routeLocation.test-d.ts
index 9e7ee00da..d34538e5f 100644
--- a/src/type-extensions/routeLocation.test-d.ts
+++ b/src/type-extensions/routeLocation.test-d.ts
@@ -2,14 +2,13 @@ import { describe, it, expectTypeOf } from 'vitest'
 import type {
   RouteLocationNormalized,
   RouteRecordName,
-  TypesConfig,
   ParamValue,
   ParamValueZeroOrMore,
   RouteRecordInfo,
-} from '../types'
+} from 'vue-router'
 
 // TODO: could we move this to an .d.ts file that is only loaded for tests?
-declare module '../types' {
+declare module 'vue-router' {
   // Extend with some custom routes
   interface TypesConfig {
     RouteNamedMap: {
diff --git a/src/type-extensions/routeLocation.ts b/src/type-extensions/routeLocation.ts
deleted file mode 100644
index 824611621..000000000
--- a/src/type-extensions/routeLocation.ts
+++ /dev/null
@@ -1,165 +0,0 @@
-import type {
-  Router,
-  RouteParams,
-  RouteParamsRaw,
-  RouteLocation,
-  RouteLocationNormalized,
-  RouteLocationNormalizedLoaded,
-  RouteLocationOptions,
-  RouteQueryAndHash,
-  RouteRecordName,
-} from 'vue-router'
-import type { _RouteMapGeneric } from '../codegen/generateRouteMap'
-import type { LiteralStringUnion } from '../utils'
-// inlining the type as it avoids code splitting issues
-import type { RouteNamedMap } from './types-config'
-
-export type _RouteRecordName = keyof RouteNamedMap
-
-export interface RouteLocationNormalizedTyped<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-  Name extends keyof RouteMap = keyof RouteMap,
-> extends RouteLocationNormalized {
-  name: Extract<Name, RouteRecordName>
-  // we don't override path because it could contain params and in practice it's just not useful
-  params: RouteMap[Name]['params']
-}
-
-export type RouteLocationNormalizedTypedList<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-> = { [N in keyof RouteMap]: RouteLocationNormalizedTyped<RouteMap, N> }
-
-export interface RouteLocationNormalizedLoadedTyped<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-  Name extends keyof RouteMap = keyof RouteMap,
-> extends RouteLocationNormalizedLoaded {
-  name: Extract<Name, RouteRecordName>
-  // we don't override path because it could contain params and in practice it's just not useful
-  params: RouteMap[Name]['params']
-}
-
-export type RouteLocationNormalizedLoadedTypedList<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-> = { [N in keyof RouteMap]: RouteLocationNormalizedLoadedTyped<RouteMap, N> }
-
-export interface RouteLocationAsRelativeTyped<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-  Name extends keyof RouteMap = keyof RouteMap,
-> extends RouteQueryAndHash,
-    RouteLocationOptions {
-  name?: Name
-  params?: RouteMap[Name]['paramsRaw']
-}
-
-export type RouteLocationAsRelativeTypedList<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-> = { [N in keyof RouteMap]: RouteLocationAsRelativeTyped<RouteMap, N> }
-
-export interface RouteLocationAsPathTyped<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-  Name extends keyof RouteMap = keyof RouteMap,
-> extends RouteQueryAndHash,
-    RouteLocationOptions {
-  path: LiteralStringUnion<RouteMap[Name]['path']>
-}
-
-export type RouteLocationAsPathTypedList<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-> = { [N in keyof RouteMap]: RouteLocationAsPathTyped<RouteMap, N> }
-
-export type RouteLocationAsString<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-> = LiteralStringUnion<RouteMap[keyof RouteMap]['path'], string>
-
-export interface RouteLocationTyped<
-  RouteMap extends _RouteMapGeneric,
-  Name extends keyof RouteMap,
-> extends RouteLocation {
-  name: Extract<Name, RouteRecordName>
-  params: RouteMap[Name]['params']
-}
-
-export type RouteLocationTypedList<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-> = { [N in keyof RouteMap]: RouteLocationTyped<RouteMap, N> }
-
-export interface RouteLocationResolvedTyped<
-  RouteMap extends _RouteMapGeneric,
-  Name extends keyof RouteMap,
-> extends RouteLocationTyped<RouteMap, Name> {
-  href: string
-}
-
-export type RouteLocationResolvedTypedList<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-> = { [N in keyof RouteMap]: RouteLocationResolvedTyped<RouteMap, N> }
-
-/**
- * Type safe versions of types that are exposed by vue-router
- */
-
-/**
- * Type safe version of `RouteLocationNormalized`. Accepts the name of the route as a type parameter.
- * @see {@link RouteLocationNormalized}
- */
-export type _RouteLocationNormalized<
-  Name extends _RouteRecordName = _RouteRecordName,
-> = RouteLocationNormalizedTypedList<RouteNamedMap>[Name]
-
-/**
- * Type safe version of `RouteLocationNormalizedLoaded`. Accepts the name of the route as a type parameter.
- * @see {@link RouteLocationNormalizedLoaded}
- */
-export type _RouteLocationNormalizedLoaded<
-  Name extends _RouteRecordName = _RouteRecordName,
-> = RouteLocationNormalizedLoadedTypedList<RouteNamedMap>[Name]
-
-/**
- * Type safe version of `RouteLocationAsRelative`. Accepts the name of the route as a type parameter.
- * @see {@link RouteLocationAsRelative}
- */
-export type _RouteLocationAsRelativePath<
-  Name extends _RouteRecordName = _RouteRecordName,
-> = RouteLocationAsRelativeTypedList<RouteNamedMap>[Name]
-
-/**
- * Type safe version of `RouteLocationResolved` (the returned route of `router.resolve()`).
- * Allows passing the name of the route to be passed as a generic.
- * @see {@link Router['resolve']}
- */
-export type _RouteLocationResolved<
-  Name extends keyof RouteNamedMap = keyof RouteNamedMap,
-> = RouteLocationResolvedTypedList<RouteNamedMap>[Name]
-
-/**
- * Type safe version of `RouteLocation` . Allows passing the name of the route to be passed as a generic.
- * @see {@link RouteLocation}
- */
-export type _RouteLocation<
-  Name extends keyof RouteNamedMap = keyof RouteNamedMap,
-> = RouteLocationTypedList<RouteNamedMap>[Name]
-
-/**
- * Type safe version of `RouteLocationRaw` . Allows passing the name of the route to be passed as a generic.
- * @see {@link RouteLocationRaw}
- */
-export type _RouteLocationRaw<
-  Name extends keyof RouteNamedMap = keyof RouteNamedMap,
-> =
-  | RouteLocationAsString<RouteNamedMap>
-  | RouteLocationAsRelativeTypedList<RouteNamedMap>[Name]
-  | RouteLocationAsPathTypedList<RouteNamedMap>[Name]
-
-/**
- * Generate a type safe params for a route location. Requires the name of the route to be passed as a generic.
- * @see {@link RouteParams}
- */
-export type _RouteParams<Name extends keyof RouteNamedMap> =
-  RouteNamedMap[Name]['params']
-
-/**
- * Generate a type safe raw params for a route location. Requires the name of the route to be passed as a generic.
- * @see {@link RouteParamsRaw}
- */
-export type _RouteParamsRaw<Name extends keyof RouteNamedMap> =
-  RouteNamedMap[Name]['paramsRaw']
diff --git a/src/type-extensions/router.ts b/src/type-extensions/router.ts
deleted file mode 100644
index f420c41a8..000000000
--- a/src/type-extensions/router.ts
+++ /dev/null
@@ -1,167 +0,0 @@
-import type { ShallowRef } from 'vue'
-import type {
-  Router,
-  RouteLocationNormalizedLoaded,
-  RouteRecordRaw,
-  RouterOptions,
-} from 'vue-router'
-import type {
-  RouteLocationResolvedTypedList,
-  RouteLocationNormalizedLoadedTypedList,
-  RouteLocationAsString,
-  RouteLocationAsRelativeTyped,
-  RouteLocationAsPathTyped,
-  RouteLocationAsRelativeTypedList,
-  RouteLocationAsPathTypedList,
-} from './routeLocation'
-import type { _RouteMapGeneric } from '../codegen/generateRouteMap'
-import type {
-  NavigationGuardWithThisTyped,
-  NavigationHookAfterTyped,
-} from './navigationGuards'
-import type { RouteNamedMap, TypesConfig } from './types-config'
-
-/**
- * NOTE: Ideally, these should be moved to vue-router in the future to enable typed routes in the core. What's left to
- * confirm is if the strategy relying on a `TypesConfig` is the future proof. Moving this to vue-router would also
- * remove the double documentation.
- */
-
-export interface _RouterTyped<
-  RouteMap extends _RouteMapGeneric = _RouteMapGeneric,
-> extends Omit<
-    Router,
-    | 'resolve'
-    | 'push'
-    | 'replace'
-    | 'beforeEach'
-    | 'beforeResolve'
-    | 'afterEach'
-    | 'currentRoute'
-  > {
-  /**
-   * Current {@link RouteLocationNormalized}. Prefer using `useRoute()` instead.
-   */
-  currentRoute: ShallowRef<
-    RouteLocationNormalizedLoadedTypedList<RouteMap>[keyof RouteMap]
-  >
-
-  /**
-   * Programmatically navigate to a new URL by pushing an entry in the history
-   * stack.
-   *
-   * @param to - Route location to navigate to
-   */
-  push(
-    to:
-      | RouteLocationAsString<RouteMap>
-      | RouteLocationAsRelativeTypedList<RouteMap>[keyof RouteMap]
-      | RouteLocationAsPathTypedList<RouteMap>[keyof RouteMap]
-  ): ReturnType<Router['push']>
-
-  /**
-   * Programmatically navigate to a new URL by replacing the current entry in
-   * the history stack. Equivalent to `router.push({ replace: true })`.
-   *
-   * @param to - Route location to navigate to
-   */
-  replace(
-    to:
-      | RouteLocationAsString<RouteMap>
-      | RouteLocationAsRelativeTypedList<RouteMap>[keyof RouteMap]
-      | RouteLocationAsPathTypedList<RouteMap>[keyof RouteMap]
-  ): ReturnType<Router['replace']>
-
-  /**
-   * Returns the {@link RouteLocation | normalized version} of a
-   * {@link RouteLocationRaw | route location}. Also includes an `href` property
-   * that includes any existing `base`. By default, the `currentLocation` used is
-   * `router.currentRoute` and should only be overridden in advanced use cases.
-   *
-   * @param to - Raw route location to resolve
-   * @param currentLocation - Optional current location to resolve against
-   */
-  resolve<Name extends keyof RouteMap = keyof RouteMap>(
-    to:
-      | RouteLocationAsString<RouteMap>
-      | RouteLocationAsRelativeTyped<RouteMap, Name>
-      | RouteLocationAsPathTyped<RouteMap, Name>,
-    currentLocation?: RouteLocationNormalizedLoaded
-  ): RouteLocationResolvedTypedList<RouteMap>[Name]
-
-  /**
-   * Add a navigation guard that executes before any navigation. Returns a
-   * function that removes the registered guard.
-   *
-   * @param guard - navigation guard to add
-   */
-  beforeEach(
-    guard: NavigationGuardWithThisTyped<undefined, RouteMap>
-  ): ReturnType<Router['beforeEach']>
-
-  /**
-   * Add a navigation guard that executes before navigation is about to be
-   * resolved. At this state all component have been fetched and other
-   * navigation guards have been successful. Returns a function that removes the
-   * registered guard.
-   *
-   * @param guard - navigation guard to add
-   * @returns a function that removes the registered guard
-   *
-   * @example
-   * ```js
-   * router.beforeResolve(to => {
-   *   if (to.meta.requiresAuth && !isAuthenticated) return false
-   * })
-   * ```
-   *
-   */
-  beforeResolve(
-    guard: NavigationGuardWithThisTyped<undefined, RouteMap>
-  ): ReturnType<Router['beforeResolve']>
-
-  /**
-   * Add a navigation hook that is executed after every navigation. Returns a
-   * function that removes the registered hook.
-   *
-   * @param guard - navigation hook to add
-   * @returns a function that removes the registered hook
-   *
-   * @example
-   * ```js
-   * router.afterEach((to, from, failure) => {
-   *   if (isNavigationFailure(failure)) {
-   *     console.log('failed navigation', failure)
-   *   }
-   * })
-   * ```
-   */
-  afterEach(
-    guard: NavigationHookAfterTyped<RouteMap>
-  ): ReturnType<Router['beforeEach']>
-}
-
-/**
- * Type safe version of `Router`. Used internally by loaders and other methods to provide a typed API without having to pass the RouteNamedMap.
- * @see {@link Router}
- */
-export type _Router =
-  TypesConfig extends Record<'RouteNamedMap', any>
-    ? _RouterTyped<RouteNamedMap>
-    : Router
-
-/**
- * unplugin-vue-router version of `RouterOptions`.
- * @deprecated use `RouterOptions` instead. This type is no longer needed.
- * @see {@link RouterOptions}
- */
-export interface _RouterOptions extends RouterOptions {
-  /**
-   * Modify the routes before they are passed to the router. You can modify the existing array or return a
-   * new one.
-   * @deprecated `routes` is now required, so you can just modify a copy of the array directly.
-   *
-   * @param routes - The routes generated by this plugin and exposed by `vue-router/auto-routes`
-   */
-  extendRoutes?: (routes: RouteRecordRaw[]) => RouteRecordRaw[] | void
-}
diff --git a/src/type-extensions/types-config.ts b/src/type-extensions/types-config.ts
deleted file mode 100644
index efbb6bd40..000000000
--- a/src/type-extensions/types-config.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { type RouteRecordInfo } from '../types'
-
-/**
- * Allows using types that are generated at build-time. **ONLY FOR INTERNAL USAGE**.
- *
- * @internal
- */
-export interface TypesConfig {}
-
-/**
- * Convenience type to get the typed RouteMap or a generic one if not provided.
- */
-export type RouteNamedMap =
-  TypesConfig extends Record<'RouteNamedMap', infer RouteNamedMap>
-    ? RouteNamedMap
-    : Record<string, RouteRecordInfo>
diff --git a/src/types.ts b/src/types.ts
index 97ea8e4ad..af4b1104c 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -3,69 +3,6 @@
  * https://github.com/posva/unplugin-vue-router/issues/136
  */
 
-export type {
-  _RouteMapGeneric,
-  RouteRecordInfo,
-} from './codegen/generateRouteMap'
-export type {
-  // TODO: mark all of these as internals since the dynamically exposed versions are fully typed, these are just helpers
-  // to generate the convenient types
-  RouteLocationAsRelativeTyped,
-  RouteLocationAsRelativeTypedList,
-  RouteLocationAsPathTyped,
-  RouteLocationAsPathTypedList,
-  RouteLocationAsString,
-  RouteLocationTyped,
-  RouteLocationTypedList,
-  RouteLocationResolvedTyped,
-  RouteLocationResolvedTypedList,
-  RouteLocationNormalizedTyped,
-  RouteLocationNormalizedTypedList,
-  RouteLocationNormalizedLoadedTyped,
-  RouteLocationNormalizedLoadedTypedList,
-
-  // Types that exist in Vue Router but are augmented to be typed if TypesConfig is provided
-  // with the RouteNamedMap
-  _RouteLocationNormalized as RouteLocationNormalized,
-  _RouteRecordName as RouteRecordName,
-  _RouteLocationNormalizedLoaded as RouteLocationNormalizedLoaded,
-  _RouteLocation as RouteLocation,
-  _RouteLocationAsRelativePath as RouteLocationAsRelativePath,
-  _RouteLocationRaw as RouteLocationRaw,
-  _RouteLocationResolved as RouteLocationResolved,
-  _RouteParams as RouteParams,
-  _RouteParamsRaw as RouteParamsRaw,
-} from './type-extensions/routeLocation'
-export type {
-  NavigationGuardReturn,
-  NavigationGuard,
-  NavigationGuardWithThis,
-  // typed helpers
-  NavigationGuardTyped,
-  NavigationGuardWithThisTyped,
-  NavigationHookAfterTyped,
-} from './type-extensions/navigationGuards'
-export type {
-  // TODO: deprecate and remove
-  _RouterTyped,
-  _Router as Router,
-  // FIXME: remove in the next major version
-  _RouterOptions,
-} from './type-extensions/router'
-export type {
-  RouterLinkTyped,
-  UseLinkFnTyped,
-  _UseLinkReturnTyped,
-  RouterLinkPropsTyped,
-} from './type-extensions/RouterLink'
-export type { TypesConfig, RouteNamedMap } from './type-extensions/types-config'
-export type {
-  ParamValue,
-  ParamValueOneOrMore,
-  ParamValueZeroOrMore,
-  ParamValueZeroOrOne,
-} from './codegen/generateRouteParams'
-
 export type { Options } from './options'
 export type { TreeNode } from './core/tree'
 export type {
diff --git a/tests/data-loaders/tester.ts b/tests/data-loaders/tester.ts
index 6a42d8cbe..0983e4392 100644
--- a/tests/data-loaders/tester.ts
+++ b/tests/data-loaders/tester.ts
@@ -18,14 +18,14 @@ import { mockPromise } from '../utils'
 import RouterViewMock from '../data-loaders/RouterViewMock.vue'
 import ComponentWithNestedLoader from '../data-loaders/ComponentWithNestedLoader.vue'
 import { dataOneSpy, dataTwoSpy } from '../data-loaders/loaders'
-import type { RouteLocationNormalizedLoaded as _RouteLocationNormalizedLoaded } from 'unplugin-vue-router/types'
+import type { RouteLocationNormalizedLoaded } from 'vue-router'
 import { mockWarn } from '../vitest-mock-warn'
 
 export function testDefineLoader<Context = void>(
   loaderFactory: (
     context: {
       fn: (
-        to: _RouteLocationNormalizedLoaded,
+        to: RouteLocationNormalizedLoaded,
         context: DataLoaderContextBase
       ) => Promise<unknown>
     } & DefineDataLoaderOptionsBase<boolean> & { key?: string }
@@ -134,7 +134,7 @@ export function testDefineLoader<Context = void>(
           const spy = vi
             .fn<unknown[], Promise<unknown>>()
             .mockResolvedValueOnce(null)
-          const { wrapper, useData, router } = singleLoaderOneRoute(
+          const { useData, router } = singleLoaderOneRoute(
             loaderFactory({ lazy, commit, fn: spy })
           )
           await router.push('/fetch')
@@ -148,7 +148,7 @@ export function testDefineLoader<Context = void>(
             .fn<unknown[], Promise<unknown>>()
             .mockResolvedValue('ko')
 
-          const { wrapper, useData, router } = singleLoaderOneRoute(
+          const { useData, router } = singleLoaderOneRoute(
             loaderFactory({ lazy, commit, fn: spy })
           )
           // initial navigation
@@ -163,7 +163,7 @@ export function testDefineLoader<Context = void>(
 
         it('can return a NavigationResult without affecting initial data', async () => {
           let calls = 0
-          const spy = vi.fn(async (to: _RouteLocationNormalizedLoaded) => {
+          const spy = vi.fn(async (to: RouteLocationNormalizedLoaded) => {
             return calls++ === 0 ? new NavigationResult('/other') : to.query.p
           })
           const { useData, router } = singleLoaderOneRoute(
@@ -177,7 +177,7 @@ export function testDefineLoader<Context = void>(
 
         it('can return a NavigationResult without affecting loaded data', async () => {
           let calls = 0
-          const spy = vi.fn(async (to: _RouteLocationNormalizedLoaded) => {
+          const spy = vi.fn(async (to: RouteLocationNormalizedLoaded) => {
             return calls++ > 0 ? new NavigationResult('/other') : to.query.p
           })
           const { useData, router } = singleLoaderOneRoute(
@@ -198,7 +198,7 @@ export function testDefineLoader<Context = void>(
           'can return a NavigationResult without affecting the last error',
           async () => {
             let calls = 0
-            const spy = vi.fn(async (to: _RouteLocationNormalizedLoaded) => {
+            const spy = vi.fn(async (to: RouteLocationNormalizedLoaded) => {
               return calls++ > 0
                 ? new NavigationResult('/other')
                 : Promise.reject(new Error(to.query.p as string))
@@ -207,7 +207,7 @@ export function testDefineLoader<Context = void>(
               loaderFactory({ lazy, commit, fn: spy })
             )
             await router.push('/fetch?p=ok').catch(() => {})
-            const { error, data } = useData()
+            const { error } = useData()
             expect(spy).toHaveBeenCalled()
             expect(error.value).toEqual(new Error('ok'))
             await router.push('/fetch?p=ko').catch(() => {})
@@ -237,7 +237,7 @@ export function testDefineLoader<Context = void>(
           const spy = vi
             .fn<unknown[], Promise<string>>()
             .mockResolvedValueOnce('resolved 1')
-          const { wrapper, router, useData } = singleLoaderOneRoute(
+          const { router, useData } = singleLoaderOneRoute(
             loaderFactory({ lazy, commit, fn: spy })
           )
           await router.push('/fetch')
@@ -263,7 +263,7 @@ export function testDefineLoader<Context = void>(
               return 'ok'
             }
           })
-          const { useData, router, wrapper } = singleLoaderOneRoute(
+          const { useData, router } = singleLoaderOneRoute(
             loaderFactory({
               fn: spy,
               lazy,
@@ -310,7 +310,7 @@ export function testDefineLoader<Context = void>(
       })
 
       it(`should abort the navigation if a non lazy loader throws, commit: ${commit}`, async () => {
-        const { wrapper, router } = singleLoaderOneRoute(
+        const { router } = singleLoaderOneRoute(
           loaderFactory({
             fn: async () => {
               throw new Error('nope')
@@ -337,7 +337,7 @@ export function testDefineLoader<Context = void>(
           })
         )
         await router.push('/fetch')
-        const { data, error, isLoading } = useData()
+        const { data, isLoading } = useData()
         expect(wrapper.get('#error').text()).toBe('Error: nope')
         expect(isLoading.value).toBe(false)
         expect(data.value).toBe(undefined)
@@ -350,7 +350,7 @@ export function testDefineLoader<Context = void>(
           commit,
           lazy: false,
         })
-        const { wrapper, app, router, useData } = singleLoaderOneRoute(
+        const { router } = singleLoaderOneRoute(
           loaderFactory({
             fn: async (to) => {
               const data = await l1.loader()
@@ -371,20 +371,18 @@ export function testDefineLoader<Context = void>(
 
   it('passes a signal to the loader', async () => {
     const spy = vi.fn<
-      [to: _RouteLocationNormalizedLoaded, context: DataLoaderContextBase],
+      [to: RouteLocationNormalizedLoaded, context: DataLoaderContextBase],
       Promise<unknown>
     >()
     spy.mockResolvedValueOnce('ok')
-    const { wrapper, useData, router } = singleLoaderOneRoute(
-      loaderFactory({ fn: spy })
-    )
+    const { router } = singleLoaderOneRoute(loaderFactory({ fn: spy }))
     await router.push('/fetch?p=ok')
     expect(spy).toHaveBeenCalledTimes(1)
     expect(spy.mock.calls.at(0)?.[1]?.signal).toBeInstanceOf(AbortSignal)
   })
 
   it('blocks navigation by default (non lazy)', async () => {
-    const [spy, resolve, reject] = mockPromise('resolved')
+    const [spy, resolve] = mockPromise('resolved')
     const { useData, router } = singleLoaderOneRoute(loaderFactory({ fn: spy }))
     const p = router.push('/fetch')
     await vi.runAllTimersAsync()
@@ -398,7 +396,7 @@ export function testDefineLoader<Context = void>(
   })
 
   it('does not block navigation when lazy loaded', async () => {
-    const [spy, resolve, reject] = mockPromise('resolved')
+    const [spy, resolve] = mockPromise('resolved')
     const { wrapper, useData, router } = singleLoaderOneRoute(
       loaderFactory({
         fn: spy,
@@ -427,7 +425,7 @@ export function testDefineLoader<Context = void>(
     let resolveSecondCall!: (val?: unknown) => void
     const p1 = new Promise((r) => (resolveFirstCall = r))
     const p2 = new Promise((r) => (resolveSecondCall = r))
-    const { wrapper, useData, router } = singleLoaderOneRoute(
+    const { useData, router } = singleLoaderOneRoute(
       loaderFactory({
         fn: async (to) => {
           calls++
@@ -462,7 +460,7 @@ export function testDefineLoader<Context = void>(
     const nestedP1 = new Promise((r) => (resolveNestedFirstCall = r))
     const nestedP2 = new Promise((r) => (resolveNestedSecondCall = r))
     const nestedLoaderSpy = vi
-      .fn<[to: _RouteLocationNormalizedLoaded], Promise<unknown>>()
+      .fn<[to: RouteLocationNormalizedLoaded], Promise<unknown>>()
       .mockImplementation(async (to) => {
         nestedCalls++
         if (nestedCalls === 1) {
@@ -484,7 +482,7 @@ export function testDefineLoader<Context = void>(
     const rootP2 = new Promise((r) => (resolveRootSecondCall = r))
 
     const rootLoaderSpy = vi
-      .fn<[to: _RouteLocationNormalizedLoaded], Promise<unknown>>()
+      .fn<[to: RouteLocationNormalizedLoaded], Promise<unknown>>()
       .mockImplementation(async (to) => {
         rootCalls++
         const data = await useNestedLoader()
@@ -496,7 +494,7 @@ export function testDefineLoader<Context = void>(
         return `${data},${to.query.p}`
       })
 
-    const { wrapper, useData, router, app } = singleLoaderOneRoute(
+    const { useData, router, app } = singleLoaderOneRoute(
       loaderFactory({ fn: rootLoaderSpy, key: 'root' })
     )
     const firstNavigation = router.push('/fetch?p=one')
@@ -582,7 +580,7 @@ export function testDefineLoader<Context = void>(
     const rootP1 = new Promise((r) => (resolveRootFirstCall = r))
     const rootP2 = new Promise((r) => (resolveRootSecondCall = r))
 
-    const { wrapper, useData, router, app } = singleLoaderOneRoute(
+    const { useData, router, app } = singleLoaderOneRoute(
       loaderFactory({
         fn: async (to) => {
           rootCalls++
@@ -631,7 +629,7 @@ export function testDefineLoader<Context = void>(
     const p2 = new Promise((r) => (resolveCall2 = r))
     const p3 = new Promise((r) => (resolveCall3 = r))
     const spy = vi
-      .fn<[to: _RouteLocationNormalizedLoaded], Promise<string>>()
+      .fn<[to: RouteLocationNormalizedLoaded], Promise<string>>()
       .mockImplementation(async (to) => {
         calls++
         // the first one should be skipped
@@ -646,9 +644,7 @@ export function testDefineLoader<Context = void>(
         }
         return to.query.p as string
       })
-    const { wrapper, useData, router } = singleLoaderOneRoute(
-      loaderFactory({ fn: spy })
-    )
+    const { useData, router } = singleLoaderOneRoute(loaderFactory({ fn: spy }))
     // set the initial location
     await router.push('/fetch?p=ok')
 
@@ -682,9 +678,9 @@ export function testDefineLoader<Context = void>(
   })
 
   it('loader result can be awaited for the data to be ready', async () => {
-    const [spy, resolve, reject] = mockPromise('resolved')
+    const [spy, resolve] = mockPromise('resolved')
 
-    const { wrapper, app, useData, router } = singleLoaderOneRoute(
+    const { app, useData, router } = singleLoaderOneRoute(
       loaderFactory({ fn: async () => spy(), key: 'a' })
     )
     router.push('/fetch')
@@ -718,7 +714,7 @@ export function testDefineLoader<Context = void>(
       },
       key: 'two',
     })
-    const { wrapper, useData, router } = singleLoaderOneRoute(useLoaderTwo)
+    const { useData, router } = singleLoaderOneRoute(useLoaderTwo)
     await router.push('/fetch')
     const { data } = useData()
     expect(spyOne).toHaveBeenCalledTimes(1)
@@ -741,7 +737,6 @@ export function testDefineLoader<Context = void>(
         ],
       },
     })
-    const app: App = wrapper.vm.$.appContext.app
 
     expect(dataOneSpy).toHaveBeenCalledTimes(0)
     await router.push('/fetch')
@@ -782,7 +777,6 @@ export function testDefineLoader<Context = void>(
         ],
       },
     })
-    const app: App = wrapper.vm.$.appContext.app
 
     router.push('/fetch?p=one')
     await vi.runOnlyPendingTimersAsync()
@@ -932,7 +926,7 @@ export function testDefineLoader<Context = void>(
 
   it('awaits for a lazy loader if used as a nested loader', async () => {
     const l1 = mockedLoader({ lazy: true, key: 'nested' })
-    const { wrapper, app, router, useData } = singleLoaderOneRoute(
+    const { useData, router } = singleLoaderOneRoute(
       loaderFactory({
         fn: async (to) => {
           const data = await l1.loader()
@@ -942,7 +936,7 @@ export function testDefineLoader<Context = void>(
       })
     )
 
-    const p = router.push('/fetch?p=one')
+    router.push('/fetch?p=one')
     await vi.runOnlyPendingTimersAsync()
 
     const { data } = useData()
@@ -955,7 +949,7 @@ export function testDefineLoader<Context = void>(
 
   describe('app.runWithContext()', () => {
     it('can inject globals', async () => {
-      const { wrapper, router, useData, app } = singleLoaderOneRoute(
+      const { router, useData, app } = singleLoaderOneRoute(
         loaderFactory({
           async fn() {
             return inject('key', 'ko')
@@ -975,7 +969,7 @@ export function testDefineLoader<Context = void>(
         },
         key: 'nested',
       })
-      const { wrapper, router, useData, app } = singleLoaderOneRoute(
+      const { router, useData, app } = singleLoaderOneRoute(
         loaderFactory({
           async fn() {
             return await nestedLoader()
@@ -1002,7 +996,7 @@ export function testDefineLoader<Context = void>(
         },
         key: 'l2',
       })
-      const { wrapper, router, useData, app } = singleLoaderOneRoute(
+      const { router, useData, app } = singleLoaderOneRoute(
         loaderFactory({
           fn: async () => {
             const a = await l1()
@@ -1019,7 +1013,7 @@ export function testDefineLoader<Context = void>(
     })
 
     it('can inject globals when reloaded', async () => {
-      const { wrapper, router, useData, app } = singleLoaderOneRoute(
+      const { router, useData, app } = singleLoaderOneRoute(
         loaderFactory({
           fn: async () => {
             return inject('key', 'ko')
@@ -1048,7 +1042,7 @@ export function testDefineLoader<Context = void>(
         },
         key: 'l2',
       })
-      const { wrapper, router, useData, app } = singleLoaderOneRoute(
+      const { router, useData, app } = singleLoaderOneRoute(
         loaderFactory({
           fn: async () => {
             const a = await l1()
diff --git a/tests/utils.ts b/tests/utils.ts
index fe584634b..f9551e368 100644
--- a/tests/utils.ts
+++ b/tests/utils.ts
@@ -1,9 +1,4 @@
 import { vi } from 'vitest'
-import type { NavigationResult } from '../src/data-loaders/navigation-guard'
-import {
-  type DefineDataLoaderOptions,
-  defineBasicLoader,
-} from '../src/data-loaders/defineLoader'
 
 export const delay = (ms: number) =>
   new Promise((resolve) => setTimeout(resolve, ms))
diff --git a/tests/vitest-mock-warn.ts b/tests/vitest-mock-warn.ts
index d70bdec1d..c5314ef00 100644
--- a/tests/vitest-mock-warn.ts
+++ b/tests/vitest-mock-warn.ts
@@ -28,7 +28,13 @@ export function mockWarn() {
 
     toHaveBeenWarnedLast(received: string | RegExp) {
       asserted.set(received.toString(), received)
-      const lastCall = warn.mock.calls[warn.mock.calls.length - 1][0]
+      if (warn.mock.calls.length === 0) {
+        return {
+          pass: false,
+          message: () => 'expected console.warn to have been called.',
+        }
+      }
+      const lastCall = warn.mock.calls.at(-1)?.[0]
       const passed =
         typeof received === 'string'
           ? lastCall.indexOf(received) > -1
@@ -91,7 +97,7 @@ export function mockWarn() {
     const nonAssertedWarnings = warn.mock.calls
       .map((args) => args[0])
       .filter((received) => {
-        return !assertedArray.some(([key, assertedMsg]) => {
+        return !assertedArray.some(([_key, assertedMsg]) => {
           return typeof assertedMsg === 'string'
             ? received.indexOf(assertedMsg) > -1
             : assertedMsg.test(received)
diff --git a/vitest.config.ts b/vitest.config.ts
index 787f4b5ac..625023ff8 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -25,7 +25,6 @@ export default defineConfig({
       enabled: true,
       checker: 'vue-tsc',
       // only: true,
-      ignoreSourceErrors: true,
       // by default it includes all specs too
       include: ['**/*.test-d.ts'],
       // tsconfig: './tsconfig.typecheck.json',