@kitbag/router 0.11.4 → 0.13.0

package/dist/kitbag-router.d.ts

@@ -1,51 +1,71 @@
 import { AsyncComponentLoader } from 'vue';
 import { Component } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
 import { ComputedRef } from 'vue';
 import { DefineComponent } from 'vue';
-import { ExtractPropTypes } from 'vue';
 import { FunctionalComponent } from 'vue';
 import { InjectionKey } from 'vue';
 import { MaybeRefOrGetter } from 'vue';
 import { Plugin as Plugin_2 } from 'vue';
-import { PropType } from 'vue';
 import { PublicProps } from 'vue';
 import { Ref } from 'vue';
-import { RendererElement } from 'vue';
-import { RendererNode } from 'vue';
+import { UnwrapRef } from 'vue';
 import { VNode } from 'vue';
 
-declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+declare const __VLS_component: DefineComponent<    {
+name?: string;
+}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
+name?: string;
+} & {}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}>;
 
-declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;
-
-declare type __VLS_Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
+declare const __VLS_component_2: DefineComponent<RouterLinkProps & RouterPushOptions, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RouterLinkProps & RouterPushOptions & {}>, {
+prefetch: PrefetchConfig;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}>;
 
-declare type __VLS_TypePropsToRuntimeProps<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: PropType<T[K]>;
-        required: true;
+declare function __VLS_template(): {
+    slots: Readonly<{
+        default?: (props: {
+            route: RouterRoute;
+            component: Component;
+            rejection: UnwrapRef<RouterRejection>;
+        }) => VNode;
+    }> & {
+        default?: (props: {
+            route: RouterRoute;
+            component: Component;
+            rejection: UnwrapRef<RouterRejection>;
+        }) => VNode;
     };
+    refs: {};
+    attrs: Partial<{}>;
 };
 
-declare type __VLS_TypePropsToRuntimeProps_2<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: PropType<__VLS_NonUndefinedable_2<T[K]>>;
-    } : {
-        type: PropType<T[K]>;
-        required: true;
+declare function __VLS_template_2(): {
+    slots: Readonly<{
+        default?: (props: {
+            resolved: string;
+            isMatch: boolean;
+            isExactMatch: boolean;
+            isExternal: boolean;
+        }) => unknown;
+    }> & {
+        default?: (props: {
+            resolved: string;
+            isMatch: boolean;
+            isExactMatch: boolean;
+            isExternal: boolean;
+        }) => unknown;
+    };
+    refs: {
+        element: HTMLAnchorElement;
     };
+    attrs: Partial<{}>;
 };
 
-declare type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
-        default: D[K];
-    }> : P[K];
-};
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;
 
 declare type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
@@ -95,7 +115,7 @@ export declare type AfterRouteHookLifecycle = 'onAfterRouteEnter' | 'onAfterRout
  * Type for responses from an after route hook, which may indicate different outcomes such as success, push, or reject.
  * @template TRoutes - The type of the routes configuration.
  */
-export declare type AfterRouteHookResponse<TRoutes extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<TRoutes> | RouteHookRejectResponse;
+export declare type AfterRouteHookResponse = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse;
 
 declare type AllPropertiesAreOptional<T> = Record<string, unknown> extends T ? true : IsEmptyObject<OnlyRequiredProperties<T>>;
 
