@kitbag/router 0.11.3 → 0.12.0

package/dist/kitbag-router.d.ts

@@ -1,51 +1,69 @@
 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: {};
+    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 +113,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 +134,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 +146,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 +258,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, RouteParams<TPath, TQuery>> & 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, 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']>, 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, RouteParams<TPath, TQuery>> & 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, 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']>, 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 +300,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;
 };
@@ -634,6 +694,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 +787,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 +795,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 +843,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 +858,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 +867,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.
@@ -941,27 +970,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 = {
     /**
@@ -1060,17 +1069,18 @@ declare type RouterResolveOptions = {
     hash?: string;
 };
 
-declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = Readonly<{
-    id: TRoute['id'];
-    name: TRoute['name'];
-    matched: TRoute['matched'];
-    matches: TRoute['matches'];
+declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = {
+    readonly id: TRoute['id'];
+    readonly name: TRoute['name'];
+    readonly matched: TRoute['matched'];
+    readonly matches: TRoute['matches'];
+    readonly hash: TRoute['hash'];
+    readonly update: RouteUpdate<TRoute>;
+    params: TRoute['params'];
     state: TRoute['state'];
-    query: ResolvedRouteQuery;
-    hash: TRoute['hash'];
-    params: Writable<TRoute['params']>;
-    update: RouteUpdate<TRoute>;
-}>;
+    get query(): ResolvedRouteQuery;
+    set query(value: QuerySource);
+};
 
 /**
  * This type is the same as `RouterRoute<ResolvedRoute<TRoutes[number]>>` while remaining distributive
@@ -1079,89 +1089,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: Readonly<{
-            id: string;
-            name: string;
-            matched: CreateRouteOptions & WithHooks & (WithHost | WithoutHost) & (WithComponent | WithComponents | WithoutComponents) & (WithParent | WithoutParent) & (WithState | WithoutState) & {
-                id: string;
-                meta: Record<string, unknown>;
-            };
-            matches: (CreateRouteOptions & WithHooks & (WithHost | WithoutHost) & (WithComponent | WithComponents | WithoutComponents) & (WithParent | WithoutParent) & (WithState | WithoutState) & {
-                id: string;
-                meta: Record<string, unknown>;
-            })[];
-            state: {
-                [x: string]: any;
-                [x: number]: any;
-            };
-            query: ResolvedRouteQuery;
-            hash: string | undefined;
-            params: Writable<    {
-            [x: string]: any;
-            [x: number]: any;
-            }>;
-            update: {
-                (paramName: string, paramValue: unknown, options?: RouterPushOptions | undefined): Promise<void>;
-                (params: Partial<{
-                    [x: string]: any;
-                    [x: number]: any;
-                }>, options?: RouterPushOptions | undefined): Promise<void>;
-            };
-        }>;
-        component: Component;
-        rejection: {
-            type: "NotFound";
-            component: Component;
-        } | null;
-    }) => VNode<RendererNode, RendererElement, {
-        [key: string]: any;
-    }>) | undefined;
-}> & {
-    default?: ((props: {
-        route: Readonly<{
-            id: string;
-            name: string;
-            matched: CreateRouteOptions & WithHooks & (WithHost | WithoutHost) & (WithComponent | WithComponents | WithoutComponents) & (WithParent | WithoutParent) & (WithState | WithoutState) & {
-                id: string;
-                meta: Record<string, unknown>;
-            };
-            matches: (CreateRouteOptions & WithHooks & (WithHost | WithoutHost) & (WithComponent | WithComponents | WithoutComponents) & (WithParent | WithoutParent) & (WithState | WithoutState) & {
-                id: string;
-                meta: Record<string, unknown>;
-            })[];
-            state: {
-                [x: string]: any;
-                [x: number]: any;
-            };
-            query: ResolvedRouteQuery;
-            hash: string | undefined;
-            params: Writable<    {
-            [x: string]: any;
-            [x: number]: any;
-            }>;
-            update: {
-                (paramName: string, paramValue: unknown, options?: RouterPushOptions | undefined): Promise<void>;
-                (params: Partial<{
-                    [x: string]: any;
-                    [x: number]: any;
-                }>, options?: RouterPushOptions | undefined): Promise<void>;
-            };
-        }>;
-        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`.
@@ -1324,7 +1252,7 @@ declare type WithComponent<TComponent extends Component = Component, TParams ext
      * A Vue component, which can be either synchronous or asynchronous components.
      */
     component: TComponent;
-    props?: (params: TParams) => TComponent extends Component ? MaybePromise<ComponentProps<TComponent>> : {};
+    props?: (params: TParams, 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>> = {
@@ -1333,7 +1261,7 @@ declare type WithComponents<TComponents extends Record<string, Component> = Reco
      */
     components: TComponents;
     props?: {
-        [TKey in keyof TComponents]?: (params: TParams) => TComponents[TKey] extends Component ? MaybePromise<ComponentProps<TComponents[TKey]>> : {};
+        [TKey in keyof TComponents]?: (params: TParams, context: CallbackContext) => TComponents[TKey] extends Component ? MaybePromise<ComponentProps<TComponents[TKey]>> : {};
     };
 };
 
@@ -1391,10 +1319,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 { }
 
 
@@ -1404,4 +1328,3 @@ declare module 'vue' {
         RouterLink: typeof RouterLink;
     }
 }
-