diff --git a/src/data-loaders/createDataLoader.ts b/src/data-loaders/createDataLoader.ts
index 4d00f43f8..3b5ada553 100644
--- a/src/data-loaders/createDataLoader.ts
+++ b/src/data-loaders/createDataLoader.ts
@@ -8,14 +8,11 @@ import { type _Awaitable } from '../utils'
 /**
  * Base type for a data loader entry. Each Data Loader has its own entry in the `loaderEntries` (accessible via `[LOADER_ENTRIES_KEY]`) map.
  */
-export interface DataLoaderEntryBase<
-  isLazy extends boolean = boolean,
-  Data = unknown,
-> {
+export interface DataLoaderEntryBase<Data = unknown> {
   /**
    * Data stored in the entry.
    */
-  data: ShallowRef<_DataMaybeLazy<Data, isLazy>>
+  data: ShallowRef<Data | undefined>
 
   /**
    * Error if there was an error.
@@ -32,7 +29,7 @@ export interface DataLoaderEntryBase<
    */
   isLoading: ShallowRef<boolean>
 
-  options: DefineDataLoaderOptionsBase<isLazy>
+  options: DefineDataLoaderOptionsBase
 
   /**
    * Called by the navigation guard when the navigation is duplicated. Should be used to reset pendingTo and pendingLoad and any other property that should be reset.
@@ -86,7 +83,7 @@ export interface CreateDataLoaderOptions<
   after: <Data = unknown>(data: Data, context: Context) => unknown
 }
 
-export interface DefineDataLoaderOptionsBase<isLazy extends boolean> {
+export interface DefineDataLoaderOptionsBase {
   /**
    * Whether the data should be lazy loaded without blocking the client side navigation or not. When set to true, the loader will no longer block the navigation and the returned composable can be called even
    * without having the data ready.
@@ -94,7 +91,7 @@ export interface DefineDataLoaderOptionsBase<isLazy extends boolean> {
    * @defaultValue `false`
    */
   lazy?:
-    | isLazy
+    | boolean
     | ((
         to: RouteLocationNormalizedLoaded,
         from?: RouteLocationNormalizedLoaded
@@ -143,7 +140,6 @@ export const toLazyValue = (
  * - `after-load`: the data is committed after all non-lazy loaders have finished loading.
  */
 export type DefineDataLoaderCommit = 'immediate' | 'after-load'
-// TODO: is after-load fine or is it better to have an after-navigation instead
 
 export interface DataLoaderContextBase {
   /**
@@ -153,11 +149,11 @@ export interface DataLoaderContextBase {
 }
 
 export interface DefineDataLoader<Context extends DataLoaderContextBase> {
-  <isLazy extends boolean, Data>(
+  <Data>(
     fn: DefineLoaderFn<Data, Context>,
-    options?: DefineDataLoaderOptionsBase<isLazy>
+    options?: DefineDataLoaderOptionsBase
     // TODO: or a generic that allows a more complex UseDataLoader
-  ): UseDataLoader<isLazy, Data>
+  ): UseDataLoader<Data>
 }
 
 // TODO: should be in each data loader. Refactor the base type to accept the needed generics
@@ -166,10 +162,7 @@ export interface DefineDataLoader<Context extends DataLoaderContextBase> {
  * Data Loader composable returned by `defineLoader()`.
  * @see {@link DefineDataLoader}
  */
-export interface UseDataLoader<
-  isLazy extends boolean = boolean,
-  Data = unknown,
-> {
+export interface UseDataLoader<Data = unknown> {
   [IS_USE_DATA_LOADER_KEY]: true
 
   /**
@@ -198,24 +191,21 @@ export interface UseDataLoader<
     // `return new NavigationResult()` in the loader
     Exclude<Data, NavigationResult>,
     // or use it as a composable
-    UseDataLoaderResult<isLazy, Exclude<Data, NavigationResult>>
+    UseDataLoaderResult<Exclude<Data, NavigationResult>>
   >
 
   /**
    * Internals of the data loader.
    * @internal
    */
-  _: UseDataLoaderInternals<isLazy, Exclude<Data, NavigationResult>>
+  _: UseDataLoaderInternals<Exclude<Data, NavigationResult>>
 }
 
 /**
  * Internal properties of a data loader composable. Used by the internal implementation of `defineLoader()`. **Should
  * not be used in application code.**
  */
-export interface UseDataLoaderInternals<
-  isLazy extends boolean = boolean,
-  Data = unknown,
-> {
+export interface UseDataLoaderInternals<Data = unknown> {
   /**
    * Loads the data from the cache if possible, otherwise loads it from the loader and awaits it.
    *
@@ -234,7 +224,7 @@ export interface UseDataLoaderInternals<
   /**
    * Resolved options for the loader.
    */
-  options: DefineDataLoaderOptionsBase<isLazy>
+  options: DefineDataLoaderOptionsBase
 
   /**
    * Gets the entry associated with the router instance. Assumes the data loader has been loaded and that the entry
@@ -242,28 +232,17 @@ export interface UseDataLoaderInternals<
    *
    * @param router - router instance
    */
-  getEntry(router: Router): DataLoaderEntryBase<isLazy, Data>
+  getEntry(router: Router): DataLoaderEntryBase<Data>
 }
 
-/**
- * Generates the type for a `Ref` of a data loader based on the value of `lazy`.
- * @internal
- */
-export type _DataMaybeLazy<Data, isLazy extends boolean = boolean> =
-  // no lazy provided, default value is false
-  boolean extends isLazy ? Data : true extends isLazy ? Data | undefined : Data
-
 /**
  * Return value of a loader composable defined with `defineLoader()`.
  */
-export interface UseDataLoaderResult<
-  isLazy extends boolean = boolean,
-  Data = unknown,
-> {
+export interface UseDataLoaderResult<Data = unknown> {
   /**
    * Data returned by the loader. If the data loader is lazy, it will be undefined until the first load.
    */
-  data: ShallowRef<_DataMaybeLazy<Data, isLazy>>
+  data: ShallowRef<Data | undefined>
 
   /**
    * Whether there is an ongoing request.
diff --git a/src/data-loaders/defineColadaLoader.ts b/src/data-loaders/defineColadaLoader.ts
index 616dc99ff..8e28200c4 100644
--- a/src/data-loaders/defineColadaLoader.ts
+++ b/src/data-loaders/defineColadaLoader.ts
@@ -13,7 +13,6 @@ import type {
   DefineLoaderFn,
   UseDataLoader,
   UseDataLoaderResult,
-  _DataMaybeLazy,
   _DefineLoaderEntryMap,
 } from 'unplugin-vue-router/runtime'
 import {
@@ -60,40 +59,32 @@ import { toLazyValue } from './createDataLoader'
  * @param loader - function that returns a promise with the data
  * @param options - options to configure the data loader
  */
-export function defineColadaLoader<
-  Name extends keyof RouteMap,
-  Data,
-  isLazy extends boolean,
->(
+export function defineColadaLoader<Name extends keyof RouteMap, Data>(
   name: Name,
-  options: DefineDataColadaLoaderOptions<isLazy, Name, Data>
-): UseDataLoaderColada<isLazy, Data>
-export function defineColadaLoader<Data, isLazy extends boolean>(
-  options: DefineDataColadaLoaderOptions<isLazy, keyof RouteMap, Data>
-): UseDataLoaderColada<isLazy, Data>
+  options: DefineDataColadaLoaderOptions<Name, Data>
+): UseDataLoaderColada<Data>
+export function defineColadaLoader<Data>(
+  options: DefineDataColadaLoaderOptions<keyof RouteMap, Data>
+): UseDataLoaderColada<Data>
 
-export function defineColadaLoader<Data, isLazy extends boolean>(
+export function defineColadaLoader<Data>(
   nameOrOptions:
     | keyof RouteMap
-    | DefineDataColadaLoaderOptions<isLazy, keyof RouteMap, Data>,
-  _options?: DefineDataColadaLoaderOptions<isLazy, keyof RouteMap, Data>
-): UseDataLoaderColada<isLazy, Data> {
+    | DefineDataColadaLoaderOptions<keyof RouteMap, Data>,
+  _options?: DefineDataColadaLoaderOptions<keyof RouteMap, Data>
+): UseDataLoaderColada<Data> {
   // TODO: make it DEV only and remove the first argument in production mode
   // resolve option overrides
   _options =
     _options ||
-    (nameOrOptions as DefineDataColadaLoaderOptions<
-      isLazy,
-      keyof RouteMap,
-      Data
-    >)
+    (nameOrOptions as DefineDataColadaLoaderOptions<keyof RouteMap, Data>)
   const loader = _options.query
 
   const options = {
     ...DEFAULT_DEFINE_LOADER_OPTIONS,
     ..._options,
     commit: _options?.commit || 'after-load',
-  } as DefineDataColadaLoaderOptions<isLazy, keyof RouteMap, Data>
+  } as DefineDataColadaLoaderOptions<keyof RouteMap, Data>
 
   let isInitial = true
 
@@ -104,10 +95,8 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
     parent?: DataLoaderEntryBase,
     reload?: boolean
   ): Promise<void> {
-    const entries = router[
-      LOADER_ENTRIES_KEY
-    ]! as unknown as _DefineLoaderEntryMap<
-      DataLoaderColadaEntry<boolean, unknown>
+    const entries = router[LOADER_ENTRIES_KEY]! as _DefineLoaderEntryMap<
+      DataLoaderColadaEntry<unknown>
     >
     const isSSR = router[IS_SSR_KEY]
     const key = serializeQueryKey(options.key, to)
@@ -115,7 +104,7 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
       const route = shallowRef<RouteLocationNormalizedLoaded>(to)
       entries.set(loader, {
         // force the type to match
-        data: shallowRef<_DataMaybeLazy<Data, isLazy>>(),
+        data: shallowRef<Data | undefined>(),
         isLoading: shallowRef(false),
         error: shallowRef<any>(),
         to,
@@ -308,7 +297,7 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
   }
 
   function commit(
-    this: DataLoaderColadaEntry<isLazy, Data>,
+    this: DataLoaderColadaEntry<Data>,
     to: RouteLocationNormalizedLoaded
   ) {
     const key = serializeQueryKey(options.key, to)
@@ -358,7 +347,7 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
 
   // @ts-expect-error: requires the internals and symbol that are added later
   const useDataLoader: // for ts
-  UseDataLoaderColada<isLazy, Data> = () => {
+  UseDataLoaderColada<Data> = () => {
     // work with nested data loaders
     const currentEntry = getCurrentContext()
     const [parentEntry, _router, _route] = currentEntry
@@ -368,10 +357,8 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
 
     const entries = router[
       LOADER_ENTRIES_KEY
-    ]! as unknown as _DefineLoaderEntryMap<
-      DataLoaderColadaEntry<boolean, unknown>
-    >
-    let entry = entries.get(loader)
+    ]! as unknown as _DefineLoaderEntryMap<DataLoaderColadaEntry<unknown>>
+    let entry = entries.get(loader) as DataLoaderColadaEntry<Data> | undefined
 
     if (
       // if the entry doesn't exist, create it with load and ensure it's loading
@@ -388,7 +375,7 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
       )
     }
 
-    entry = entries.get(loader)!
+    entry = entries.get(loader)! as DataLoaderColadaEntry<Data>
 
     // add ourselves to the parent entry children
     if (parentEntry) {
@@ -450,7 +437,7 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
       asyncStatus: ext!.asyncStatus,
       state: ext!.state,
       isPending: ext!.isPending,
-    } satisfies UseDataLoaderColadaResult<boolean, unknown>
+    } satisfies UseDataLoaderColadaResult<Data>
 
     // load ensures there is a pending load
     const promise = entry
@@ -489,11 +476,10 @@ export function defineColadaLoader<Data, isLazy extends boolean>(
 export const joinKeys = (keys: string[]): string => keys.join('|')
 
 export interface DefineDataColadaLoaderOptions<
-  isLazy extends boolean,
   Name extends keyof RouteMap,
   Data,
-> extends DefineDataLoaderOptionsBase<isLazy>,
-    Omit<UseQueryOptions<unknown>, 'query' | 'key'> {
+> extends DefineDataLoaderOptionsBase,
+    Omit<UseQueryOptions<Data>, 'query' | 'key'> {
   /**
    * Key associated with the data and passed to pinia colada
    * @param to - Route to load the data
@@ -517,8 +503,8 @@ export interface DefineDataColadaLoaderOptions<
  */
 export interface DataColadaLoaderContext extends DataLoaderContextBase {}
 
-export interface UseDataLoaderColadaResult<isLazy extends boolean, Data>
-  extends UseDataLoaderResult<isLazy, Data>,
+export interface UseDataLoaderColadaResult<Data>
+  extends UseDataLoaderResult<Data>,
     Pick<
       UseQueryReturn<Data, any>,
       'isPending' | 'refetch' | 'refresh' | 'status' | 'asyncStatus' | 'state'
@@ -527,8 +513,7 @@ export interface UseDataLoaderColadaResult<isLazy extends boolean, Data>
 /**
  * Data Loader composable returned by `defineColadaLoader()`.
  */
-export interface UseDataLoaderColada<isLazy extends boolean, Data>
-  extends UseDataLoader<isLazy, Data> {
+export interface UseDataLoaderColada<Data> extends UseDataLoader<Data> {
   /**
    * Data Loader composable returned by `defineColadaLoader()`.
    *
@@ -555,12 +540,11 @@ export interface UseDataLoaderColada<isLazy extends boolean, Data>
     // `return new NavigationResult()` in the loader
     Exclude<Data, NavigationResult>,
     // or use it as a composable
-    UseDataLoaderColadaResult<isLazy, Exclude<Data, NavigationResult>>
+    UseDataLoaderColadaResult<Exclude<Data, NavigationResult>>
   >
 }
 
-export interface DataLoaderColadaEntry<isLazy extends boolean, Data>
-  extends DataLoaderEntryBase<isLazy, Data> {
+export interface DataLoaderColadaEntry<Data> extends DataLoaderEntryBase<Data> {
   /**
    * Reactive route passed to pinia colada so it automatically refetch
    */
@@ -601,7 +585,7 @@ const DEFAULT_DEFINE_LOADER_OPTIONS = {
   server: true,
   commit: 'after-load',
 } satisfies Omit<
-  DefineDataColadaLoaderOptions<boolean, keyof RouteMap, unknown>,
+  DefineDataColadaLoaderOptions<keyof RouteMap, unknown>,
   'key' | 'query'
 >
 
@@ -622,7 +606,7 @@ const toValueWithParameters = <T, Arg>(
  * @param to - route to use
  */
 function serializeQueryKey(
-  keyOption: DefineDataColadaLoaderOptions<boolean, string, unknown>['key'],
+  keyOption: DefineDataColadaLoaderOptions<string, unknown>['key'],
   to: RouteLocationNormalizedLoaded
 ): string[] {
   const key = toValueWithParameters(keyOption, to)
diff --git a/src/data-loaders/defineLoader.spec.ts b/src/data-loaders/defineLoader.spec.ts
index 4999a10de..c632ca19a 100644
--- a/src/data-loaders/defineLoader.spec.ts
+++ b/src/data-loaders/defineLoader.spec.ts
@@ -33,7 +33,7 @@ import { RouteLocationNormalizedLoaded } from 'vue-router'
 
 function mockedLoader<T = string | NavigationResult>(
   // boolean is easier to handle for router mock
-  options?: DefineDataLoaderOptions<boolean>
+  options?: DefineDataLoaderOptions
 ) {
   const [spy, resolve, reject] = mockPromise<T, unknown>(
     // not correct as T could be something else
diff --git a/src/data-loaders/defineLoader.ts b/src/data-loaders/defineLoader.ts
index 0e9ed546d..6571de4e3 100644
--- a/src/data-loaders/defineLoader.ts
+++ b/src/data-loaders/defineLoader.ts
@@ -12,7 +12,6 @@ import type {
   DefineLoaderFn,
   UseDataLoader,
   UseDataLoaderResult,
-  _DataMaybeLazy,
 } from 'unplugin-vue-router/runtime'
 import {
   ABORT_CONTROLLER_KEY,
@@ -42,35 +41,31 @@ import { toLazyValue } from './createDataLoader'
  * @param loader - function that returns a promise with the data
  * @param options - options to configure the data loader
  */
-export function defineBasicLoader<
-  Name extends keyof RouteMap,
-  Data,
-  isLazy extends boolean,
->(
+export function defineBasicLoader<Name extends keyof RouteMap, Data>(
   name: Name,
   loader: DefineLoaderFn<
     Data,
     DataLoaderContext,
     RouteLocationNormalizedLoaded<Name>
   >,
-  options?: DefineDataLoaderOptions<isLazy>
-): UseDataLoaderBasic<isLazy, Data>
-export function defineBasicLoader<Data, isLazy extends boolean>(
+  options?: DefineDataLoaderOptions
+): UseDataLoaderBasic<Data>
+export function defineBasicLoader<Data>(
   loader: DefineLoaderFn<
     Data,
     DataLoaderContext,
     RouteLocationNormalizedLoaded
   >,
-  options?: DefineDataLoaderOptions<isLazy>
-): UseDataLoaderBasic<isLazy, Data>
+  options?: DefineDataLoaderOptions
+): UseDataLoaderBasic<Data>
 
-export function defineBasicLoader<Data, isLazy extends boolean>(
+export function defineBasicLoader<Data>(
   nameOrLoader: keyof RouteMap | DefineLoaderFn<Data, DataLoaderContext>,
   _loaderOrOptions?:
-    | DefineDataLoaderOptions<isLazy>
+    | DefineDataLoaderOptions
     | DefineLoaderFn<Data, DataLoaderContext>,
-  opts?: DefineDataLoaderOptions<isLazy>
-): UseDataLoaderBasic<isLazy, Data> {
+  opts?: DefineDataLoaderOptions
+): UseDataLoaderBasic<Data> {
   // TODO: make it DEV only and remove the first argument in production mode
   // resolve option overrides
   const loader =
@@ -78,13 +73,13 @@ export function defineBasicLoader<Data, isLazy extends boolean>(
       ? nameOrLoader
       : (_loaderOrOptions! as DefineLoaderFn<Data, DataLoaderContext>)
   opts = typeof _loaderOrOptions === 'object' ? _loaderOrOptions : opts
-  // {} as DefineDataLoaderOptions<isLazy>,
+
   const options = {
     ...DEFAULT_DEFINE_LOADER_OPTIONS,
     ...opts,
     // avoid opts overriding with `undefined`
     commit: opts?.commit || DEFAULT_DEFINE_LOADER_OPTIONS.commit,
-  } as DefineDataLoaderOptions<isLazy>
+  } as DefineDataLoaderOptions
 
   function load(
     to: RouteLocationNormalizedLoaded,
@@ -99,7 +94,7 @@ export function defineBasicLoader<Data, isLazy extends boolean>(
     if (!entries.has(loader)) {
       entries.set(loader, {
         // force the type to match
-        data: shallowRef<_DataMaybeLazy<Data, isLazy>>(),
+        data: shallowRef<Data | undefined>(),
         isLoading: shallowRef(false),
         error: shallowRef<any>(),
         to,
@@ -277,9 +272,9 @@ export function defineBasicLoader<Data, isLazy extends boolean>(
     }
   }
 
-  // @ts-expect-error: requires the internals and symbol that are added later
-  const useDataLoader: // for ts
-  UseDataLoaderBasic<isLazy, Data> = () => {
+  // @ts-expect-error: return type has the generics
+  const useDataLoader // for ts
+  : UseDataLoaderBasic<Data> = () => {
     // work with nested data loaders
     const currentContext = getCurrentContext()
     const [parentEntry, _router, _route] = currentContext
@@ -352,7 +347,7 @@ export function defineBasicLoader<Data, isLazy extends boolean>(
       })
       // we only want the error if we are nesting the loader
       // otherwise this will end up in "Unhandled promise rejection"
-      .catch((e) => (parentEntry ? Promise.reject(e) : null))
+      .catch((e: unknown) => (parentEntry ? Promise.reject(e) : null))
 
     setCurrentContext(currentContext)
     return Object.assign(promise, useDataLoaderResult)
@@ -374,8 +369,7 @@ export function defineBasicLoader<Data, isLazy extends boolean>(
   return useDataLoader
 }
 
-export interface DefineDataLoaderOptions<isLazy extends boolean>
-  extends DefineDataLoaderOptionsBase<isLazy> {
+export interface DefineDataLoaderOptions extends DefineDataLoaderOptionsBase {
   /**
    * Key to use for SSR state. This will be used to read the initial data from `initialData`'s object.
    */
@@ -388,7 +382,7 @@ const DEFAULT_DEFINE_LOADER_OPTIONS = {
   lazy: false as boolean,
   server: true,
   commit: 'after-load',
-} satisfies DefineDataLoaderOptions<boolean>
+} satisfies DefineDataLoaderOptions
 
 /**
  * Symbol used to store the data in the router so it can be retrieved after the initial navigation.
@@ -415,5 +409,4 @@ declare module 'vue-router' {
   }
 }
 
-export interface UseDataLoaderBasic<isLazy extends boolean, Data>
-  extends UseDataLoader<isLazy, Data> {}
+export interface UseDataLoaderBasic<Data> extends UseDataLoader<Data> {}
diff --git a/src/data-loaders/index.ts b/src/data-loaders/index.ts
index 5bbe06e32..3100635bf 100644
--- a/src/data-loaders/index.ts
+++ b/src/data-loaders/index.ts
@@ -6,7 +6,6 @@ export type {
   DataLoaderEntryBase,
   DefineDataLoaderOptionsBase,
   DefineLoaderFn,
-  _DataMaybeLazy,
 } from './createDataLoader'
 
 // new data fetching
diff --git a/src/data-loaders/meta-extensions.ts b/src/data-loaders/meta-extensions.ts
index 9d61a70be..5529127cc 100644
--- a/src/data-loaders/meta-extensions.ts
+++ b/src/data-loaders/meta-extensions.ts
@@ -16,10 +16,8 @@ import { type NavigationResult } from './navigation-guard'
  * @internal
  */
 export type _DefineLoaderEntryMap<
-  DataLoaderEntry extends DataLoaderEntryBase<
-    boolean,
-    unknown
-  > = DataLoaderEntryBase<boolean, unknown>,
+  DataLoaderEntry extends
+    DataLoaderEntryBase<unknown> = DataLoaderEntryBase<unknown>,
 > = WeakMap<
   // Depending on the `defineLoader()` they might use a different thing as key
   // e.g. an function for basic defineLoader, a doc instance for VueFire
diff --git a/src/data-loaders/navigation-guard.spec.ts b/src/data-loaders/navigation-guard.spec.ts
index ae4da4b47..eb4f1c682 100644
--- a/src/data-loaders/navigation-guard.spec.ts
+++ b/src/data-loaders/navigation-guard.spec.ts
@@ -30,7 +30,7 @@ import type { NavigationFailure } from 'vue-router'
 
 function mockedLoader<T = string | NavigationResult>(
   // boolean is easier to handle for router mock
-  options?: DefineDataLoaderOptions<boolean>
+  options?: DefineDataLoaderOptions
 ) {
   const [spy, resolve, reject] = mockPromise<T, unknown>(
     // not correct as T could be something else
diff --git a/tests/data-loaders/tester.ts b/tests/data-loaders/tester.ts
index af844693e..0ac7f1381 100644
--- a/tests/data-loaders/tester.ts
+++ b/tests/data-loaders/tester.ts
@@ -29,7 +29,7 @@ export function testDefineLoader<Context = void>(
         to: RouteLocationNormalizedLoaded,
         context: DataLoaderContextBase
       ) => Promise<unknown>
-    } & DefineDataLoaderOptionsBase<boolean> & { key?: string }
+    } & DefineDataLoaderOptionsBase & { key?: string }
   ) => UseDataLoader,
   {
     plugins,
@@ -45,7 +45,7 @@ export function testDefineLoader<Context = void>(
 
   function mockedLoader<T = string | NavigationResult>(
     // boolean is easier to handle for router mock
-    options?: DefineDataLoaderOptionsBase<boolean> & { key?: string }
+    options?: DefineDataLoaderOptionsBase & { key?: string }
   ) {
     const [spy, resolve, reject] = mockPromise<T, unknown>(
       // not correct as T could be something else