@kitbag/router 0.3.0 → 0.4.1

package/dist/kitbag-router.d.ts

@@ -1,7 +1,6 @@
 import { AsyncComponentLoader } from 'vue';
 import { Component } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
-import { DeepReadonly } from 'vue';
 import { DefineComponent } from 'vue';
 import { ExtractPropTypes } from 'vue';
 import { FunctionalComponent } from 'vue';
@@ -56,6 +55,13 @@ declare type __VLS_WithTemplateSlots_2<T, S> = T & {
  */
 export declare type AddAfterRouteHook = (hook: AfterRouteHook) => RouteHookRemove;
 
+/**
+ * Adds a hook that is called after a route change. Returns a function to remove the hook.
+ * @param hook - {@link AfterRouteHook} The hook function to add.
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
+declare type AddAfterRouteHook_2 = (hook: AfterRouteHook_2) => RouteHookRemove_2
+
 /**
  * Adds a hook that is called before a route change. Returns a function to remove the hook.
  * @param hook - {@link BeforeRouteHook} The hook function to add.
@@ -63,6 +69,13 @@ export declare type AddAfterRouteHook = (hook: AfterRouteHook) => RouteHookRemov
  */
 export declare type AddBeforeRouteHook = (hook: BeforeRouteHook) => RouteHookRemove;
 
+/**
+ * Adds a hook that is called before a route change. Returns a function to remove the hook.
+ * @param hook - {@link BeforeRouteHook} The hook function to add.
+ * @returns {RouteHookRemove} A function that removes the added hook.
+ */
+declare type AddBeforeRouteHook_2 = (hook: BeforeRouteHook_2) => RouteHookRemove_2
+
 /**
  * Represents a function called after a route change has occurred.
  * @param to - {@link ResolvedRoute} The resolved route the router has navigated to.
@@ -71,11 +84,24 @@ export declare type AddBeforeRouteHook = (hook: BeforeRouteHook) => RouteHookRem
  */
 export declare type AfterRouteHook = (to: ResolvedRoute, context: AfterRouteHookContext) => MaybePromise<void>;
 
+/**
+ * Represents a function called after a route change has occurred.
+ * @param to - {@link ResolvedRoute} The resolved route the router has navigated to.
+ * @param context - {@link AfterRouteHookContext} The context providing functions and state for the routing operation.
+ * @returns Possibly a promise that resolves when the hook's logic has completed.
+ */
+declare type AfterRouteHook_2 = (to: ResolvedRoute_2, context: AfterRouteHookContext_2) => MaybePromise_2<void>
+
 /**
  * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
  */
 declare type AfterRouteHookContext = RouteHookContext;
 
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
+ */
+declare type AfterRouteHookContext_2 = RouteHookContext_2
+
 /**
  * Enumerates the lifecycle events for after route hooks.
  */
@@ -89,6 +115,10 @@ export declare type AfterRouteHookResponse<TRoutes extends Routes> = RouteHookSu
 
 declare type AllPropertiesAreOptional<T> = Record<string, unknown> extends T ? true : IsEmptyObject<OnlyRequiredProperties<T>>;
 
+declare type AllPropertiesAreOptional_2<T> = Record<string, unknown> extends T
+? true
+: IsEmptyObject_2<OnlyRequiredProperties_2<T>>
+
 declare type BaseResolvedRoute = Route & {
     path: {
         params: Record<string, unknown>;
@@ -98,6 +128,8 @@ declare type BaseResolvedRoute = Route & {
     };
 };
 
+declare type BaseResolvedRoute_2 = Route_2 & { path: { params: Record<string, unknown> }, query: { params: Record<string, unknown> } }
+
 declare type BaseRoute = {
     key: string;
     disabled: false;
@@ -109,6 +141,8 @@ declare type BaseRoute = {
     };
 };
 
+declare type BaseRoute_2 = { key: string, disabled: false, path: { params: Record<string, unknown> }, query: { params: Record<string, unknown> } }
+
 /**
  * Represents a function called before a route change, potentially altering the routing operation.
  * @param to - {@link ResolvedRoute} The resolved route the router is navigating to.
@@ -117,6 +151,14 @@ declare type BaseRoute = {
  */
 export declare type BeforeRouteHook = (to: ResolvedRoute, context: BeforeRouteHookContext) => MaybePromise<void>;
 
+/**
+ * Represents a function called before a route change, potentially altering the routing operation.
+ * @param to - {@link ResolvedRoute} The resolved route the router is navigating to.
+ * @param context - {@link BeforeRouteHookContext} The context providing functions and state for the routing operation.
+ * @returns Possibly a promise that resolves when the hook's logic has completed.
+ */
+declare type BeforeRouteHook_2 = (to: ResolvedRoute_2, context: BeforeRouteHookContext_2) => MaybePromise_2<void>
+
 /**
  * Context provided to route hooks, containing context of previous route and functions for triggering rejections, push/replace to another route,
  * as well as aborting current route change.
@@ -125,6 +167,14 @@ declare type BeforeRouteHookContext = RouteHookContext & {
     abort: RouteHookAbort;
 };
 
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections, push/replace to another route,
+ * as well as aborting current route change.
+ */
+declare type BeforeRouteHookContext_2 = RouteHookContext_2 & {
+    abort: RouteHookAbort_2,
+}
+
 /**
  * Enumerates the lifecycle events for before route hooks.
  */
@@ -136,10 +186,14 @@ export declare type BeforeRouteHookLifecycle = 'onBeforeRouteEnter' | 'onBeforeR
  */
 export declare type BeforeRouteHookResponse<TRoutes extends Routes> = RouteHookSuccessResponse | RouteHookPushResponse<TRoutes> | RouteHookRejectResponse | RouteHookAbortResponse;
 
-declare const builtInRejections: readonly ["NotFound"];
+declare const builtInRejections: ['NotFound'];
+
+declare const builtInRejections_2: ['NotFound'] = ['NotFound'];
 
 declare type BuiltInRejectionType = typeof builtInRejections[number];
 
+declare type BuiltInRejectionType_2 = typeof builtInRejections_2[number]
+
 /**
  * Represents properties for child routes, including required component, name, and path.
  */
@@ -166,6 +220,32 @@ export declare type ChildRouteProps = (WithComponent | WithComponents) & WithHoo
     meta?: RouteMeta;
 };
 
+/**
+ * Represents properties for child routes, including required component, name, and path.
+ */
+declare type ChildRouteProps_2 = (WithComponent_2 | WithComponents_2) & WithHooks_2 & {
+    /**
+     * Name for route, used to create route keys and in navigation.
+     */
+    name: string,
+    /**
+     * Children routes, expected type comes from `createRoutes()`
+     */
+    disabled?: boolean,
+    /**
+     * Path part of URL.
+     */
+    path: string | Path_2,
+    /**
+     * Query (aka search) part of URL.
+     */
+    query?: string | Query_2,
+    /**
+     * Represents additional metadata associated with a route, customizable via declaration merging.
+     */
+    meta?: RouteMeta_2,
+}
+
 declare type CombineName<TParentName extends string | undefined, TChildName extends string | undefined> = TParentName extends string ? TChildName extends string ? `${TParentName}.${TChildName}` : TParentName : TChildName extends string ? TChildName : '';
 
 declare type CombinePath<TParent extends Path, TChild extends Path> = ToPath<TParent> extends {
@@ -210,6 +290,12 @@ export declare function component<TComponent extends Component>(component: TComp
 
 declare type Constructor = new (...args: any) => any;
 
+export declare function createParam<TParam extends ParamWithDefault>(param: TParam): TParam;
+
+export declare function createParam<TParam extends Param>(param: TParam): ParamGetSet<ExtractParamType<TParam>>;
+
+export declare function createParam<TParam extends Param>(param: TParam, defaultValue: ExtractParamType<TParam>): ParamWithDefault<TParam>;
+
 /**
  * Creates a router instance for a Vue application, equipped with methods for route handling, lifecycle hooks, and state management.
  *
@@ -264,64 +350,179 @@ export declare class DuplicateParamsError extends Error {
  */
 export declare type ExtractParamName<TParam extends string> = TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam;
 
+/**
+ * Extracts the parameter name from a string, handling optional parameters denoted by a leading '?'.
+ * @template TParam - The string from which to extract the parameter name.
+ * @returns The extracted parameter name, or never if the parameter string is empty.
+ */
+declare type ExtractParamName_2<
+TParam extends string
+> = TParam extends `?${infer Param}`
+? Param extends ''
+? never
+: Param
+: TParam extends ''
+? never
+: TParam
+
 declare type ExtractParamsFromPathString<TPath extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TPath extends `${string}${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? MergeParams<{
     [P in ExtractParamName<Param>]: ExtractPathParamType<Param, TParams>;
 }, ExtractParamsFromPathString<Rest, TParams>> : Record<never, never>;
 
+declare type ExtractParamsFromPathString_2<
+TPath extends string,
+TParams extends Record<string, Param_2 | undefined> = Record<never, never>
+> = TPath extends `${string}${ParamStart_2}${infer Param}${ParamEnd_2}${infer Rest}`
+? MergeParams_2<{ [P in ExtractParamName_2<Param>]: ExtractPathParamType_2<Param, TParams> }, ExtractParamsFromPathString_2<Rest, TParams>>
+: Record<never, never>
+
+/**
+ * Extracts the actual type from a parameter type, handling getters, setters, and potential undefined values.
+ * This type also is responsible for narrowing possibly undefined values when the param has a default value.
+ * @template TParam - The parameter type.
+ * @returns The extracted type, or 'string' as a fallback.
+ */
+export declare type ExtractParamType<TParam extends Param> = TParam extends ParamGetSet<infer Type> ? TParam extends IsOptionalParam ? TParam extends ParamWithDefault ? Type : Type | undefined : Type : TParam extends ParamGetter ? ReturnType<TParam> : string;
+
 /**
  * Extracts the actual type from a parameter type, handling getters, setters, and potential undefined values.
+ * This type also is responsible for narrowing possibly undefined values when the param has a default value.
  * @template TParam - The parameter type.
  * @returns The extracted type, or 'string' as a fallback.
  */
-export declare type ExtractParamType<TParam extends Param | undefined> = TParam extends ParamGetSet<infer Type> ? undefined extends TParam ? Type | undefined : Type : TParam extends ParamGetter ? undefined extends TParam ? ReturnType<TParam> | undefined : ReturnType<TParam> : undefined extends TParam ? undefined : string;
+declare type ExtractParamType_2<TParam extends Param_2> = TParam extends ParamGetSet_2<infer Type>
+? TParam extends IsOptionalParam_2
+? TParam extends ParamWithDefault_2
+? Type
+: Type | undefined
+: Type
+: TParam extends ParamGetter_2
+? ReturnType<TParam>
+: string
 
 /**
  * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
  * @template TParams - The record of parameter types, possibly including undefined.
  * @returns A new type with the appropriate properties marked as optional.
  */
-export declare type ExtractParamTypes<TParams extends Record<string, Param | undefined>> = Identity<MakeOptional<{
+export declare type ExtractParamTypes<TParams extends Record<string, Param>> = Identity<MakeOptional<{
     [K in keyof TParams]: ExtractParamType<TParams[K]>;
 }>>;
 
+/**
+ * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
+ * @template TParams - The record of parameter types, possibly including undefined.
+ * @returns A new type with the appropriate properties marked as optional.
+ */
+declare type ExtractParamTypes_2<TParams extends Record<string, Param_2>> = Identity_2<MakeOptional_2<{
+    [K in keyof TParams]: ExtractParamType_2<TParams[K]>
+}>>
+
+declare type ExtractParamTypesWithoutLosingOptional<TParams extends Record<string, Param>> = Identity<MakeOptional<{
+    [K in keyof TParams]: ExtractParamTypeWithoutLosingOptional<TParams[K]>;
+}>>;
+
+declare type ExtractParamTypesWithoutLosingOptional_2<TParams extends Record<string, Param_2>> = Identity_2<MakeOptional_2<{
+    [K in keyof TParams]: ExtractParamTypeWithoutLosingOptional_2<TParams[K]>
+}>>
+
+declare type ExtractParamTypeWithoutLosingOptional<TParam extends Param> = TParam extends ParamGetSet<infer Type> ? TParam extends IsOptionalParam ? Type | undefined : Type : TParam extends ParamGetter ? ReturnType<TParam> : string;
+
+declare type ExtractParamTypeWithoutLosingOptional_2<TParam extends Param_2> = TParam extends ParamGetSet_2<infer Type>
+? TParam extends IsOptionalParam_2
+? Type | undefined
+: Type
+: TParam extends ParamGetter_2
+? ReturnType<TParam>
+: string
+
 /**
  * Determines the type of a path parameter from a record of parameter types, considering optional parameters.
  * @template TParam - The parameter name string.
  * @template TParams - The record object mapping parameter names to their types.
  * @returns The type associated with the parameter, or StringConstructor if unspecified; may be undefined for optional parameters.
  */
-export declare type ExtractPathParamType<TParam extends string, TParams extends Record<string, Param | undefined>> = TParam extends `?${infer OptionalParam}` ? OptionalParam extends keyof TParams ? TParams[OptionalParam] | undefined : StringConstructor | undefined : TParam extends keyof TParams ? TParams[TParam] : StringConstructor;
+export declare type ExtractPathParamType<TParam extends string, TParams extends Record<string, Param | undefined>> = TParam extends `?${infer OptionalParam}` ? OptionalParam extends keyof TParams ? TParams[OptionalParam] extends Param ? OptionalParamGetSet<TParams[OptionalParam]> : OptionalParamGetSet<StringConstructor> : OptionalParamGetSet<StringConstructor> : TParam extends keyof TParams ? TParams[TParam] : StringConstructor;
+
+/**
+ * Determines the type of a path parameter from a record of parameter types, considering optional parameters.
+ * @template TParam - The parameter name string.
+ * @template TParams - The record object mapping parameter names to their types.
+ * @returns The type associated with the parameter, or StringConstructor if unspecified; may be undefined for optional parameters.
+ */
+declare type ExtractPathParamType_2<
+TParam extends string,
+TParams extends Record<string, Param_2 | undefined>
+> = TParam extends `?${infer OptionalParam}`
+? OptionalParam extends keyof TParams
+? TParams[OptionalParam] extends Param_2
+? OptionalParamGetSet_2<TParams[OptionalParam]>
+: OptionalParamGetSet_2<StringConstructor>
+: OptionalParamGetSet_2<StringConstructor>
+: TParam extends keyof TParams
+? TParams[TParam]
+: StringConstructor
 
 declare type ExtractQueryParamsFromQueryString<TQuery extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TQuery extends `${string}=${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? MergeParams<{
     [P in ExtractParamName<Param>]: ExtractPathParamType<Param, TParams>;
 }, ExtractQueryParamsFromQueryString<Rest, TParams>> : Record<never, never>;
 
+declare type ExtractQueryParamsFromQueryString_2<
+TQuery extends string,
+TParams extends Record<string, Param_2 | undefined> = Record<never, never>
+> = TQuery extends `${string}=${ParamStart_2}${infer Param}${ParamEnd_2}${infer Rest}`
+? MergeParams_2<{ [P in ExtractParamName_2<Param>]: ExtractPathParamType_2<Param, TParams> }, ExtractQueryParamsFromQueryString_2<Rest, TParams>>
+: Record<never, never>
+
 declare type ExtractRouteChildren<TRoute extends RouteProps> = TRoute extends ParentRouteProps ? TRoute['children'] extends Route[] ? TRoute['children'] : [] : [];
 
 /**
  * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
+ * This parameter object type represents the expected type when accessing params from router.route or useRoute.
  * @template TRoute - The route type from which to extract and merge parameter types.
  * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
  */
-export declare type ExtractRouteParamTypes<TRoute extends {
+export declare type ExtractRouteParamTypes<TRoute> = TRoute extends {
     path: {
-        params: Record<string, unknown>;
+        params: infer PathParams extends Record<string, Param>;
     };
     query: {
-        params: Record<string, unknown>;
+        params: infer QueryParams extends Record<string, Param>;
     };
-}> = TRoute extends {
+} ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : Record<string, unknown>;
+
+/**
+ * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
+ * This parameter object type represents the expected type when accessing params from router.route or useRoute.
+ * @template TRoute - The route type from which to extract and merge parameter types.
+ * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
+ */
+declare type ExtractRouteParamTypes_2<TRoute> = TRoute extends {
+    path: { params: infer PathParams extends Record<string, Param_2> },
+    query: { params: infer QueryParams extends Record<string, Param_2> },
+}
+? ExtractParamTypes_2<MergeParams_2<PathParams, QueryParams>>
+: Record<string, unknown>
+
+declare type ExtractRouteParamTypesWithoutLosingOptional<TRoute> = TRoute extends {
     path: {
-        params: infer PathParams extends Record<string, Param | undefined>;
+        params: infer PathParams extends Record<string, Param>;
     };
     query: {
-        params: infer QueryParams extends Record<string, Param | undefined>;
+        params: infer QueryParams extends Record<string, Param>;
     };
-} ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : Record<string, unknown>;
+} ? ExtractParamTypesWithoutLosingOptional<MergeParams<PathParams, QueryParams>> : Record<string, unknown>;
+
+declare type ExtractRouteParamTypesWithoutLosingOptional_2<TRoute> = TRoute extends {
+    path: { params: infer PathParams extends Record<string, Param_2> },
+    query: { params: infer QueryParams extends Record<string, Param_2> },
+}
+? ExtractParamTypesWithoutLosingOptional_2<MergeParams_2<PathParams, QueryParams>>
+: Record<string, unknown>
 
 declare type Flatten<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends unknown[] ? Flatten<[...First, ...Flatten<Rest>]> : [First, ...Flatten<Rest>] : [];
 
-declare type FlattenRoute<TRoute extends RouteProps, TKey extends string | undefined = TRoute['name'], TPath extends Path = ToPath<TRoute['path']>, TQuery extends Query = ToQuery<TRoute['query']>, TDisabled extends boolean = TRoute['disabled'] extends boolean ? TRoute['disabled'] : false, TChildren extends Route[] = ExtractRouteChildren<TRoute>> = [
+declare type FlattenRoute<TRoute extends RouteProps, TKey extends string = string & TRoute['name'], TPath extends Path = ToPath<TRoute['path']>, TQuery extends Query = ToQuery<TRoute['query']>, TDisabled extends boolean = TRoute['disabled'] extends boolean ? TRoute['disabled'] : false, TChildren extends Route[] = ExtractRouteChildren<TRoute>> = [
 Route<TKey, TPath, TQuery, TDisabled>,
 ...{
     [K in keyof TChildren]: Route<CombineName<TKey, TChildren[K]['key']>, CombinePath<TPath, TChildren[K]['path']>, CombineQuery<TQuery, TChildren[K]['query']>, TChildren[K]['disabled']>;
@@ -338,8 +539,22 @@ declare type Identity<T> = T extends object ? {} & {
     [P in keyof T as T[P] extends never ? never : P]: T[P];
 } : T;
 
+declare type Identity_2<T> = T extends object ? {} & {
+    [P in keyof T as T[P] extends never ? never : P]: T[P]
+} : T
+
 declare type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
 
+declare type IsEmptyObject_2<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false
+
+declare type IsOptionalParam = {
+    [optionalParamKey]: true;
+};
+
+declare type IsOptionalParam_2 = {
+    [optionalParamKey_2]: true,
+}
+
 /**
  * Type guard to check if a value conforms to the ParamGetSet type.
  * @param value - The value to check.
@@ -354,6 +569,8 @@ export declare function isParamGetSet(value: Param): value is ParamGetSet;
  */
 export declare function isParamGetter(value: Param): value is ParamGetter;
 
+export declare function isParamWithDefault(param: Param): param is ParamWithDefault;
+
 /**
  * Type guard function to determine if a given route configuration is a parent route, based on the presence of children.
  * @param value - The route configuration to check.
@@ -365,36 +582,40 @@ export declare function isParentRouteWithoutComponent(value: RouteProps): value
 
 export declare function isRoute(route: unknown): route is RouterRoute;
 
-export declare function isRoute<TRouteKey extends RegisteredRoutesKey>(route: unknown, routeKey: TRouteKey, options: IsRouteOptions): route is RouterRoute<ResolvedRoute<RegisteredRouteMap[TRouteKey]>>;
+export declare function isRoute<TRouteKey extends RegisteredRoutesKey>(route: unknown, routeKey: TRouteKey, options?: IsRouteOptions): route is RouterRoute<ResolvedRoute<RegisteredRouteMap[TRouteKey]>>;
 
 declare type IsRouteOptions = {
     exact?: boolean;
 };
 
-declare const isRouterRouteSymbol: unique symbol;
-
 export declare function isRouteWithComponent(value: RouteProps): value is RouteProps & WithComponent;
 
 export declare function isRouteWithComponent(value: Readonly<RouteProps>): value is Readonly<RouteProps & WithComponent>;
 
-export declare function isRouteWithComponent(value: DeepReadonly<RouteProps>): value is DeepReadonly<RouteProps & WithComponent>;
-
 export declare function isRouteWithComponents(value: RouteProps): value is RouteProps & WithComponents;
 
 export declare function isRouteWithComponents(value: Readonly<RouteProps>): value is Readonly<RouteProps & WithComponents>;
 
-export declare function isRouteWithComponents(value: DeepReadonly<RouteProps>): value is DeepReadonly<RouteProps & WithComponents>;
-
 declare type MakeOptional<T> = {
     [P in WithOptionalProperties<T>]?: T[P];
 } & {
     [P in Exclude<keyof T, WithOptionalProperties<T>>]: T[P];
 };
 
+declare type MakeOptional_2<T> = {
+    [P in WithOptionalProperties_2<T>]?: T[P];
+} & {
+    [P in Exclude<keyof T, WithOptionalProperties_2<T>>]: T[P];
+}
+
 declare type MaybeArray<T> = T | T[];
 
+declare type MaybeArray_2<T> = T | T[]
+
 declare type MaybePromise<T> = T | Promise<T>;
 
+declare type MaybePromise_2<T> = T | Promise<T>
+
 /**
  * Merges two parameter type records, ensuring no overlap in properties.
  * @template TAlpha - The first record type.
@@ -405,8 +626,29 @@ export declare type MergeParams<TAlpha extends Record<string, unknown>, TBeta ex
     [K in keyof TAlpha | keyof TBeta]: K extends keyof TAlpha & keyof TBeta ? never : K extends keyof TAlpha ? TAlpha[K] : K extends keyof TBeta ? TBeta[K] : never;
 };
 
+/**
+ * Merges two parameter type records, ensuring no overlap in properties.
+ * @template TAlpha - The first record type.
+ * @template TBeta - The second record type.
+ * @returns A new record type combining properties from both inputs without overlaps.
+ */
+declare type MergeParams_2<
+TAlpha extends Record<string, unknown>,
+TBeta extends Record<string, unknown>
+> = {
+    [K in keyof TAlpha | keyof TBeta]: K extends keyof TAlpha & keyof TBeta
+    ? never
+    : K extends keyof TAlpha
+    ? TAlpha[K]
+    : K extends keyof TBeta
+    ? TBeta[K]
+    : never
+}
+
 declare type NamedNotDisabled<T> = T extends BaseRoute ? T : never;
 
+declare type NamedNotDisabled_2<T> = T extends BaseRoute_2 ? T : never
+
 /**
  * Registers a hook that is called after a route has been entered. Must be called during setup.
  * This allows performing actions right after the component becomes active, such as fetching data or setting up event listeners.
@@ -456,29 +698,72 @@ declare type OnlyRequiredProperties<T> = {
     [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
 };
 
+declare type OnlyRequiredProperties_2<T> = {
+    [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K]
+}
+
+declare type OptionalParamGetSet<TParam extends Param> = TParam extends ParamGetSet ? TParam & IsOptionalParam : ParamGetSet<ExtractParamType<TParam>> & IsOptionalParam;
+
+declare type OptionalParamGetSet_2<TParam extends Param_2> = TParam extends ParamGetSet_2
+? TParam & IsOptionalParam_2
+: ParamGetSet_2<ExtractParamType_2<TParam>> & IsOptionalParam_2
+
+declare const optionalParamKey: unique symbol;
+
+declare const optionalParamKey_2 = Symbol();
+
 export declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON;
 
+declare type Param_2 = ParamGetter_2 | ParamGetSet_2 | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON
+
 export declare type ParamEnd = typeof paramEnd;
 
 export declare const paramEnd = "]";
 
+declare type ParamEnd_2 = typeof paramEnd_2
+
+declare const paramEnd_2 = ']';
+
 export declare type ParamExtras = {
     invalid: (message?: string) => never;
 };
 
+declare type ParamExtras_2 = {
+    invalid: (message?: string) => never,
+}
+
 export declare type ParamGetSet<T = any> = {
     get: ParamGetter<T>;
     set: ParamSetter<T>;
+    defaultValue?: T;
 };
 
+declare type ParamGetSet_2<T = any> = {
+    get: ParamGetter_2<T>,
+    set: ParamSetter_2<T>,
+    defaultValue?: T,
+}
+
 export declare type ParamGetter<T = any> = (value: string, extras: ParamExtras) => T;
 
+declare type ParamGetter_2<T = any> = (value: string, extras: ParamExtras_2) => T
+
 export declare type ParamSetter<T = any> = (value: T, extras: ParamExtras) => string;
 
+declare type ParamSetter_2<T = any> = (value: T, extras: ParamExtras_2) => string
+
 export declare type ParamStart = typeof paramStart;
 
 export declare const paramStart = "[";
 
+declare type ParamStart_2 = typeof paramStart_2
+
+declare const paramStart_2 = '[';
+
+export declare type ParamWithDefault<TParam extends Param = Param> = Required<ParamGetSet<ExtractParamType<TParam>>>;
+
+declare type ParamWithDefault_2<TParam extends Param_2 = Param_2> = Required<ParamGetSet_2<ExtractParamType_2<TParam>>>
+
 /**
  * Represents properties common to parent routes in a route configuration, including hooks, path, and optional query parameters.
  */
@@ -509,9 +794,39 @@ export declare type ParentRouteProps = Partial<WithComponent | WithComponents> &
     meta?: RouteMeta;
 };
 
-declare type Path<TPath extends string = any, TParams extends PathParams<TPath> = any> = {
+/**
+ * Represents properties common to parent routes in a route configuration, including hooks, path, and optional query parameters.
+ */
+declare type ParentRouteProps_2 = Partial<WithComponent_2 | WithComponents_2> & WithHooks_2 & {
+    /**
+     * Name for route, used to create route keys and in navigation.
+     */
+    name?: string,
+    /**
+     * Path part of URL.
+     */
+    path: string | Path_2,
+    /**
+     * Query (aka search) part of URL.
+     */
+    query?: string | Query_2,
+    /**
+     * Disabled routes will not ever match but can still provide physical structure, nested children behave normally.
+     */
+    disabled?: boolean,
+    /**
+     * Children routes, expected type comes from `createRoutes()`
+     */
+    children: Routes_2,
+    /**
+     * Represents additional metadata associated with a route, customizable via declaration merging.
+     */
+    meta?: RouteMeta_2,
+}
+
+declare type Path<TPath extends string = string, TParams extends PathParams<TPath> = Record<string, Param | undefined>> = {
     path: TPath;
-    params: Identity<ExtractParamsFromPathString<TPath, TParams>>;
+    params: string extends TPath ? Record<string, Param> : Identity<ExtractParamsFromPathString<TPath, TParams>>;
     toString: () => string;
 };
 
@@ -540,17 +855,30 @@ declare type Path<TPath extends string = any, TParams extends PathParams<TPath>
  */
 export declare function path<TPath extends string, TParams extends PathParams<TPath>>(path: TPath, params: Identity<TParams>): Path<TPath, TParams>;
 
+declare type Path_2<
+TPath extends string = string,
+TParams extends PathParams_2<TPath> = Record<string, Param_2 | undefined>
+> = {
+    path: TPath,
+    params: string extends TPath ? Record<string, Param_2> : Identity_2<ExtractParamsFromPathString_2<TPath, TParams>>,
+    toString: () => string,
+}
+
 declare type PathParams<TPath extends string> = {
     [K in keyof ExtractParamsFromPathString<TPath>]?: Param;
 };
 
+declare type PathParams_2<TPath extends string> = {
+    [K in keyof ExtractParamsFromPathString_2<TPath>]?: Param_2
+}
+
 declare type Props<TComponent extends Component> = TComponent extends Constructor ? InstanceType<TComponent>['$props'] : TComponent extends AsyncComponentLoader<infer T extends Component> ? Props<T> : TComponent extends FunctionalComponent<infer T> ? T : never;
 
 declare type PropsGetter<TComponent extends Component> = () => MaybePromise<Props<TComponent>>;
 
-declare type Query<T extends string = any, P extends QueryParams<T> = any> = {
-    query: T;
-    params: Identity<ExtractQueryParamsFromQueryString<T, P>>;
+declare type Query<TQuery extends string = string, TQueryParams extends QueryParams<TQuery> = Record<string, Param | undefined>> = {
+    query: TQuery;
+    params: string extends TQuery ? Record<string, Param> : Identity<ExtractQueryParamsFromQueryString<TQuery, TQueryParams>>;
     toString: () => string;
 };
 
@@ -579,10 +907,23 @@ declare type Query<T extends string = any, P extends QueryParams<T> = any> = {
  */
 export declare function query<TQuery extends string, TParams extends QueryParams<TQuery>>(query: TQuery, params: Identity<TParams>): Query<TQuery, TParams>;
 
+declare type Query_2<
+TQuery extends string = string,
+TQueryParams extends QueryParams_2<TQuery> = Record<string, Param_2 | undefined>
+> = {
+    query: TQuery,
+    params: string extends TQuery ? Record<string, Param_2> : Identity_2<ExtractQueryParamsFromQueryString_2<TQuery, TQueryParams>>,
+    toString: () => string,
+}
+
 declare type QueryParams<T extends string> = {
     [K in keyof ExtractQueryParamsFromQueryString<T>]?: Param;
 };
 
+declare type QueryParams_2<T extends string> = {
+    [K in keyof ExtractQueryParamsFromQueryString_2<T>]?: Param_2
+}
+
 /**
  * Represents the state of currently registered router, and rejections. Used to provide correct type context for
  * components like `RouterLink`, as well as for composables like `useRouter`, `useRoute`, and hooks.
@@ -599,6 +940,21 @@ declare type QueryParams<T extends string> = {
 export declare interface Register {
 }
 
+/**
+ * Represents the state of currently registered router, and rejections. Used to provide correct type context for
+ * components like `RouterLink`, as well as for composables like `useRouter`, `useRoute`, and hooks.
+ *
+ * @example
+ * ```ts
+ * declare module '@kitbag/router' {
+ *   interface Register {
+ *     router: typeof router
+ *   }
+ * }
+ * ```
+ */
+declare interface Register_2 {}
+
 /**
  * Represents the possible Rejections registered within {@link Register}
  */
@@ -606,6 +962,13 @@ export declare type RegisteredRejectionType = Register extends {
     rejections: infer TRejections extends string[];
 } ? TRejections[number] : never;
 
+/**
+ * Represents the possible Rejections registered within {@link Register}
+ */
+declare type RegisteredRejectionType_2 = Register_2 extends { rejections: infer TRejections extends string[] }
+? TRejections[number]
+: never
+
 /**
  * Represents the a map of all possible RouteKeys with corresponding Route registered within {@link Register}
  */
@@ -623,11 +986,21 @@ export declare type RegisteredRouter = Register extends {
  */
 export declare type RegisteredRouterPush = RouterPush<RegisteredRoutes>;
 
+/**
+ * Represents the type for router `push`, with types for routes registered within {@link Register}
+ */
+declare type RegisteredRouterPush_2 = RouterPush_2<RegisteredRoutes_2>
+
 /**
  * Represents the type for router `replace`, with types for routes registered within {@link Register}
  */
 export declare type RegisteredRouterReplace = RouterReplace<RegisteredRoutes>;
 
+/**
+ * Represents the type for router `replace`, with types for routes registered within {@link Register}
+ */
+declare type RegisteredRouterReplace_2 = RouterReplace_2<RegisteredRoutes_2>
+
 /**
  * Represents the State property registered within {@link Register}
  */
@@ -642,6 +1015,13 @@ export declare type RegisteredRoutes = Register extends {
     router: Router<infer TRoutes extends Routes>;
 } ? TRoutes : Route<string, Path<'', {}>, Query<'', {}>, false>[];
 
+/**
+ * Represents the Router routes property within {@link Register}
+ */
+declare type RegisteredRoutes_2 = Register_2 extends { router: Router_2<infer TRoutes extends Routes_2> }
+? TRoutes
+: Route_2<string, Path_2<'', {}>, Query_2<'', {}>, false>[]
+
 /**
  * Represents the union of all possible RouteKeys registered within {@link Register}
  */
@@ -651,7 +1031,7 @@ export declare type RegisteredRoutesKey = RoutesKey<RegisteredRoutes>;
  * Represents a route that the router has matched to current browser location.
  * @template TRoute - Underlying Route that has been resolved.
  */
-declare type ResolvedRoute<TRoute extends Route = BaseResolvedRoute> = DeepReadonly<{
+declare type ResolvedRoute<TRoute extends Route = BaseResolvedRoute> = Readonly<{
     /**
      * The specific route properties that were matched in the current route.
      */
@@ -660,7 +1040,7 @@ declare type ResolvedRoute<TRoute extends Route = BaseResolvedRoute> = DeepReado
      * 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: RouteProps[];
+    matches: TRoute['matches'];
     /**
      * Unique identifier for the route, generated by joining route `name` by period. Key is used for routing and for matching.
      */
@@ -672,14 +1052,47 @@ declare type ResolvedRoute<TRoute extends Route = BaseResolvedRoute> = DeepReado
     /**
      * Key value pair for route params, values will be the user provided value from current browser location.
      */
-    params: ExtractRouteParamTypes<TRoute>;
+    params: BaseResolvedRoute extends TRoute ? Record<string, unknown> : ExtractRouteParamTypes<TRoute>;
 }>;
 
+/**
+ * Represents a route that the router has matched to current browser location.
+ * @template TRoute - Underlying Route that has been resolved.
+ */
+declare type ResolvedRoute_2<TRoute extends Route_2 = BaseResolvedRoute_2> = Readonly<{
+    /**
+     * The specific route properties that were matched in the current route.
+     */
+    matched: TRoute['matched'],
+    /**
+     * 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: TRoute['matches'],
+    /**
+     * Unique identifier for the route, generated by joining route `name` by period. Key is used for routing and for matching.
+     */
+    key: TRoute['key'],
+    /**
+     * Accessor for query string values from user in the current browser location.
+     */
+    query: ResolvedRouteQuery_2,
+    /**
+     * Key value pair for route params, values will be the user provided value from current browser location.
+     */
+    params: BaseResolvedRoute_2 extends TRoute ? Record<string, unknown> : ExtractRouteParamTypes_2<TRoute>,
+}>
+
 declare type ResolvedRouteQuery = {
     get: (key: string) => string | null;
     getAll: (key: string) => string[];
 };
 
+declare type ResolvedRouteQuery_2 = {
+    get: (key: string) => string | null,
+    getAll: (key: string) => string[],
+}
+
 /**
  * Represents the structure of a route within the application. Return value of `createRoutes`
  * @template TKey - Represents the unique key identifying the route, typically a string.
@@ -687,7 +1100,7 @@ declare type ResolvedRouteQuery = {
  * @template TQuery - The type or structure of the query parameters associated with the route.
  * @template TDisabled - Indicates whether the route is disabled, which could affect routing logic.
  */
-export declare type Route<TKey extends string | undefined = any, TPath extends string | Path = Path, TQuery extends string | Query | undefined = Query, TDisabled extends boolean | undefined = boolean> = {
+export declare type Route<TKey extends string = string, TPath extends string | Path = Path, TQuery extends string | Query = Query, TDisabled extends boolean = boolean> = {
     /**
      * The specific route properties that were matched in the current route.
      */
@@ -716,8 +1129,51 @@ export declare type Route<TKey extends string | undefined = any, TPath extends s
     disabled: TDisabled extends boolean ? TDisabled : false;
 };
 
+/**
+ * Represents the structure of a route within the application. Return value of `createRoutes`
+ * @template TKey - Represents the unique key identifying the route, typically a string.
+ * @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.
+ * @template TDisabled - Indicates whether the route is disabled, which could affect routing logic.
+ */
+declare type Route_2<
+TKey extends string = string,
+TPath extends string | Path_2 = Path_2,
+TQuery extends string | Query_2 = Query_2,
+TDisabled extends boolean = boolean
+> = {
+    /**
+     * The specific route properties that were matched in the current route.
+     */
+    matched: RoutePropsWithMeta_2,
+    /**
+     * 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: RoutePropsWithMeta_2[],
+    /**
+     * Unique identifier for the route, generated by joining route `name` by period. Key is used for routing and for matching.
+     */
+    key: TKey,
+    /**
+     * Represents the structured path of the route, including path params.
+     */
+    path: ToPath_2<TPath>,
+    /**
+     * Represents the structured query of the route, including query params.
+     */
+    query: ToQuery_2<TQuery>,
+    depth: number,
+    /**
+     * Indicates if the route is disabled.
+     */
+    disabled: TDisabled extends boolean ? TDisabled : false,
+}
+
 declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesKey<TRoutes>> = RoutesMap<TRoutes>[TKey];
 
+declare type RouteGetByKey_2<TRoutes extends Routes_2, TKey extends RoutesKey_2<TRoutes>> = RoutesMap_2<TRoutes>[TKey]
+
 /**
  * Generic type representing a route hook, which can be either before or after a route change.
  */
@@ -728,6 +1184,11 @@ export declare type RouteHook = BeforeRouteHook | AfterRouteHook;
  */
 export declare type RouteHookAbort = () => void;
 
+/**
+ * A function that can be called to abort a routing operation.
+ */
+declare type RouteHookAbort_2 = () => void
+
 /**
  * Defines the structure of an aborted route hook response.
  */
@@ -745,6 +1206,16 @@ declare type RouteHookContext = {
     replace: RegisteredRouterReplace;
 };
 
+/**
+ * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
+ */
+declare type RouteHookContext_2 = {
+    from: ResolvedRoute_2 | null,
+    reject: RouterReject_2,
+    push: RegisteredRouterPush_2,
+    replace: RegisteredRouterReplace_2,
+}
+
 /**
  * Union type for all route hook lifecycle events.
  */
@@ -772,6 +1243,11 @@ declare type RouteHookRejectResponse = {
  */
 export declare type RouteHookRemove = () => void;
 
+/**
+ * A function to remove a previously registered route hook.
+ */
+declare type RouteHookRemove_2 = () => void
+
 /**
  * Union type for all possible route hook responses, covering both before and after scenarios.
  * @template TRoutes - The type of the routes configuration.
@@ -799,20 +1275,48 @@ declare type RouteHookSuccessResponse = {
 export declare interface RouteMeta extends Record<string, unknown> {
 }
 
-declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypes<RouteGetByKey<TRoutes, TKey>>;
+/**
+ * Represents additional metadata associated with a route, customizable via declaration merging.
+ * @example
+ * ```ts
+ * declare module '@kitbag/router' {
+ *   interface RouteMeta {
+ *     pageTitle?: string
+ *   }
+ * }
+ * ```
+ */
+declare interface RouteMeta_2 extends Record<string, unknown> {}
+
+declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypesWithoutLosingOptional<RouteGetByKey<TRoutes, TKey>>;
+
+declare type RouteParamsByKey_2<
+TRoutes extends Routes_2,
+TKey extends string
+> = ExtractRouteParamTypesWithoutLosingOptional_2<RouteGetByKey_2<TRoutes, TKey>>
 
 /**
  * Unifies the properties of both parent and child routes, ensuring type safety and consistency across route configurations.
  */
 export declare type RouteProps = Readonly<ParentRouteProps | ChildRouteProps>;
 
+/**
+ * Unifies the properties of both parent and child routes, ensuring type safety and consistency across route configurations.
+ */
+declare type RouteProps_2 = Readonly<ParentRouteProps_2 | ChildRouteProps_2>
+
 /**
  * The Route properties originally provided to `createRoutes`. The only change is normalizing meta to always default to an empty object.
  */
-declare type RoutePropsWithMeta = RouteProps & {
+export declare type RoutePropsWithMeta = RouteProps & {
     meta: RouteMeta;
 };
 
+/**
+ * The Route properties originally provided to `createRoutes`. The only change is normalizing meta to always default to an empty object.
+ */
+declare type RoutePropsWithMeta_2 = RouteProps_2 & { meta: RouteMeta_2 }
+
 export declare type Router<TRoutes extends Routes = any> = Plugin_2 & {
     /**
      * Manages the current route state.
@@ -884,12 +1388,100 @@ export declare type Router<TRoutes extends Routes = any> = Plugin_2 & {
     initialized: Promise<void>;
 };
 
+declare type Router_2<
+TRoutes extends Routes_2 = any
+> = Plugin_2 & {
+    /**
+     * Manages the current route state.
+     */
+    route: RouterRoute_2,
+    /**
+     * Resolves a URL to a route object.
+     */
+    resolve: RouterResolve_2<TRoutes>,
+    /**
+     * Navigates to a specified path or route object in the history stack, adding a new entry.
+     */
+    push: RouterPush_2<TRoutes>,
+    /**
+     * Replaces the current entry in the history stack with a new one.
+     */
+    replace: RouterReplace_2<TRoutes>,
+    /**
+     * Finds a route object based on the provided lookup parameters.
+     */
+    find: RouterFind_2<TRoutes>,
+    /**
+     * Handles route rejection based on a specified rejection type.
+     */
+    reject: RouterReject_2,
+    /**
+     * Forces the router to re-evaluate the current route.
+     */
+    refresh: () => void,
+    /**
+     * Navigates to the previous entry in the browser's history stack.
+     */
+    back: () => void,
+    /**
+     * Navigates to the next entry in the browser's history stack.
+     */
+    forward: () => void,
+    /**
+     * Moves the current history entry to a specific point in the history stack.
+     */
+    go: (delta: number) => void,
+    /**
+     * Registers a hook to be called before a route is entered.
+     */
+    onBeforeRouteEnter: AddBeforeRouteHook_2,
+    /**
+     * Registers a hook to be called before a route is left.
+     */
+    onBeforeRouteLeave: AddBeforeRouteHook_2,
+    /**
+     * Registers a hook to be called before a route is updated.
+     */
+    onBeforeRouteUpdate: AddBeforeRouteHook_2,
+    /**
+     * Registers a hook to be called after a route is entered.
+     */
+    onAfterRouteEnter: AddAfterRouteHook_2,
+    /**
+     * Registers a hook to be called after a route is left.
+     */
+    onAfterRouteLeave: AddAfterRouteHook_2,
+    /**
+     * Registers a hook to be called after a route is updated.
+     */
+    onAfterRouteUpdate: AddAfterRouteHook_2,
+    /**
+     * A promise that resolves when the router is fully initialized.
+     */
+    initialized: Promise<void>,
+}
+
 declare type RouterFind<TRoutes extends Routes> = {
     <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterFindArgs<TRoutes, TSource>): ResolvedRoute | undefined;
     (source: Url): ResolvedRoute | undefined;
 };
 
-declare type RouterFindArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams] : [params: TParams];
+declare type RouterFind_2<
+TRoutes extends Routes_2
+> = {
+    <TSource extends RoutesKey_2<TRoutes>>(source: TSource, ...args: RouterFindArgs_2<TRoutes, TSource>): ResolvedRoute_2 | undefined,
+    (source: Url_2): ResolvedRoute_2 | undefined,
+}
+
+declare type RouterFindArgs<TRoutes extends Routes, TSource extends RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams] : [params: TParams];
+
+declare type RouterFindArgs_2<
+TRoutes extends Routes_2,
+TSource extends RoutesKey_2<TRoutes>,
+TParams = RouteParamsByKey_2<TRoutes, TSource>
+> = AllPropertiesAreOptional_2<TParams> extends true
+? [params?: TParams]
+: [params: TParams]
 
 declare type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
 
@@ -943,15 +1535,37 @@ declare type RouterPush<TRoutes extends Routes = any> = {
     (source: Url, options?: RouterPushOptions): Promise<void>;
 };
 
-declare type RouterPushArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterPushOptions] : [params: TParams, options?: RouterPushOptions];
+declare type RouterPush_2<
+TRoutes extends Routes_2 = any
+> = {
+    <TSource extends RoutesKey_2<TRoutes>>(source: TSource, ...args: RouterPushArgs_2<TRoutes, TSource>): Promise<void>,
+    (source: Url_2, options?: RouterPushOptions_2): Promise<void>,
+}
+
+declare type RouterPushArgs<TRoutes extends Routes, TSource extends RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterPushOptions] : [params: TParams, options?: RouterPushOptions];
+
+declare type RouterPushArgs_2<
+TRoutes extends Routes_2,
+TSource extends RoutesKey_2<TRoutes>,
+TParams = RouteParamsByKey_2<TRoutes, TSource>
+> = AllPropertiesAreOptional_2<TParams> extends true
+? [params?: TParams, options?: RouterPushOptions_2]
+: [params: TParams, options?: RouterPushOptions_2]
 
 declare type RouterPushOptions = {
     query?: Record<string, string>;
     replace?: boolean;
 };
 
+declare type RouterPushOptions_2 = {
+    query?: Record<string, string>,
+    replace?: boolean,
+}
+
 export declare type RouterReject = (type: RouterRejectionType) => void;
 
+declare type RouterReject_2 = (type: RouterRejectionType_2) => void
+
 declare type RouterRejection = Ref<null | {
     type: RouterRejectionType;
     component: Component;
@@ -965,39 +1579,102 @@ export declare const routerRejectionKey: InjectionKey<RouterRejection>;
 
 declare type RouterRejectionType = BuiltInRejectionType | RegisteredRejectionType;
 
+declare type RouterRejectionType_2 = BuiltInRejectionType_2 | RegisteredRejectionType_2
+
 declare type RouterReplace<TRoutes extends Routes> = {
     <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterReplaceArgs<TRoutes, TSource>): Promise<void>;
     (source: Url, options?: RouterReplaceOptions): Promise<void>;
 };
 
-declare type RouterReplaceArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterReplaceOptions] : [params: TParams, options?: RouterReplaceOptions];
+declare type RouterReplace_2<
+TRoutes extends Routes_2
+> = {
+    <TSource extends RoutesKey_2<TRoutes>>(source: TSource, ...args: RouterReplaceArgs_2<TRoutes, TSource>): Promise<void>,
+    (source: Url_2, options?: RouterReplaceOptions_2): Promise<void>,
+}
+
+declare type RouterReplaceArgs<TRoutes extends Routes, TSource extends RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterReplaceOptions] : [params: TParams, options?: RouterReplaceOptions];
+
+declare type RouterReplaceArgs_2<
+TRoutes extends Routes_2,
+TSource extends RoutesKey_2<TRoutes>,
+TParams = RouteParamsByKey_2<TRoutes, TSource>
+> = AllPropertiesAreOptional_2<TParams> extends true
+? [params?: TParams, options?: RouterReplaceOptions_2]
+: [params: TParams, options?: RouterReplaceOptions_2]
 
 declare type RouterReplaceOptions = Omit<RouterPushOptions, 'replace'>;
 
+declare type RouterReplaceOptions_2 = Omit<RouterPushOptions_2, 'replace'>
+
 declare type RouterResolve<TRoutes extends Routes> = {
     <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterResolveArgs<TRoutes, TSource>): string;
     (source: Url, options?: RouterResolveOptions): string;
 };
 
-declare type RouterResolveArgs<TRoutes extends Routes, TSource extends string & keyof RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterResolveOptions] : [params: TParams, options?: RouterResolveOptions];
+declare type RouterResolve_2<
+TRoutes extends Routes_2
+> = {
+    <TSource extends RoutesKey_2<TRoutes>>(source: TSource, ...args: RouterResolveArgs_2<TRoutes, TSource>): string,
+    (source: Url_2, options?: RouterResolveOptions_2): string,
+}
+
+declare type RouterResolveArgs<TRoutes extends Routes, TSource extends RoutesKey<TRoutes>, TParams = RouteParamsByKey<TRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: TParams, options?: RouterResolveOptions] : [params: TParams, options?: RouterResolveOptions];
+
+declare type RouterResolveArgs_2<
+TRoutes extends Routes_2,
+TSource extends RoutesKey_2<TRoutes>,
+TParams = RouteParamsByKey_2<TRoutes, TSource>
+> = AllPropertiesAreOptional_2<TParams> extends true
+? [params?: TParams, options?: RouterResolveOptions_2]
+: [params: TParams, options?: RouterResolveOptions_2]
 
 declare type RouterResolveOptions = {
     query?: Record<string, string>;
 };
 
-declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = Omit<ResolvedRoute, 'params'> & Readonly<{
+declare type RouterResolveOptions_2 = {
+    query?: Record<string, string>,
+}
+
+declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = Readonly<{
+    key: TRoute['key'];
+    matched: TRoute['matched'];
+    matches: TRoute['matches'];
+    query: ResolvedRouteQuery;
     params: Writable<TRoute['params']>;
     update: RouteUpdate<TRoute>;
-    [isRouterRouteSymbol]: true;
 }>;
 
+declare type RouterRoute_2<TRoute extends ResolvedRoute_2 = ResolvedRoute_2> = Readonly<{
+    key: TRoute['key'],
+    matched: TRoute['matched'],
+    matches: TRoute['matches'],
+    query: ResolvedRouteQuery_2,
+    params: Writable_2<TRoute['params']>,
+    update: RouteUpdate_2<TRoute>,
+}>
+
 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;
+        route: Readonly<{
+            key: string;
+            matched: RoutePropsWithMeta;
+            matches: RoutePropsWithMeta[];
+            query: ResolvedRouteQuery;
+            params: Writable<Record<string, unknown>>;
+            update: RouteUpdate<Readonly<{
+            matched: RoutePropsWithMeta_2;
+            matches: RoutePropsWithMeta_2[];
+            key: string;
+            query: ResolvedRouteQuery_2;
+            params: Record<string, unknown>;
+            }>>;
+        }>;
         component: Component;
         rejection: {
             type: "NotFound";
@@ -1008,7 +1685,20 @@ name?: string | undefined;
     }>) | undefined;
 }> & {
     default?: ((props: {
-        route: RouterRoute;
+        route: Readonly<{
+            key: string;
+            matched: RoutePropsWithMeta;
+            matches: RoutePropsWithMeta[];
+            query: ResolvedRouteQuery;
+            params: Writable<Record<string, unknown>>;
+            update: RouteUpdate<Readonly<{
+            matched: RoutePropsWithMeta_2;
+            matches: RoutePropsWithMeta_2[];
+            key: string;
+            query: ResolvedRouteQuery_2;
+            params: Record<string, unknown>;
+            }>>;
+        }>;
         component: Component;
         rejection: {
             type: "NotFound";
@@ -1024,29 +1714,57 @@ name?: string | undefined;
  */
 export declare type Routes = Readonly<Route[]>;
 
+/**
+ * Represents an immutable array of Route instances. Return value of `createRoutes`, expected param for `createRouter`.
+ */
+declare type Routes_2 = Readonly<Route_2[]>
+
 declare type RoutesKey<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
 
+declare type RoutesKey_2<TRoutes extends Routes_2> = string & keyof RoutesMap_2<TRoutes>
+
 declare type RoutesMap<TRoutes extends Routes = []> = {
     [K in TRoutes[number] as NamedNotDisabled<K> extends {
         key: string;
     } ? NamedNotDisabled<K>['key'] : never]: NamedNotDisabled<K>;
 };
 
+declare type RoutesMap_2<TRoutes extends Routes_2 = []> = {
+    [K in TRoutes[number] as NamedNotDisabled_2<K> extends { key: string } ? NamedNotDisabled_2<K>['key']: never]: NamedNotDisabled_2<K>
+}
+
 declare type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = {
     <TKey extends keyof TRoute['params']>(key: TKey, value: TRoute['params'][TKey], options?: RouterPushOptions): Promise<void>;
     (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
 };
 
+declare type RouteUpdate_2<TRoute extends ResolvedRoute_2 = ResolvedRoute_2> = {
+    <TKey extends keyof TRoute['params']>(key: TKey, value: TRoute['params'][TKey], options?: RouterPushOptions_2): Promise<void>,
+    (params: Partial<TRoute['params']>, options?: RouterPushOptions_2): Promise<void>,
+}
+
 declare type StringHasValue<T extends string | undefined> = T extends undefined ? false : '' extends T ? false : true;
 
 declare type ToCallback = (resolve: RegisteredRouter['resolve']) => string;
 
 declare type ToPath<T extends string | Path> = T extends string ? Path<T, {}> : T;
 
+declare type ToPath_2<T extends string | Path_2> = T extends string ? Path_2<T, {}> : T
+
 declare type ToQuery<T extends string | Query | undefined> = T extends string ? Query<T, {}> : T extends undefined ? Query<'', {}> : unknown extends T ? Query<'', {}> : T;
 
+declare type ToQuery_2<T extends string | Query_2 | undefined> = T extends string
+? Query_2<T, {}>
+: T extends undefined
+? Query_2<'', {}>
+: unknown extends T
+? Query_2<'', {}>
+: T
+
 declare type Url = `http://${string}` | `https://${string}` | `/${string}` | '/';
 
+declare type Url_2 = `http://${string}` | `https://${string}` | `/${string}` | '/'
+
 export declare type UseLink = {
     /**
      * ResolvedRoute if matched. Same value as `router.find`
@@ -1085,11 +1803,11 @@ export declare type UseLink = {
  * @returns {UseLink} Reactive context values for as well as navigation methods.
  *
  */
-export declare function useLink<TRouteKey extends string & keyof RegisteredRouteMap>(routeKey: MaybeRefOrGetter<TRouteKey>, ...args: UseLinkArgs<TRouteKey>): UseLink;
+export declare function useLink<TRouteKey extends RegisteredRoutesKey>(routeKey: MaybeRefOrGetter<TRouteKey>, ...args: UseLinkArgs<TRouteKey>): UseLink;
 
 export declare function useLink(url: MaybeRefOrGetter<Url>): UseLink;
 
-declare type UseLinkArgs<TSource extends string & keyof RegisteredRouteMap, TParams = RouteParamsByKey<RegisteredRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<RouterResolveOptions>] : [params: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<RouterResolveOptions>];
+declare type UseLinkArgs<TSource extends RegisteredRoutesKey, TParams = RouteParamsByKey<RegisteredRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<RouterResolveOptions>] : [params: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<RouterResolveOptions>];
 
 /**
  * A composition to access the router's rejection state.
@@ -1152,6 +1870,13 @@ declare type WithComponent = {
     component: Component;
 };
 
+declare type WithComponent_2 = {
+    /**
+     * A Vue component, which can be either synchronous or asynchronous components.
+     */
+    component: Component,
+}
+
 declare type WithComponents = {
     /**
      * Multiple components for named views, which can be either synchronous or asynchronous components.
@@ -1159,6 +1884,15 @@ declare type WithComponents = {
     components: Record<string, Component>;
 };
 
+declare type WithComponents_2 = {
+    /**
+     * Multiple components for named views, which can be either synchronous or asynchronous components.
+     */
+    components: Record<string, Component>,
+}
+
+export declare function withDefault<TParam extends Param>(param: TParam, defaultValue: ExtractParamType<TParam>): ParamWithDefault<TParam>;
+
 /**
  * Defines route hooks that can be applied before entering, updating, or leaving a route, as well as after these events.
  */
@@ -1171,14 +1905,32 @@ declare type WithHooks = {
     onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
 };
 
+/**
+ * Defines route hooks that can be applied before entering, updating, or leaving a route, as well as after these events.
+ */
+declare type WithHooks_2 = {
+    onBeforeRouteEnter?: MaybeArray_2<BeforeRouteHook_2>,
+    onBeforeRouteUpdate?: MaybeArray_2<BeforeRouteHook_2>,
+    onBeforeRouteLeave?: MaybeArray_2<BeforeRouteHook_2>,
+    onAfterRouteEnter?: MaybeArray_2<AfterRouteHook_2>,
+    onAfterRouteUpdate?: MaybeArray_2<AfterRouteHook_2>,
+    onAfterRouteLeave?: MaybeArray_2<AfterRouteHook_2>,
+}
+
 declare type WithOptionalProperties<T> = {
     [P in keyof T]-?: undefined extends T[P] ? P : never;
 }[keyof T];
 
+declare type WithOptionalProperties_2<T> = {
+    [P in keyof T]-?: undefined extends T[P] ? P : never
+}[keyof T]
+
 declare type Writable<T> = {
     -readonly [P in keyof T]: T[P];
 };
 
+declare type Writable_2<T> = { -readonly [P in keyof T]: T[P] }
+
 export { }