@kitbag/router 0.20.6 → 0.20.7

package/dist/kitbag-router.d.ts

@@ -1,1433 +1,2 @@
-import { App } from 'vue';
-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 { FunctionalComponent } from 'vue';
-import { MaybeRefOrGetter } from 'vue';
-import { PrefetchConfig as PrefetchConfig_2 } from '../types';
-import { PublicProps } from 'vue';
-import { Ref } from 'vue';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { UnwrapRef } from 'vue';
-import { VNode } from 'vue';
-
-declare type __VLS_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
-
-declare type __VLS_WithTemplateSlots_2<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
-
-/**
- * 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.
- */
-export declare type AddAfterRouteHook = (hook: AfterRouteHook) => 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.
- */
-export declare type AddBeforeRouteHook = (hook: BeforeRouteHook) => RouteHookRemove;
-
-export declare type AddComponentAfterRouteHook = (hook: AfterRouteHookRegistration) => RouteHookRemove;
-
-export declare type AddComponentBeforeRouteHook = (hook: BeforeRouteHookRegistration) => RouteHookRemove;
-
-export declare type AddGlobalRouteHooks = (hooks: RouteHooks) => void;
-
-export declare type AfterHookContext = {
-    to: ResolvedRoute;
-    from: ResolvedRoute | null;
-};
-
-/**
- * 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.
- */
-export declare type AfterRouteHook = (to: ResolvedRoute, context: AfterRouteHookContext) => MaybePromise<void>;
-
-/**
- * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
- */
-export declare type AfterRouteHookContext = RouteHookContext;
-
-/**
- * Enumerates the lifecycle events for after route hooks.
- */
-export declare type AfterRouteHookLifecycle = 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
-
-export declare type AfterRouteHookRegistration = {
-    lifecycle: 'onAfterRouteEnter' | 'onAfterRouteUpdate' | 'onAfterRouteLeave';
-    hook: AfterRouteHook;
-    depth: number;
-};
-
-/**
- * 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 = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse;
-
-declare type AllPropertiesAreOptional<T> = Record<string, unknown> extends T ? true : IsEmptyObject<OnlyRequiredProperties<T>>;
-
-export declare function arrayOf<const T extends Param[]>(params: T, options?: ArrayOfOptions): ParamGetSet<ExtractParamType<T[number]>[]>;
-
-declare type ArrayOfOptions = {
-    separator?: string;
-};
-
-declare type AsNamedRoute<T extends Route> = IsRouteUnnamed<T> extends true ? never : T;
-
-/**
- * Converts a type to a string if it is a string, otherwise returns never.
- * Specifically useful when using keyof T to produce a union of strings
- * rather than string | number | symbol.
- */
-declare type AsString<T> = T extends string ? T : never;
-
-/**
- * Converts a string to a valid URL.
- * @param value - The string to convert.
- * @returns The valid URL.
- */
-export declare function asUrl(value: string): Url;
-
-export declare type BeforeHookContext = {
-    to: ResolvedRoute;
-    from: ResolvedRoute | null;
-};
-
-/**
- * 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.
- */
-export declare type BeforeRouteHook = (to: ResolvedRoute, context: BeforeRouteHookContext) => MaybePromise<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.
- */
-export declare type BeforeRouteHookContext = RouteHookContext & {
-    abort: CallbackContextAbort;
-};
-
-/**
- * Enumerates the lifecycle events for before route hooks.
- */
-export declare type BeforeRouteHookLifecycle = 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
-
-export declare type BeforeRouteHookRegistration = {
-    lifecycle: 'onBeforeRouteEnter' | 'onBeforeRouteUpdate' | 'onBeforeRouteLeave';
-    hook: BeforeRouteHook;
-    depth: number;
-};
-
-/**
- * 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 = CallbackSuccessResponse | CallbackPushResponse | CallbackRejectResponse | CallbackAbortResponse;
-
-declare type BuiltInRejectionType = 'NotFound';
-
-/**
- * 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 WithParams, TChild extends WithParams> = CombinePath<TParent, TChild>;
-
-declare type CombineMeta<TParent extends Record<string, unknown>, TChild extends Record<string, unknown>> = TParent & TChild;
-
-declare type CombinePath<TParent extends WithParams, TChild extends WithParams> = ToWithParams<TParent> extends {
-    value: infer TParentPath extends string;
-    params: infer TParentParams extends Record<string, unknown>;
-} ? ToWithParams<TChild> extends {
-    value: infer TChildPath extends string;
-    params: infer TChildParams extends Record<string, unknown>;
-} ? TParentParams & TChildParams extends Record<string, Param | undefined> ? WithParams<CombinePathString<TParentPath, TChildPath>, TParentParams & TChildParams> : WithParams<CombinePathString<TParentPath, TChildPath>, {}> : WithParams<'', {}> : WithParams<'', {}>;
-
-declare type CombinePathString<TParent extends string, TChild extends string> = `${TParent}${TChild}`;
-
-declare type CombineQuery<TParent extends WithParams, TChild extends WithParams> = ToWithParams<TParent> extends {
-    value: infer TParentQuery extends string;
-    params: infer TParentParams extends Record<string, unknown>;
-} ? ToWithParams<TChild> extends {
-    value: infer TChildQuery extends string;
-    params: infer TChildParams extends Record<string, unknown>;
-} ? TParentParams & TChildParams extends Record<string, Param | undefined> ? WithParams<CombineQueryString<TParentQuery, TChildQuery>, TParentParams & TChildParams> : WithParams<CombineQueryString<TParentQuery, TChildQuery>, {}> : WithParams<'', {}> : WithParams<'', {}>;
-
-declare type CombineQueryString<TParent extends string | undefined, TChild extends string | undefined> = StringHasValue<TParent> extends true ? StringHasValue<TChild> extends true ? `${TParent}&${TChild}` : TParent : TChild;
-
-declare type CombineState<TParent extends Record<string, Param>, TChild extends Record<string, Param>> = TParent & TChild;
-
-declare type ComponentProps<TComponent extends Component> = TComponent extends Constructor ? InstanceType<TComponent>['$props'] : TComponent extends AsyncComponentLoader<infer T extends Component> ? ComponentProps<T> : TComponent extends FunctionalComponent<infer T> ? T : {};
-
-declare type ComponentPropsAreOptional<TComponent extends Component> = Partial<ComponentProps<TComponent>> extends ComponentProps<TComponent> ? true : false;
-
-declare type Constructor = new (...args: any) => any;
-
-/**
- * The Route properties originally provided to `createRoute`. The only change is normalizing meta to always default to an empty object.
- */
-export declare type CreatedRouteOptions = Omit<CreateRouteOptions, 'props'> & WithHooks & {
-    id: string;
-    props?: unknown;
-};
-
-export declare function createExternalRoute<const TOptions extends CreateRouteOptions & WithHost & WithoutParent>(options: TOptions): ToRoute<TOptions, undefined>;
-
-export declare function createExternalRoute<const TOptions extends CreateRouteOptions & WithoutHost & WithParent>(options: TOptions): ToRoute<TOptions, undefined>;
-
-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: NoInfer<ExtractParamType<TParam>>): ParamWithDefault<TParam>;
-
-export declare function createRoute<const TOptions extends CreateRouteOptions, const TProps extends CreateRouteProps<TOptions>>(options: TOptions, ...args: CreateRouteWithProps<TOptions, TProps>): ToRoute<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>;
-
-export declare type CreateRouteOptions<TName extends string | undefined = string | undefined, TPath extends string | WithParams | undefined = string | WithParams | undefined, TQuery extends string | WithParams | undefined = string | WithParams | undefined, THash extends string | WithParams | undefined = string | WithParams | undefined, TMeta extends RouteMeta = RouteMeta> = WithHooks & {
-    /**
-     * Name for route, used to create route keys and in navigation.
-     */
-    name?: TName;
-    /**
-     * Path part of URL.
-     */
-    path?: TPath;
-    /**
-     * Query (aka search) part of URL.
-     */
-    query?: TQuery;
-    /**
-     * Hash part of URL.
-     */
-    hash?: THash;
-    /**
-     * Represents additional metadata associated with a route, customizable via declaration merging.
-     */
-    meta?: TMeta;
-    /**
-     * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
-     */
-    prefetch?: PrefetchConfig;
-    /**
-     * Type params for additional data intended to be stored in history state, all keys will be optional unless a default is provided.
-     */
-    state?: Record<string, Param>;
-    /**
-     * An optional parent route to nest this route under.
-     */
-    parent?: Route;
-    /**
-     * An optional component to render when this route is matched.
-     *
-     * @default RouterView
-     */
-    component?: Component;
-    /**
-     * An object of named components to render using named views
-     */
-    components?: Record<string, Component>;
-    /**
-     * Props have been moved to the second argument of `createRoute`. This property can no longer be used.
-     *
-     * @deprecated
-     */
-    props?: never;
-};
-
-declare type CreateRouteProps<TOptions extends CreateRouteOptions = CreateRouteOptions> = TOptions['component'] extends Component ? PropsGetter<TOptions, TOptions['component']> : TOptions['components'] extends Record<string, Component> ? RoutePropsRecord<TOptions, TOptions['components']> : PropsGetter<TOptions, typeof RouterView>;
-
-/**
- * Creates a router instance for a Vue application, equipped with methods for route handling, lifecycle hooks, and state management.
- *
- * @param routes - {@link Routes} An array of route definitions specifying the configuration of routes in the application.
- * Use createRoute method to create the route definitions.
- * @param options - {@link RouterOptions} for the router, including history mode and initial URL settings.
- * @returns Router instance
- *
- * @example
- * ```ts
- * import { createRoute, createRouter } from '@kitbag/router'
- *
- * const Home = { template: '<div>Home</div>' }
- * const About = { template: '<div>About</div>' }
- *
- * export const routes = [
- *   createRoute({ name: 'home', path: '/', component: Home }),
- *   createRoute({ name: 'path', path: '/about', component: About }),
- * ] as const
- *
- * const router = createRouter(routes)
- * ```
- */
-export declare function createRouter<const TRoutes extends Routes, const TOptions extends RouterOptions, const TPlugin extends RouterPlugin = EmptyRouterPlugin>(routes: TRoutes, options?: TOptions, plugins?: TPlugin[]): Router<TRoutes, TOptions, TPlugin>;
-
-export declare function createRouter<const TRoutes extends Routes, const TOptions extends RouterOptions, const TPlugin extends RouterPlugin = EmptyRouterPlugin>(routes: TRoutes[], options?: TOptions, plugins?: TPlugin[]): Router<TRoutes, TOptions, TPlugin>;
-
-export declare function createRouterPlugin<TRoutes extends Routes = [], TRejections extends Record<string, Component> = {}>(plugin: Partial<RouterPlugin<TRoutes, TRejections>>): RouterPlugin<TRoutes, TRejections>;
-
-declare type CreateRouteWithProps<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions>> = CreateRouteProps<TOptions> extends PropsGetter<TOptions> ? Partial<ReturnType<CreateRouteProps<TOptions>>> extends ReturnType<CreateRouteProps<TOptions>> ? [props?: TProps] : [props: TProps] : Partial<CreateRouteProps<TOptions>> extends CreateRouteProps<TOptions> ? [props?: TProps] : [props: TProps];
-
-/**
- * An error thrown when duplicate parameters are detected in a route.
- * Param names must be unique. This includes params defined in a path
- * parent and params defined in the query.
- * @group Errors
- */
-export declare class DuplicateParamsError extends Error {
-    /**
-     * Constructs a new DuplicateParamsError instance with a message indicating the problematic parameter.
-     * @param paramName - The name of the parameter that was duplicated.
-     */
-    constructor(paramName: string);
-}
-
-declare type EmptyRouterPlugin = {
-    routes: [];
-    rejections: {};
-};
-
-/**
- * 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<TParam extends PropertyKey> = TParam extends string ? TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam : never;
-
-/**
- * Extracts the actual type from a parameter type, handling getters and setters.
- * @template TParam - The parameter type.
- * @returns The extracted type, or 'string' as a fallback.
- */
-declare type ExtractParamType<TParam extends Param> = TParam extends ParamGetSet<infer Type> ? Type : TParam extends ParamGetter ? ReturnType<TParam> : TParam extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TParam> : TParam extends LiteralParam ? TParam : string;
-
-declare type ExtractParamTypes<TParams extends Record<string, Param>> = Identity<MakeOptional<{
-    [K in keyof TParams as ExtractParamName<K>]: ExtractParamType<TParams[K]>;
-}>>;
-
-/**
- * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
- * @template TParams - The record of parameter types, possibly including undefined.
- * @returns A new type with the appropriate properties marked as optional.
- */
-declare type ExtractParamTypesReading<TWithParams extends WithParams> = {
-    [K in keyof TWithParams['params']]: TWithParams['value'] extends `${string}${ParamStart}?${K & string}${ParamEnd}${string}` ? TWithParams['params'][K] extends Required<ParamGetSet> ? ExtractParamType<TWithParams['params'][K]> : ExtractParamType<TWithParams['params'][K]> | undefined : ExtractParamType<TWithParams['params'][K]>;
-};
-
-/**
- * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
- * Differs from ExtractParamTypesReading in that optional params with defaults will remain optional.
- * @template TParams - The record of parameter types, possibly including undefined.
- * @returns A new type with the appropriate properties marked as optional.
- */
-declare type ExtractParamTypesWriting<TWithParams extends WithParams> = {
-    [K in keyof TWithParams['params']]: TWithParams['value'] extends `${string}${ParamStart}?${K & string}${ParamEnd}${string}` ? ExtractParamType<TWithParams['params'][K]> | undefined : ExtractParamType<TWithParams['params'][K]>;
-};
-
-/**
- * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
- * @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 ExtractRouteParamTypesReading<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesReading<TRoute['host']> & ExtractParamTypesReading<TRoute['path']> & ExtractParamTypesReading<TRoute['query']> & ExtractParamTypesReading<TRoute['hash']>>>;
-
-/**
- * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
- * Differs from ExtractRouteParamTypesReading in that optional params with defaults will remain optional.
- * @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 ExtractRouteParamTypesWriting<TRoute extends Route> = Identity<MakeOptional<ExtractParamTypesWriting<TRoute['host']> & ExtractParamTypesWriting<TRoute['path']> & ExtractParamTypesWriting<TRoute['query']> & ExtractParamTypesWriting<TRoute['hash']>>>;
-
-declare type ExtractRouteStateParamsAsOptional<TParams extends Record<string, Param>> = {
-    [K in keyof TParams]: ExtractParamType<TParams[K]> | undefined;
-};
-
-declare type ExtractStateParams<TRoute> = TRoute extends {
-    state: infer TState extends Record<string, Param>;
-} ? ExtractParamTypes<TState> : Record<string, unknown>;
-
-declare type GetParentPropsReturnType<TParent extends Route | undefined = Route | undefined> = TParent extends Route ? TParent['matched']['props'] extends PropsGetter ? ReturnType<TParent['matched']['props']> : TParent['matched']['props'] extends Record<string, PropsGetter> ? {
-    [K in keyof TParent['matched']['props']]: ReturnType<TParent['matched']['props'][K]>;
-} : undefined : undefined;
-
-/**
- * @deprecated use `withParams` instead
- * @hidden we don't want to expose this in the api docs
- */
-export declare const host: typeof withParams;
-
-declare type Identity<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;
-
-/**
- * A type guard for determining if a value is a valid RouterRoute.
- * @param route - The value to check.
- * @returns `true` if the value is a valid RouterRoute, otherwise `false`.
- * @group Type Guards
- */
-export declare function isRoute(route: unknown): route is RouterRoute;
-
-/**
- * A type guard for determining if a value is a valid RouterRoute with an exact match.
- * @param route - The value to check.
- * @param routeName - The expected route name.
- * @returns `true` if the value is a valid RouterRoute with an exact match, otherwise `false`.
- * @group Type Guards
- */
-export declare function isRoute<TRoute extends RouterRoute, TRouteName extends TRoute['name']>(route: TRoute, routeName: TRouteName, options: IsRouteOptions & {
-    exact: true;
-}): route is TRoute & {
-    name: TRouteName;
-};
-
-/**
- * A type guard for determining if a value is a valid RouterRoute with a partial match.
- * @param route - The value to check.
- * @param routeName - The expected route name.
- * @returns `true` if the value is a valid RouterRoute with a partial match, otherwise `false`.
- * @group Type Guards
- */
-export declare function isRoute<TRoute extends RouterRoute, TRouteName extends TRoute['name']>(route: TRoute, routeName: TRouteName, options?: IsRouteOptions): route is RouteWithMatch<TRoute, TRouteName>;
-
-/**
- * A type guard for determining if a value is a valid RegisteredRouterRoute with an exact match.
- * @param route - The value to check.
- * @param routeName - The expected route name.
- * @returns `true` if the value is a valid RegisteredRouterRoute with an exact match, otherwise `false`.
- * @group Type Guards
- */
-export declare function isRoute<TRouteName extends RegisteredRoutesName>(route: unknown, routeName: TRouteName, options: IsRouteOptions & {
-    exact: true;
-}): route is RegisteredRouterRoute & {
-    name: TRouteName;
-};
-
-/**
- * A type guard for determining if a value is a valid RegisteredRouterRoute with a partial match.
- * @param route - The value to check.
- * @param routeName - The expected route name.
- * @returns `true` if the value is a valid RegisteredRouterRoute with a partial match, otherwise `false`.
- * @group Type Guards
- */
-export declare function isRoute<TRouteName extends RegisteredRoutesName>(route: unknown, routeName: TRouteName, options?: IsRouteOptions): route is RouteWithMatch<RegisteredRouterRoute, TRouteName>;
-
-/**
- * A type guard for determining if a value is a valid RouterRoute.
- * @param route - The value to check.
- * @param routeName - The expected route name.
- * @returns `true` if the value is a valid RouterRoute, otherwise `false`.
- * @group Type Guards
- */
-export declare function isRoute(route: unknown, routeName?: string, options?: IsRouteOptions): boolean;
-
-declare type IsRouteOptions = {
-    exact?: boolean;
-};
-
-declare type IsRouteUnnamed<T extends Route> = StringHasValue<T['name']> extends true ? false : true;
-
-/**
- * A type guard for determining if a value is a valid URL.
- * @param value - The value to check.
- * @returns `true` if the value is a valid URL, otherwise `false`.
- * @group Type Guards
- */
-export declare function isUrl(value: unknown): value is Url;
-
-/**
- * Extracts the keys of a union type.
- */
-declare type KeysOfUnion<T> = T extends T ? keyof T : never;
-
-declare type LastInArray<T, TFallback = never> = T extends [...any[], infer Last] ? Last : TFallback;
-
-export declare type LiteralParam = string | number | boolean;
-
-declare type MakeOptional<T> = {
-    [P in WithOptionalProperties<T>]?: T[P];
-} & {
-    [P in Exclude<keyof T, WithOptionalProperties<T>>]: T[P];
-};
-
-declare type MaybeArray<T> = T | T[];
-
-declare type MaybePromise<T> = T | Promise<T>;
-
-/**
- * An error thrown when a parent's meta has the same key as a child and the types are not compatible.
- * A child's meta can override properties of the parent, however the types must match!
- * @group Errors
- */
-export declare class MetaPropertyConflict extends Error {
-    constructor(property?: string);
-}
-
-/**
- * Registers a hook that is called after a route has been left. Must be called during setup.
- * This can be used for cleanup actions after the component is no longer active, ensuring proper resource management.
- *
- * @param AfterRouteHook - The hook callback function
- * @returns {RouteHookRemove} A function that removes the added hook.
- * @group Hooks
- */
-export declare const onAfterRouteLeave: AddAfterRouteHook;
-
-/**
- * Registers a hook that is called after a route has been updated. Must be called during setup.
- * This is ideal for responding to updates within the same route, such as parameter changes, without full component reloads.
- *
- * @param AfterRouteHook - The hook callback function
- * @returns {RouteHookRemove} A function that removes the added hook.
- * @group Hooks
- */
-export declare const onAfterRouteUpdate: AddAfterRouteHook;
-
-/**
- * Registers a hook that is called before a route is left. Must be called from setup.
- * This is useful for performing actions or cleanups before navigating away from a route component.
- *
- * @param BeforeRouteHook - The hook callback function
- * @returns {RouteHookRemove} A function that removes the added hook.
- * @group Hooks
- */
-export declare const onBeforeRouteLeave: AddBeforeRouteHook;
-
-/**
- * Registers a hook that is called before a route is updated. Must be called from setup.
- * This is particularly useful for handling changes in route parameters or query while staying within the same component.
- *
- * @param BeforeRouteHook - The hook callback function
- * @returns {RouteHookRemove} A function that removes the added hook.
- * @group Hooks
- */
-export declare const onBeforeRouteUpdate: AddBeforeRouteHook;
-
-declare type OnlyRequiredProperties<T> = {
-    [K in keyof T as Extract<T[K], undefined> extends never ? K : never]: T[K];
-};
-
-export declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON | ZodSchemaLike | ValibotSchemaLike | LiteralParam;
-
-declare type ParamEnd = typeof paramEnd;
-
-declare const paramEnd = "]";
-
-export declare type ParamExtras = {
-    invalid: (message?: string) => never;
-};
-
-export declare type ParamGetSet<T = any> = {
-    get: ParamGetter<T>;
-    set: ParamSetter<T>;
-    defaultValue?: T;
-};
-
-export declare type ParamGetter<T = any> = (value: string, extras: ParamExtras) => T;
-
-export declare type ParamSetter<T = any> = (value: T, extras: ParamExtras) => string;
-
-declare type ParamStart = typeof paramStart;
-
-declare const paramStart = "[";
-
-declare type ParamWithDefault<TParam extends Param = Param> = Required<ParamGetSet<ExtractParamType<TParam>>>;
-
-/**
- * @deprecated use `withParams` instead
- * @hidden we don't want to expose this in the api docs
- */
-export declare const path: typeof withParams;
-
-/**
- * Determines what assets are prefetched. A boolean enables or disables all prefetching.
- */
-export declare type PrefetchConfig = boolean | PrefetchStrategy | PrefetchConfigOptions;
-
-declare type PrefetchConfigOptions = {
-    /**
-     * When true any component that is wrapped in vue's defineAsyncComponent will be prefetched
-     * @default 'eager'
-     */
-    components?: boolean | PrefetchStrategy;
-    /**
-     * When true any props for routes will be prefetched
-     * @default false
-     */
-    props?: boolean | PrefetchStrategy;
-};
-
-/**
- * Determines when assets are prefetched.
- * eager: Fetched immediately
- * lazy: Fetched when visible
- */
-export declare type PrefetchStrategy = 'eager' | 'lazy' | 'intent';
-
-/**
- * Context provided to props callback functions
- */
-export declare type PropsCallbackContext<TParent extends Route | undefined = Route | undefined> = {
-    push: CallbackContext['push'];
-    replace: CallbackContext['replace'];
-    reject: CallbackContext['reject'];
-    parent: PropsCallbackParent<TParent>;
-};
-
-declare type PropsCallbackParent<TParent extends Route | undefined = Route | undefined> = Route | undefined extends TParent ? undefined | {
-    name: string;
-    props: unknown;
-} : TParent extends Route ? {
-    name: TParent['name'];
-    props: GetParentPropsReturnType<TParent>;
-} : undefined;
-
-declare type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions['parent']>) => MaybePromise<ComponentProps<TComponent>>;
-
-/**
- * @deprecated use `withParams` instead
- * @hidden we don't want to expose this in the api docs
- */
-export declare const query: typeof withParams;
-
-export declare type QuerySource = ConstructorParameters<typeof URLSearchParams>[0];
-
-/**
- * Represents the state of currently registered router, and route meta. 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
- *     routeMeta: { public?: boolean }
- *   }
- * }
- * ```
- */
-export declare interface Register {
-}
-
-/**
- * Represents the possible Rejections registered within {@link Register}
- */
-export declare type RegisteredRejectionType<T = Register> = T extends {
-    router: Router<any, infer TOptions extends RouterOptions>;
-} ? keyof TOptions['rejections'] | BuiltInRejectionType : BuiltInRejectionType;
-
-/**
- * Represents the a map of all possible route names with corresponding Route registered within {@link Register}
- */
-export declare type RegisteredRouteMap = RoutesMap<RegisteredRoutes>;
-
-/**
- * Represents the Router property within {@link Register}
- */
-export declare type RegisteredRouter<T = Register> = T extends {
-    router: infer TRouter;
-} ? TRouter : Router;
-
-/**
- * Represents the type for router `push`, with types for routes registered within {@link Register}
- */
-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}
- */
-export declare type RegisteredRouterReplace = RouterReplace<RegisteredRoutes>;
-
-/**
- * Represents the Router property within {@link Register}
- */
-export declare type RegisteredRouterRoute = RegisteredRouter['route'];
-
-/**
- * Represents the Router routes property within {@link Register}
- */
-export declare type RegisteredRoutes<T = Register> = T extends {
-    router: Router<infer TRoutes extends Routes>;
-} ? TRoutes : Route[];
-
-/**
- * Represents the union of all possible route names registered within {@link Register}
- */
-export declare type RegisteredRoutesName = RoutesName<RegisteredRoutes>;
-
-/**
- * Represents a route that the router has matched to current browser location.
- * @template TRoute - Underlying Route that has been resolved.
- */
-export declare type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
-    /**
-     * Unique identifier for the route, generated by router.
-     */
-    id: TRoute['id'];
-    /**
-     * 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. Name is used for routing and for matching.
-     */
-    name: TRoute['name'];
-    /**
-     * Accessor for query string values from user in the current browser location.
-     */
-    query: URLSearchParams;
-    /**
-     * Hash value of the route.
-     */
-    hash: string;
-    /**
-     * Key value pair for route params, values will be the user provided value from current browser location.
-     */
-    params: ExtractRouteParamTypesReading<TRoute>;
-    /**
-     * Type for additional data intended to be stored in history state.
-     */
-    state: ExtractRouteStateParamsAsOptional<TRoute['state']>;
-    /**
-     * String value of the resolved URL.
-     */
-    href: Url;
-}>;
-
-/**
- * Represents the structure of a route within the application. Return value of `createRoute`
- * @template TName - Represents the unique name 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.
- */
-export declare type Route<TName extends string = string, THost extends WithParams = WithParams, TPath extends WithParams = WithParams, TQuery extends WithParams = WithParams, THash extends WithParams = WithParams, TMeta extends RouteMeta = RouteMeta, TState extends Record<string, Param> = Record<string, Param>, TMatches extends CreatedRouteOptions[] = CreatedRouteOptions[]> = {
-    /**
-     * Unique identifier for the route, generated by router.
-     */
-    id: string;
-    /**
-     * The specific route properties that were matched in the current route.
-     */
-    matched: LastInArray<TMatches, CreatedRouteOptions>;
-    /**
-     * 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: TMatches;
-    /**
-     * Identifier for the route as defined by user. Name must be unique among named routes. Name is used for routing and for matching.
-     */
-    name: TName;
-    /**
-     * Represents the host for this route. Used for external routes.
-     */
-    host: THost;
-    /**
-     * Represents the structured path of the route, including path params.
-     */
-    path: TPath;
-    /**
-     * Represents the structured query of the route, including query params.
-     */
-    query: TQuery;
-    /**
-     * Represents the hash of the route.
-     */
-    hash: THash;
-    /**
-     * Represents additional metadata associated with a route, combined with any parents.
-     */
-    meta: TMeta;
-    /**
-     * Represents the schema of the route state, combined with any parents.
-     */
-    state: TState;
-    /**
-     * Determines what assets are prefetched when router-link is rendered for this route. Overrides router level prefetch.
-     */
-    prefetch?: PrefetchConfig;
-    /* Excluded from this release type: depth */
-};
-
-declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesName<TRoutes>> = RoutesMap<TRoutes>[TKey];
-
-/**
- * Generic type representing a route hook, which can be either before or after a route change.
- */
-export declare type RouteHook = BeforeRouteHook | AfterRouteHook;
-
-export declare type RouteHookAfterRunner = (context: AfterHookContext) => Promise<AfterRouteHookResponse>;
-
-export declare type RouteHookBeforeRunner = (context: BeforeHookContext) => Promise<BeforeRouteHookResponse>;
-
-/**
- * Context provided to route hooks, containing context of previous route and functions for triggering rejections and push/replace to another route.
- */
-declare type RouteHookContext = {
-    from: ResolvedRoute | null;
-    reject: CallbackContext['reject'];
-    push: CallbackContext['push'];
-    replace: CallbackContext['replace'];
-};
-
-/**
- * Union type for all route hook lifecycle events.
- */
-export declare type RouteHookLifecycle = BeforeRouteHookLifecycle | AfterRouteHookLifecycle;
-
-/**
- * A function to remove a previously registered route hook.
- */
-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 = BeforeRouteHookResponse | AfterRouteHookResponse;
-
-declare class RouteHooks {
-    onBeforeRouteEnter: Set<BeforeRouteHook>;
-    onBeforeRouteUpdate: Set<BeforeRouteHook>;
-    onBeforeRouteLeave: Set<BeforeRouteHook>;
-    onAfterRouteEnter: Set<AfterRouteHook>;
-    onAfterRouteUpdate: Set<AfterRouteHook>;
-    onAfterRouteLeave: Set<AfterRouteHook>;
-}
-
-export declare type RouteHookTiming = 'global' | 'component';
-
-/**
- * Represents additional metadata associated with a route, customizable via declaration merging.
- */
-export declare type RouteMeta<T = Register> = T extends {
-    routeMeta: infer RouteMeta extends Record<string, unknown>;
-} ? RouteMeta : Record<string, unknown>;
-
-declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = RouteGetByKey<TRoutes, TKey> extends Route ? ExtractRouteParamTypesWriting<RouteGetByKey<TRoutes, TKey>> : Record<string, unknown>;
-
-declare type RoutePropsRecord<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponents extends Record<string, Component> = Record<string, Component>> = {
-    [K in keyof TComponents as ComponentPropsAreOptional<TComponents[K]> extends true ? K : never]?: PropsGetter<TOptions, TComponents[K]>;
-} & {
-    [K in keyof TComponents as ComponentPropsAreOptional<TComponents[K]> extends false ? K : never]: PropsGetter<TOptions, TComponents[K]>;
-};
-
-export declare type Router<TRoutes extends Routes = any, TOptions extends RouterOptions = any, TPlugin extends RouterPlugin = any> = {
-    /**
-     * Installs the router into a Vue application instance.
-     * @param app The Vue application instance to install the router into
-     */
-    install: (app: App) => void;
-    /**
-     * Manages the current route state.
-     */
-    route: RouterRoutes<TRoutes> | RouterRoutes<TPlugin['routes']>;
-    /**
-     * Creates a ResolvedRoute record for a given route name and params.
-     */
-    resolve: RouterResolve<TRoutes | TPlugin['routes']>;
-    /**
-     * Creates a ResolvedRoute record for a given URL.
-     */
-    find: (url: string, options?: RouterResolveOptions) => ResolvedRoute | undefined;
-    /**
-     * Navigates to a specified path or route object in the history stack, adding a new entry.
-     */
-    push: RouterPush<TRoutes | TPlugin['routes']>;
-    /**
-     * Replaces the current entry in the history stack with a new one.
-     */
-    replace: RouterReplace<TRoutes | TPlugin['routes']>;
-    /**
-     * Handles route rejection based on a specified rejection type.
-     */
-    reject: RouterReject<keyof TOptions['rejections'] | KeysOfUnion<TPlugin['rejections']>>;
-    /**
-     * 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;
-    /**
-     * Registers a hook to be called before a route is left.
-     */
-    onBeforeRouteLeave: AddBeforeRouteHook;
-    /**
-     * Registers a hook to be called before a route is updated.
-     */
-    onBeforeRouteUpdate: AddBeforeRouteHook;
-    /**
-     * Registers a hook to be called after a route is entered.
-     */
-    onAfterRouteEnter: AddAfterRouteHook;
-    /**
-     * Registers a hook to be called after a route is left.
-     */
-    onAfterRouteLeave: AddAfterRouteHook;
-    /**
-     * Registers a hook to be called after a route is updated.
-     */
-    onAfterRouteUpdate: AddAfterRouteHook;
-    /**
-     * Given a URL, returns true if host does not match host stored on router instance
-     */
-    isExternal: (url: string) => boolean;
-    /**
-     * Determines what assets are prefetched.
-     */
-    prefetch?: PrefetchConfig;
-    /**
-     * Initializes the router based on the initial route. Automatically called when the router is installed. Calling this more than once has no effect.
-     */
-    start: () => Promise<void>;
-    /**
-     * Returns true if the router has been started.
-     */
-    started: Ref<boolean>;
-    /**
-     * Stops the router and teardown any listeners.
-     */
-    stop: () => void;
-};
-
-declare type RouterHistoryMode = 'auto' | 'browser' | 'memory' | 'hash';
-
-/**
- * @hidden we don't want the criptic component types showing up in the api docs
- */
-export declare const RouterLink: __VLS_WithTemplateSlots_2<DefineComponent<RouterLinkProps & RouterPushOptions, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<RouterLinkProps & RouterPushOptions> & Readonly<{}>, {
-prefetch: PrefetchConfig_2;
-}, {}, {}, {}, string, ComponentProvideOptions, false, {
-element: HTMLAnchorElement;
-}, HTMLAnchorElement>, Readonly<{
-    default?: (props: {
-        route: ResolvedRoute | undefined;
-        isMatch: boolean;
-        isExactMatch: boolean;
-        isActive: boolean;
-        isExactActive: boolean;
-        isExternal: boolean;
-    }) => unknown;
-}> & {
-    default?: (props: {
-        route: ResolvedRoute | undefined;
-        isMatch: boolean;
-        isExactMatch: boolean;
-        isActive: boolean;
-        isExactActive: boolean;
-        isExternal: boolean;
-    }) => unknown;
-}>;
-
-export declare type RouterLinkProps = {
-    /**
-     * The url string to navigate to or a callback that returns a url string
-     */
-    to: Url | ResolvedRoute | ToCallback;
-    /**
-     * Determines what assets are prefetched when router-link is rendered for this route. Overrides route level prefetch.
-     */
-    prefetch?: PrefetchConfig;
-};
-
-/**
- * An error thrown when an attempt is made to use routing functionality before the router has been installed.
- * @group Errors
- */
-export declare class RouterNotInstalledError extends Error {
-    constructor();
-}
-
-/**
- * Options to initialize a {@link Router} instance.
- */
-export declare type RouterOptions = WithHooks & {
-    /**
-     * Initial URL for the router to use. Required if using Node environment. Defaults to window.location when using browser.
-     *
-     * @default window.location.toString()
-     */
-    initialUrl?: string;
-    /**
-     * Specifies the history mode for the router, such as "browser", "memory", or "hash".
-     *
-     * @default "auto"
-     */
-    historyMode?: RouterHistoryMode;
-    /**
-     * Base path to be prepended to any URL. Can be used for Vue applications that run in nested folder for domain.
-     * For example having `base` of `/foo` would assume all routes should start with `your.domain.com/foo`.
-     */
-    base?: string;
-    /**
-     * Determines what assets are prefetched when router-link is rendered for a specific route
-     */
-    prefetch?: PrefetchConfig;
-    /**
-     * Components assigned to each type of rejection your router supports.
-     */
-    rejections?: Partial<Record<string, Component>>;
-};
-
-export declare type RouterPlugin<TRoutes extends Routes = Routes, TRejections extends Record<string, Component> = Record<string, Component>> = {
-    routes: TRoutes;
-    rejections: TRejections;
-    onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
-    onAfterRouteEnter?: MaybeArray<AfterRouteHook>;
-    onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
-    onAfterRouteUpdate?: MaybeArray<AfterRouteHook>;
-    onBeforeRouteLeave?: MaybeArray<BeforeRouteHook>;
-    onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
-};
-
-declare type RouterPush<TRoutes extends Routes = any> = {
-    <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterPushArgs<TRoutes, TSource>): Promise<void>;
-    (route: ResolvedRoute, options?: RouterPushOptions): Promise<void>;
-    (url: Url, options?: RouterPushOptions): Promise<void>;
-};
-
-declare type RouterPushArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByName<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterPushOptions<RouteStateByName<TRoutes, TSource>>];
-
-export declare type RouterPushOptions<TState = unknown> = {
-    /**
-     * The query string to add to the url.
-     */
-    query?: QuerySource;
-    /**
-     * The hash to append to the url.
-     */
-    hash?: string;
-    /**
-     * Whether to replace the current history entry.
-     */
-    replace?: boolean;
-    /**
-     * State values to pass to the route.
-     */
-    state?: Partial<TState>;
-};
-
-declare type RouterReject<TRejectionType extends PropertyKey> = (type: AsString<TRejectionType> | BuiltInRejectionType) => void;
-
-declare type RouterRejection = Ref<null | {
-    type: string;
-    component: Component;
-}>;
-
-declare type RouterReplace<TRoutes extends Routes> = {
-    <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterReplaceArgs<TRoutes, TSource>): Promise<void>;
-    (route: ResolvedRoute, options?: RouterReplaceOptions): Promise<void>;
-    (url: Url, options?: RouterReplaceOptions): Promise<void>;
-};
-
-declare type RouterReplaceArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterReplaceOptions<RouteStateByName<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterReplaceOptions<RouteStateByName<TRoutes, TSource>>];
-
-declare type RouterReplaceOptions<TState = unknown> = {
-    query?: QuerySource;
-    hash?: string;
-    state?: Partial<TState>;
-};
-
-declare type RouterResolve<TRoutes extends Routes> = <TSource extends RoutesName<TRoutes>>(name: TSource, ...args: RouterResolveArgs<TRoutes, TSource>) => ResolvedRoute;
-
-declare type RouterResolveArgs<TRoutes extends Routes, TSource extends RoutesName<TRoutes>> = AllPropertiesAreOptional<RouteParamsByKey<TRoutes, TSource>> extends true ? [params?: RouteParamsByKey<TRoutes, TSource>, options?: RouterResolveOptions<RouteStateByName<TRoutes, TSource>>] : [params: RouteParamsByKey<TRoutes, TSource>, options?: RouterResolveOptions<RouteStateByName<TRoutes, TSource>>];
-
-declare type RouterResolveOptions<TState = unknown> = {
-    query?: QuerySource;
-    hash?: string;
-    state?: Partial<TState>;
-};
-
-export 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>;
-    readonly href: TRoute['href'];
-    params: TRoute['params'];
-    state: TRoute['state'];
-    get query(): URLSearchParams;
-    set query(value: QuerySource);
-};
-
-/**
- * This type is the same as `RouterRoute<ResolvedRoute<TRoutes[number]>>` while remaining distributive
- */
-export declare type RouterRoutes<TRoutes extends Routes> = {
-    [K in keyof TRoutes]: RouterRoute<ResolvedRoute<TRoutes[K]>>;
-}[number];
-
-/**
- * @hidden we don't want the criptic component types showing up in the api docs
- */
-export declare const RouterView: __VLS_WithTemplateSlots<DefineComponent<    {
-name?: string;
-}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
-name?: string;
-}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>, Readonly<{
-    default?: (props: {
-        route: RouterRoute;
-        component: Component;
-        rejection: UnwrapRef<RouterRejection>;
-    }) => VNode;
-}> & {
-    default?: (props: {
-        route: RouterRoute;
-        component: Component;
-        rejection: UnwrapRef<RouterRejection>;
-    }) => VNode;
-}>;
-
-/**
- * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
- */
-export declare type Routes = readonly Route[];
-
-declare type RoutesMap<TRoutes extends Routes = []> = {
-    [K in TRoutes[number] as AsNamedRoute<K>['name']]: AsNamedRoute<K>;
-};
-
-declare type RoutesName<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
-
-declare type RouteStateByName<TRoutes extends Routes, TName extends string> = ExtractStateParams<RouteGetByKey<TRoutes, TName>>;
-
-declare type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = ResolvedRoute extends TRoute ? {
-    (paramName: string, paramValue: unknown, options?: RouterPushOptions): Promise<void>;
-    (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
-} : {
-    <TParamName extends keyof TRoute['params']>(paramName: TParamName, paramValue: TRoute['params'][TParamName], options?: RouterPushOptions): Promise<void>;
-    (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
-};
-
-declare type RouteWithMatch<TRoute extends RouterRoute, TRouteName extends TRoute['name']> = TRoute extends RouterRoute ? TRouteName extends TRoute['matches'][number]['name'] ? TRoute : never : never;
-
-declare type StringHasValue<T> = string extends T ? true : '' extends T ? false : T extends string ? true : false;
-
-export declare type ToCallback = (resolve: RegisteredRouter['resolve']) => ResolvedRoute | Url | undefined;
-
-declare type ToMatch<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = Omit<TOptions, 'props'> & {
-    id: string;
-    props: TProps;
-};
-
-declare type ToMatches<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = TOptions extends {
-    parent: infer TParent extends Route;
-} ? [...TParent['matches'], ToMatch<TOptions, TProps>] : [ToMatch<TOptions, TProps>];
-
-declare type ToMeta<TMeta extends RouteMeta | undefined> = TMeta extends undefined ? {} : unknown extends TMeta ? {} : TMeta;
-
-declare type ToName<T extends string | undefined> = T extends string ? T : '';
-
-declare type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = CreateRouteOptions extends TOptions ? Route : TOptions extends {
-    parent: infer TParent extends Route;
-} ? Route<ToName<TOptions['name']>, ToWithParams<TParent['host']>, CombinePath<ToWithParams<TParent['path']>, ToWithParams<TOptions['path']>>, CombineQuery<ToWithParams<TParent['query']>, ToWithParams<TOptions['query']>>, CombineHash<ToWithParams<TParent['hash']>, ToWithParams<TOptions['hash']>>, CombineMeta<ToMeta<TParent['meta']>, ToMeta<TOptions['meta']>>, CombineState<ToState<TParent['state']>, ToState<TOptions['state']>>, ToMatches<TOptions, TProps>> : Route<ToName<TOptions['name']>, TOptions extends {
-    host: string | WithParams;
-} ? ToWithParams<TOptions['host']> : WithParams<'', {}>, ToWithParams<TOptions['path']>, ToWithParams<TOptions['query']>, ToWithParams<TOptions['hash']>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, TProps>>;
-
-declare type ToState<TState extends Record<string, Param> | undefined> = TState extends undefined ? Record<string, Param> : unknown extends TState ? {} : TState;
-
-declare type ToWithParams<T extends string | WithParams | undefined> = T extends string ? WithParams<T, {}> : T extends undefined ? WithParams<'', {}> : unknown extends T ? WithParams<'', {}> : T;
-
-declare type TupleOf<T extends Param[]> = {
-    [K in keyof T]: ExtractParamType<T[K]>;
-};
-
-export declare function tupleOf<const T extends Param[]>(params: T, options?: TupleOfOptions): ParamGetSet<TupleOf<T>>;
-
-declare type TupleOfOptions = {
-    separator?: string;
-};
-
-export declare function unionOf<const T extends Param[]>(params: T): ParamGetSet<ExtractParamType<T[number]>>;
-
-export declare type Url = `http://${string}` | `https://${string}` | `/${string}`;
-
-export declare type UrlParts = {
-    protocol?: string;
-    host?: string;
-    pathname: string;
-    searchParams: QuerySource;
-    search: string;
-    hash: string;
-};
-
-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`
-     */
-    route: ComputedRef<ResolvedRoute | undefined>;
-    /**
-     * Resolved URL with params interpolated and query applied. Same value as `router.resolve`.
-     */
-    href: ComputedRef<Url | undefined>;
-    /**
-     * True if route matches current URL or is ancestor of route that matches current URL
-     */
-    isMatch: ComputedRef<boolean>;
-    /**
-     * True if route matches current URL. Route is the same as what's currently stored at `router.route`.
-     */
-    isExactMatch: ComputedRef<boolean>;
-    /**
-     * True if route matches current URL, or is a parent route that matches the parent of the current URL.
-     */
-    isActive: ComputedRef<boolean>;
-    /**
-     * True if route matches current URL exactly.
-     */
-    isExactActive: ComputedRef<boolean>;
-    /**
-     *
-     */
-    isExternal: ComputedRef<boolean>;
-    /**
-     * Convenience method for executing `router.push` with route context passed in.
-     */
-    push: (options?: RouterPushOptions) => Promise<void>;
-    /**
-     * Convenience method for executing `router.replace` with route context passed in.
-     */
-    replace: (options?: RouterReplaceOptions) => Promise<void>;
-};
-
-/**
- * A composition to export much of the functionality that drives RouterLink component. Can be given route details to discover resolved URL,
- * or resolved URL to discover route details. Also exports some useful context about routes relationship to current URL and convenience methods
- * for navigating.
- *
- * @param source - The name of the route or a valid URL.
- * @param params - If providing route name, this argument will expect corresponding params.
- * @param options - {@link RouterResolveOptions} Same options as router resolve.
- * @returns {UseLink} Reactive context values for as well as navigation methods.
- * @group Compositions
- */
-export declare function useLink<TRouteKey extends RegisteredRoutesName>(name: MaybeRefOrGetter<TRouteKey>, ...args: UseLinkArgs<TRouteKey>): UseLink;
-
-export declare function useLink(url: MaybeRefOrGetter<Url>, options?: MaybeRefOrGetter<UseLinkOptions>): UseLink;
-
-export declare function useLink(resolvedRoute: MaybeRefOrGetter<ResolvedRoute | undefined>, options?: MaybeRefOrGetter<UseLinkOptions>): UseLink;
-
-export declare function useLink(source: MaybeRefOrGetter<string | ResolvedRoute | undefined>, paramsOrOptions?: MaybeRefOrGetter<Record<PropertyKey, unknown> | UseLinkOptions>, maybeOptions?: MaybeRefOrGetter<UseLinkOptions>): UseLink;
-
-declare type UseLinkArgs<TSource extends RegisteredRoutesName, TParams = RouteParamsByKey<RegisteredRoutes, TSource>> = AllPropertiesAreOptional<TParams> extends true ? [params?: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<UseLinkOptions>] : [params: MaybeRefOrGetter<TParams>, options?: MaybeRefOrGetter<UseLinkOptions>];
-
-export declare type UseLinkOptions = RouterPushOptions & {
-    prefetch?: PrefetchConfig;
-};
-
-declare type UseQueryValue<T> = {
-    value: Ref<T | null>;
-    values: Ref<T[]>;
-    remove: () => void;
-};
-
-export declare function useQueryValue(key: MaybeRefOrGetter<string>): UseQueryValue<string>;
-
-export declare function useQueryValue<TParam extends Param>(key: MaybeRefOrGetter<string>, param: TParam): UseQueryValue<ExtractParamType<TParam>>;
-
-/**
- * A composition to access the current route or verify a specific route name within a Vue component.
- * This function provides two overloads:
- * 1. When called without arguments, it returns the current route from the router without types.
- * 2. When called with a route name, it checks if the current active route includes the specified route name.
- *
- * The function also sets up a reactive watcher on the route object from the router to continually check the validity of the route name
- * if provided, throwing an error if the validation fails at any point during the component's lifecycle.
- *
- * @template TRouteName - A string type that should match route name of RegisteredRouteMap, ensuring the route name exists.
- * @param routeName - Optional. The name of the route to validate against the current active routes.
- * @returns The current router route. If a route name is provided, it validates the route name first.
- * @throws {UseRouteInvalidError} Throws an error if the provided route name is not valid or does not match the current route.
- * @group Compositions
- */
-export declare function useRoute(): RegisteredRouterRoute;
-
-export declare function useRoute<TRouteName extends RegisteredRoutesName>(routeName: TRouteName, options: IsRouteOptions & {
-    exact: true;
-}): RegisteredRouterRoute & {
-    name: TRouteName;
-};
-
-export declare function useRoute<TRouteName extends RegisteredRoutesName>(routeName: TRouteName, options?: IsRouteOptions): RegisteredRouterRoute & {
-    name: `${TRouteName}${string}`;
-};
-
-/**
- * An error thrown when there is a mismatch between an expected route and the one actually used.
- * @group Errors
- */
-export declare class UseRouteInvalidError extends Error {
-    /**
-     * Constructs a new UseRouteInvalidError instance with a message that specifies both the given and expected route names.
-     * This detailed error message aids in quickly identifying and resolving mismatches in route usage.
-     * @param routeName - The route name that was incorrectly used.
-     * @param actualRouteName - The expected route name that should have been used.
-     */
-    constructor(routeName: string, actualRouteName: string);
-}
-
-/**
- * A composition to access the registered router instance within a Vue component.
- *
- * @returns The registered router instance.
- * @throws {RouterNotInstalledError} Throws an error if the router has not been installed,
- *         ensuring the component does not operate without routing functionality.
- * @group Compositions
- */
-export declare function useRouter(): RegisteredRouter;
-
-declare interface ValibotSchemaLike extends StandardSchemaV1<any> {
-    type: string;
-}
-
-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.
- */
-export declare type WithHooks = {
-    onBeforeRouteEnter?: MaybeArray<BeforeRouteHook>;
-    onBeforeRouteUpdate?: MaybeArray<BeforeRouteHook>;
-    onBeforeRouteLeave?: MaybeArray<BeforeRouteHook>;
-    onAfterRouteEnter?: MaybeArray<AfterRouteHook>;
-    onAfterRouteUpdate?: MaybeArray<AfterRouteHook>;
-    onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
-};
-
-declare type WithHost<THost extends string | WithParams = string | WithParams> = {
-    /**
-     * Host part of URL.
-     */
-    host: THost;
-};
-
-declare type WithOptionalProperties<T> = {
-    [P in keyof T]-?: undefined extends T[P] ? P : never;
-}[keyof T];
-
-declare type WithoutHost = {
-    host?: never;
-};
-
-declare type WithoutParent = {
-    parent?: never;
-};
-
-declare type WithParams<TValue extends string = string, TParams extends Record<string, Param | undefined> = Record<string, Param | undefined>> = {
-    value: TValue;
-    params: string extends TValue ? Record<string, Param> : Identity<WithParamsParamsOutput<TValue, TParams>>;
-};
-
-export declare function withParams<const TValue extends string, const TParams extends MakeOptional<WithParamsParamsInput<TValue>>>(value: TValue, params: TParams): WithParams<TValue, TParams>;
-
-export declare function withParams(): WithParams<'', {}>;
-
-declare type WithParamsParamsInput<TValue extends string> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? Record<ExtractParamName<TParam>, Param | undefined> & WithParamsParamsInput<Rest> : {};
-
-declare type WithParamsParamsOutput<TValue extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TValue extends `${string}${ParamStart}${infer TParam}${ParamEnd}${infer Rest}` ? ExtractParamName<TParam> extends keyof TParams ? Record<ExtractParamName<TParam>, TParams[ExtractParamName<TParam>]> & WithParamsParamsOutput<Rest, TParams> : Record<ExtractParamName<TParam>, StringConstructor> & WithParamsParamsOutput<Rest, TParams> : {};
-
-declare type WithParent<TParent extends Route = Route> = {
-    parent: TParent;
-};
-
-declare interface ZodSchemaLike extends StandardSchemaV1<any> {
-    parse: (input: any) => any;
-}
-
-export { }
-
-
-declare module 'vue' {
-    interface GlobalComponents {
-        RouterView: typeof RouterView;
-        RouterLink: typeof RouterLink;
-    }
-}
+export * from './main'
+export {}