@@ -116,7 +136,7 @@ export declare type BeforeRouteHook = (to: ResolvedRoute, context: BeforeRouteHo
  * as well as aborting current route change.
  */
 declare type BeforeRouteHookContext = RouteHookContext & {
-    abort: RouteHookAbort;
+    abort: CallbackContextAbort;
 };
 
 /**
@@ -128,12 +148,54 @@ export declare type BeforeRouteHookLifecycle = 'onBeforeRouteEnter' | 'onBeforeR
  * Type for responses from a before route hook, which may indicate different outcomes such as success, push, reject, or abort.
  * @template TRoutes - The type of the routes configuration.
  */
-export declare type BeforeRouteHookResponse<TRoutes extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<TRoutes> | RouteHookRejectResponse | RouteHookAbortResponse;
+export declare type BeforeRouteHookResponse = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse | CallbackAbortResponse;
 
 declare const builtInRejections: ['NotFound'];
 
 declare type BuiltInRejectionType = typeof builtInRejections[number];
 
+/**
+ * Defines the structure of an aborted callback response.
+ */
+declare type CallbackAbortResponse = {
+    status: 'ABORT';
+};
+
+declare type CallbackContext = {
+    reject: RegisteredRouterReject;
+    push: RegisteredRouterPush;
+    replace: RegisteredRouterReplace;
+    abort: CallbackContextAbort;
+};
+
+/**
+ * A function that can be called to abort a routing operation.
+ */
+declare type CallbackContextAbort = () => void;
+
+/**
+ * Defines the structure of a callback response that results in a push to a new route.
+ */
+declare type CallbackPushResponse = {
+    status: 'PUSH';
+    to: Parameters<RegisteredRouterPush>;
+};
+
+/**
+ * Defines the structure of a callback response that results in the rejection of a route transition.
+ */
+declare type CallbackRejectResponse = {
+    status: 'REJECT';
+    type: RegisteredRejectionType;
+};
+
+/**
+ * Defines the structure of a successful callback response.
+ */
+declare type CallbackSuccessResponse = {
+    status: 'SUCCESS';
+};
+
 declare type CombineHash<TParent extends Hash, TChild extends Hash> = ToHash<TParent> extends {
     value: infer TParentHash extends string;
 } ? ToHash<TChild> extends {
@@ -198,17 +260,17 @@ export declare function createParam<TParam extends Param>(param: TParam): ParamG
 
 export declare function createParam<TParam extends Param>(param: TParam, defaultValue: ExtractParamType<TParam>): ParamWithDefault<TParam>;
 
-export declare function createRoute<const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithoutComponents & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, ToHash<THash>, TMeta, TState>;
+export declare function createRoute<const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithoutComponents & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, ToHash<THash>, TMeta, TState, TName>;
 
-export declare function createRoute<const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithoutComponents & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineHash<TParent['hash'], ToHash<THash>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
+export declare function createRoute<const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithoutComponents & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineHash<TParent['hash'], ToHash<THash>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>, TName | TParent['matches'][number]['name']>;
 
-export declare function createRoute<TComponent extends Component, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithComponent<TComponent, RouteParams<TPath, TQuery>> & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, ToHash<THash>, TMeta, TState>;
+export declare function createRoute<TComponent extends Component, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithComponent<TComponent, Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, ToHash<THash>, TMeta, TState, TName>> & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, ToHash<THash>, TMeta, TState, TName>;
 
-export declare function createRoute<TComponent extends Component, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithComponent<TComponent, RouteParams<TPath, TQuery, TParent>> & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineHash<TParent['hash'], ToHash<THash>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
+export declare function createRoute<TComponent extends Component, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithComponent<TComponent, Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineHash<TParent['hash'], ToHash<THash>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>, TName | TParent['matches'][number]['name']>> & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineHash<TParent['hash'], ToHash<THash>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>, TName | TParent['matches'][number]['name']>;
 
-export declare function createRoute<TComponents extends Record<string, Component>, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithComponents<TComponents, RouteParams<TPath, TQuery>> & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, ToHash<THash>, TMeta, TState>;
+export declare function createRoute<TComponents extends Record<string, Component>, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithComponents<TComponents, Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, ToHash<THash>, TMeta, TState, TName>> & WithoutParent & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>, ToHash<THash>, TMeta, TState, TName>;
 
-export declare function createRoute<TComponents extends Record<string, Component>, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithComponents<TComponents, RouteParams<TPath, TQuery, TParent>> & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineHash<TParent['hash'], ToHash<THash>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>>;
+export declare function createRoute<TComponents extends Record<string, Component>, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const THash extends string | Hash | undefined = undefined, const TMeta extends RouteMeta = RouteMeta, const TState extends Record<string, Param> = Record<string, Param>>(options: CreateRouteOptions<TName, TPath, TQuery, THash, TMeta> & WithHooks & WithComponents<TComponents, Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineHash<TParent['hash'], ToHash<THash>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>, TName | TParent['matches'][number]['name']>> & WithParent<TParent> & (WithState<TState> | WithoutState)): Route<ToName<TName>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>, CombineHash<TParent['hash'], ToHash<THash>>, CombineMeta<TMeta, TParent['meta']>, CombineState<TState, TParent['state']>, TName | TParent['matches'][number]['name']>;
 
 export declare type CreateRouteOptions<TName extends string | undefined = string | undefined, TPath extends string | Path | undefined = string | Path | undefined, TQuery extends string | Query | undefined = string | Query | undefined, THash extends string | Hash | undefined = string | Hash | undefined, TMeta extends RouteMeta = RouteMeta> = {
     /**
@@ -240,7 +302,7 @@ export declare type CreateRouteOptions<TName extends string | undefined = string
 /**
  * The Route properties originally provided to `createRoute`. The only change is normalizing meta to always default to an empty object.
  */
-declare type CreateRouteOptionsMatched = CreateRouteOptions & WithHooks & (WithHost | WithoutHost) & (WithComponent | WithComponents | WithoutComponents) & (WithParent | WithoutParent) & (WithState | WithoutState) & {
+declare type CreateRouteOptionsMatched<TName extends string | undefined = string | undefined> = CreateRouteOptions<TName> & WithHooks & (WithHost | WithoutHost) & (WithComponent | WithComponents | WithoutComponents) & (WithParent | WithoutParent) & (WithState | WithoutState) & {
     id: string;
     meta: RouteMeta;
 };
@@ -505,10 +567,6 @@ declare const paramStart = "[";
 
 export declare type ParamWithDefault<TParam extends Param = Param> = Required<ParamGetSet<ExtractParamType<TParam>>>;
 
-declare type ParentPath<TParent extends Route | undefined> = TParent extends Route ? TParent['path'] : Path<'', {}>;
-
-declare type ParentQuery<TParent extends Route | undefined> = TParent extends Route ? TParent['query'] : Query<'', {}>;
-
 declare type Path<TPath extends string = string, TParams extends PathParamsWithParamNameExtracted<TPath> = Record<string, Param | undefined>> = {
     value: TPath;
     params: string extends TPath ? Record<string, Param> : Identity<ExtractParamsFromPathString<TPath, TParams>>;
@@ -544,21 +602,28 @@ declare type PathParamsWithParamNameExtracted<TPath extends string> = {
 /**
  * Determines what assets are prefetched. A boolean enables or disables all prefetching.
  */
-declare type PrefetchConfig = boolean | PrefetchConfigOptions;
+declare type PrefetchConfig = boolean | PrefetchStrategy | PrefetchConfigOptions;
 
 declare type PrefetchConfigOptions = {
     /**
      * When true any component that is wrapped in vue's defineAsyncComponent will be prefetched
-     * @default true
+     * @default 'eager'
      */
-    components?: boolean;
+    components?: boolean | PrefetchStrategy;
     /**
      * When true any props for routes will be prefetched
      * @default false
      */
-    props?: boolean;
+    props?: boolean | PrefetchStrategy;
 };
 
+/**
+ * Determines when assets are prefetched.
+ * eager: Fetched immediately
+ * lazy: Fetched when visible
+ */
+declare type PrefetchStrategy = 'eager' | 'lazy';
+
 declare type Query<TQuery extends string = string, TQueryParams extends QueryParamsWithParamNameExtracted<TQuery> = Record<string, Param | undefined>> = {
     value: TQuery;
     params: string extends TQuery ? Record<string, Param> : Identity<ExtractQueryParamsFromQueryString<TQuery, TQueryParams>>;
@@ -634,6 +699,11 @@ export declare type RegisteredRouter = Register extends {
  */
 export declare type RegisteredRouterPush = RouterPush<RegisteredRoutes>;
 
+/**
+ * Type for Router Reject method. Triggers rejections registered within {@link Register}
+ */
+export declare type RegisteredRouterReject = (type: RegisteredRejectionType) => void;
+
 /**
  * Represents the type for router `replace`, with types for routes registered within {@link Register}
  */
@@ -722,7 +792,7 @@ declare type ResolvedRouteQuery = {
  * @template TPath - The type or structure of the route's path.
  * @template TQuery - The type or structure of the query parameters associated with the route.
  */
-export declare type Route<TName extends string = string, THost extends Host = Host, TPath extends Path = Path, TQuery extends Query = Query, THash extends Hash = Hash, TMeta extends RouteMeta = RouteMeta, TState extends Record<string, Param> = Record<string, Param>> = {
+export declare type Route<TName extends string = string, THost extends Host = Host, TPath extends Path = Path, TQuery extends Query = Query, THash extends Hash = Hash, TMeta extends RouteMeta = RouteMeta, TState extends Record<string, Param> = Record<string, Param>, TMatchNames extends string | undefined = string | undefined> = {
     /**
      * Unique identifier for the route, generated by router.
      */
@@ -730,12 +800,12 @@ export declare type Route<TName extends string = string, THost extends Host = Ho
     /**
      * The specific route properties that were matched in the current route.
      */
-    matched: CreateRouteOptionsMatched;
+    matched: CreateRouteOptionsMatched<TName>;
     /**
      * The specific route properties that were matched in the current route, including any ancestors.
      * Order of routes will be from greatest ancestor to narrowest matched.
      */
-    matches: CreateRouteOptionsMatched[];
+    matches: CreateRouteOptionsMatched<TMatchNames>[];
     /**
      * Identifier for the route as defined by user. Name must be unique among named routes. Name is used for routing and for matching.
      */
@@ -778,18 +848,6 @@ declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesName<TRout
  */
 export declare type RouteHook = BeforeRouteHook | AfterRouteHook;
 
-/**
- * A function that can be called to abort a routing operation.
- */
-export declare type RouteHookAbort = () => void;
-
-/**
- * Defines the structure of an aborted route hook response.
- */
-declare type RouteHookAbortResponse = {
-    status: 'ABORT';
-};
-
 /**
  * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
  */
@@ -805,23 +863,6 @@ declare type RouteHookContext = {
  */
 export declare type RouteHookLifecycle = BeforeRouteHookLifecycle | AfterRouteHookLifecycle;
 
-/**
- * Defines the structure of a route hook response that results in a push to a new route.
- * @template T - The type of the routes configuration.
- */
-declare type RouteHookPushResponse<T extends Routes> = {
-    status: 'PUSH';
-    to: Parameters<RouterPush<T>>;
-};
-
-/**
- * Defines the structure of a route hook response that results in the rejection of a route transition.
- */
-declare type RouteHookRejectResponse = {
-    status: 'REJECT';
-    type: RegisteredRejectionType;
-};
-
 /**
  * A function to remove a previously registered route hook.
  */
@@ -831,14 +872,7 @@ export declare type RouteHookRemove = () => void;
  * Union type for all possible route hook responses, covering both before and after scenarios.
  * @template TRoutes - The type of the routes configuration.
  */
-export declare type RouteHookResponse<TRoutes extends Routes> = BeforeRouteHookResponse<TRoutes> | AfterRouteHookResponse<TRoutes>;
-
-/**
- * Defines the structure of a successful route hook response.
- */
-declare type RouteHookSuccessResponse = {
-    status: 'SUCCESS';
-};
+export declare type RouteHookResponse = BeforeRouteHookResponse | AfterRouteHookResponse;
 
 /**
  * Represents additional metadata associated with a route, customizable via declaration merging.
@@ -847,8 +881,6 @@ export declare type RouteMeta = Register extends {
     routeMeta: infer RouteMeta extends Record<string, unknown>;
 } ? RouteMeta : Record<string, unknown>;
 
-declare type RouteParams<TPath extends string | Path | undefined, TQuery extends string | Query | undefined, TParent extends Route | undefined = undefined> = ExtractParamTypes<Identity<CombinePath<ParentPath<TParent>, ToPath<TPath>>['params'] & CombineQuery<ParentQuery<TParent>, ToQuery<TQuery>>['params']>>;
-
 declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypesWithoutLosingOptional<RouteGetByKey<TRoutes, TKey>>;
 
 export declare type Router<TRoutes extends Routes = any, __TOptions extends RouterOptions = any> = Plugin_2 & {
@@ -941,27 +973,7 @@ declare type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
 
 export declare const routerInjectionKey: InjectionKey<RegisteredRouter>;
 
-export declare const RouterLink: __VLS_WithTemplateSlots_2<DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps_2<RouterLinkProps & RouterPushOptions>, {
-prefetch: undefined;
-}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps_2<RouterLinkProps & RouterPushOptions>, {
-prefetch: undefined;
-}>>>, {
-prefetch: PrefetchConfig;
-}, {}>, Readonly<{
-    default?: ((props: {
-        resolved: string;
-        isMatch: boolean;
-        isExactMatch: boolean;
-        isExternal: boolean;
-    }) => unknown) | undefined;
-}> & {
-    default?: ((props: {
-        resolved: string;
-        isMatch: boolean;
-        isExactMatch: boolean;
-        isExternal: boolean;
-    }) => unknown) | undefined;
-}>;
+export declare const RouterLink: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;
 
 declare type RouterLinkProps = {
     /**
@@ -1065,10 +1077,10 @@ declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
     readonly name: TRoute['name'];
     readonly matched: TRoute['matched'];
     readonly matches: TRoute['matches'];
-    readonly state: TRoute['state'];
     readonly hash: TRoute['hash'];
-    readonly params: Writable<TRoute['params']>;
     readonly update: RouteUpdate<TRoute>;
+    params: TRoute['params'];
+    state: TRoute['state'];
     get query(): ResolvedRouteQuery;
     set query(value: QuerySource);
 };
@@ -1080,33 +1092,7 @@ export declare type RouterRoutes<TRoutes extends Routes> = {
     [K in keyof TRoutes]: RouterRoute<ResolvedRoute<TRoutes[K]>>;
 }[number];
 
-export declare const RouterView: __VLS_WithTemplateSlots<DefineComponent<__VLS_TypePropsToRuntimeProps<{
-name?: string | undefined;
-}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
-name?: string | undefined;
-}>>>, {}, {}>, Readonly<{
-    default?: ((props: {
-        route: RouterRoute;
-        component: Component;
-        rejection: {
-            type: "NotFound";
-            component: Component;
-        } | null;
-    }) => VNode<RendererNode, RendererElement, {
-        [key: string]: any;
-    }>) | undefined;
-}> & {
-    default?: ((props: {
-        route: RouterRoute;
-        component: Component;
-        rejection: {
-            type: "NotFound";
-            component: Component;
-        } | null;
-    }) => VNode<RendererNode, RendererElement, {
-        [key: string]: any;
-    }>) | undefined;
-}>;
+export declare const RouterView: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 
 /**
  * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
@@ -1155,6 +1141,10 @@ export declare type UrlParts = {
 };
 
 export declare type UseLink = {
+    /**
+     * A template ref to bind to the dom for automatic prefetching
+     */
+    element: Ref<HTMLElement | undefined>;
     /**
      * ResolvedRoute if matched. Same value as `router.find`
      */
@@ -1264,21 +1254,21 @@ export declare class UseRouteInvalidError extends Error {
  */
 export declare function useRouter(): RegisteredRouter;
 
-declare type WithComponent<TComponent extends Component = Component, TParams extends Record<string, unknown> = Record<string, unknown>> = {
+declare type WithComponent<TComponent extends Component = Component, TRoute extends Route = Route> = {
     /**
      * A Vue component, which can be either synchronous or asynchronous components.
      */
     component: TComponent;
-    props?: (params: TParams) => TComponent extends Component ? MaybePromise<ComponentProps<TComponent>> : {};
+    props?: (route: ResolvedRoute<TRoute>, context: CallbackContext) => TComponent extends Component ? MaybePromise<ComponentProps<TComponent>> : {};
 };
 
-declare type WithComponents<TComponents extends Record<string, Component> = Record<string, Component>, TParams extends Record<string, unknown> = Record<string, unknown>> = {
+declare type WithComponents<TComponents extends Record<string, Component> = Record<string, Component>, TRoute extends Route = Route> = {
     /**
      * Multiple components for named views, which can be either synchronous or asynchronous components.
      */
     components: TComponents;
     props?: {
-        [TKey in keyof TComponents]?: (params: TParams) => TComponents[TKey] extends Component ? MaybePromise<ComponentProps<TComponents[TKey]>> : {};
+        [TKey in keyof TComponents]?: (route: ResolvedRoute<TRoute>, context: CallbackContext) => TComponents[TKey] extends Component ? MaybePromise<ComponentProps<TComponents[TKey]>> : {};
     };
 };
 
@@ -1336,10 +1326,6 @@ declare type WithState<TState extends Record<string, Param> = Record<string, Par
     state: TState;
 };
 
-declare type Writable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-
 export { }
 
 
@@ -1349,4 +1335,3 @@ declare module 'vue' {
         RouterLink: typeof RouterLink;
     }
 }
-