@kitbag/router 0.20.12 → 0.22.0

package/dist/services/createRouteHooks.d.ts

@@ -1,15 +1,17 @@
-import { AddRouterBeforeRouteHook, AddRouterAfterRouteHook, AddRouterErrorHook } from '../types/hooks';
+import { AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, AddErrorHook } from '../types/hooks';
 import { Routes } from '../types/route';
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
+import { Hooks } from '../models/hooks';
 import { Rejection } from '../types/rejection';
+import { RouteRedirect } from '../types/redirects';
 export type RouteHooks<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
-    onBeforeRouteEnter: AddRouterBeforeRouteHook<TRoutes, TRejections>;
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook<TRoutes, TRejections>;
-    onBeforeRouteLeave: AddRouterBeforeRouteHook<TRoutes, TRejections>;
-    onAfterRouteEnter: AddRouterAfterRouteHook<TRoutes, TRejections>;
-    onAfterRouteUpdate: AddRouterAfterRouteHook<TRoutes, TRejections>;
-    onAfterRouteLeave: AddRouterAfterRouteHook<TRoutes, TRejections>;
-    onError: AddRouterErrorHook<TRoutes, TRejections>;
-    store: RouterRouteHooks;
+    redirect: RouteRedirect;
+    onBeforeRouteEnter: AddBeforeEnterHook<TRoutes, TRejections>;
+    onBeforeRouteUpdate: AddBeforeUpdateHook<TRoutes, TRejections>;
+    onBeforeRouteLeave: AddBeforeLeaveHook<TRoutes, TRejections>;
+    onAfterRouteEnter: AddAfterEnterHook<TRoutes, TRejections>;
+    onAfterRouteUpdate: AddAfterUpdateHook<TRoutes, TRejections>;
+    onAfterRouteLeave: AddAfterLeaveHook<TRoutes, TRejections>;
+    onError: AddErrorHook<TRoutes[number], TRoutes, TRejections>;
+    store: Hooks;
 };
 export declare function createRouteHooks(): RouteHooks;

package/dist/services/createRouteRedirects.d.ts

@@ -0,0 +1,10 @@
+import { RouteRedirects } from '../types/redirects';
+import { Route } from '../types/route';
+type CreateRouteRedirectsContext = {
+    /**
+     * The to route for the redirectFrom callback and the from route for the redirectTo callback.
+     */
+    getRoute: () => Route;
+};
+export declare function createRouteRedirects({ getRoute }: CreateRouteRedirectsContext): RouteRedirects;
+export {};

package/dist/services/createRouterAssets.d.ts

@@ -7,7 +7,7 @@ import { createUseRouter } from '../compositions/useRouter';
 import { createUseQueryValue } from '../compositions/useQueryValue';
 import { createUseLink } from '../compositions/useLink';
 import { createIsRoute } from '../guards/routes';
-import { AddRouterAfterRouteHook, AddRouterBeforeRouteHook } from '../types/hooks';
+import { AddBeforeLeaveHook, AddBeforeUpdateHook, AddAfterLeaveHook, AddAfterUpdateHook } from '../types/hooks';
 export type RouterAssets<TRouter extends Router> = {
     /**
      * Registers a hook that is called before a route is left. Must be called from setup.
@@ -17,7 +17,7 @@ export type RouterAssets<TRouter extends Router> = {
      * @returns {RouteHookRemove} A function that removes the added hook.
      * @group Hooks
      */
-    onBeforeRouteLeave: AddRouterBeforeRouteHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    onBeforeRouteLeave: AddBeforeLeaveHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
     /**
      * 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.
@@ -26,7 +26,7 @@ export type RouterAssets<TRouter extends Router> = {
      * @returns {RouteHookRemove} A function that removes the added hook.
      * @group Hooks
      */
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    onBeforeRouteUpdate: AddBeforeUpdateHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
     /**
      * 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.
@@ -35,7 +35,7 @@ export type RouterAssets<TRouter extends Router> = {
      * @returns {RouteHookRemove} A function that removes the added hook.
      * @group Hooks
      */
-    onAfterRouteLeave: AddRouterAfterRouteHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    onAfterRouteLeave: AddAfterLeaveHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
     /**
      * 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.
@@ -44,7 +44,7 @@ export type RouterAssets<TRouter extends Router> = {
      * @returns {RouteHookRemove} A function that removes the added hook.
      * @group Hooks
      */
-    onAfterRouteUpdate: AddRouterAfterRouteHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
+    onAfterRouteUpdate: AddAfterUpdateHook<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
     /**
      * A guard to verify if a route or unknown value matches a given route name.
      *

package/dist/services/createRouterCallbackContext.d.ts

@@ -1,12 +1,12 @@
-import { Router, RouterRejections, RouterRoutes } from '../types/router';
 import { RouterPush } from '../types/routerPush';
 import { RouterReject } from '../types/routerReject';
 import { RouterReplace } from '../types/routerReplace';
-import { InjectionKey } from 'vue';
 import { BuiltInRejectionType } from './createRouterReject';
 import { AsString } from '../types/utilities';
 import { Routes } from '../types/route';
-import { Rejection } from '../types/rejection';
+import { Rejections } from '../types/rejection';
+import { RouteUpdate } from '../types/routeUpdate';
+import { ResolvedRoute } from '../types/resolved';
 /**
  * Defines the structure of a successful callback response.
  */
@@ -37,11 +37,13 @@ export type RouterCallbackRejectResponse<TRejections extends string> = {
  * A function that can be called to abort a routing operation.
  */
 export type CallbackContextAbort = () => void;
-export type RouterCallbackContext<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]> = {
+export type RouterCallbackContext<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections> = {
     reject: RouterReject<TRejections>;
     push: RouterPush<TRoutes>;
     replace: RouterReplace<TRoutes>;
+    update: RouteUpdate<ResolvedRoute<TRoutes[number]>>;
     abort: CallbackContextAbort;
 };
-export declare function createRouterCallbackContext<TRouter extends Router>(_routerKey: InjectionKey<TRouter>): RouterCallbackContext<RouterRoutes<TRouter>, RouterRejections<TRouter>>;
-export declare function createRouterCallbackContext<TRoutes extends Routes, TRejections extends Rejection[]>(): RouterCallbackContext<TRoutes, TRejections>;
+export declare function createRouterCallbackContext<TRoutes extends Routes, TRejections extends Rejections>({ to }: {
+    to: ResolvedRoute;
+}): RouterCallbackContext<TRoutes, TRejections>;

package/dist/services/createRouterHooks.d.ts

@@ -1,19 +1,18 @@
-import { AddGlobalRouteHooks, AddComponentAfterRouteHook, AddComponentBeforeRouteHook, RouterRouteHookAfterRunner, RouterRouteHookErrorRunner, RouterRouteHookBeforeRunner, AddRouterBeforeRouteHook, AddRouterAfterRouteHook, AddRouterErrorHook } from '../types/hooks';
+import { AddGlobalHooks, AddComponentHook, AfterHookRunner, BeforeHookRunner, AddBeforeEnterHook, AddBeforeUpdateHook, AddBeforeLeaveHook, AddAfterEnterHook, AddAfterUpdateHook, AddAfterLeaveHook, ErrorHookRunner, AddErrorHook } from '../types/hooks';
 import { HasVueAppStore } from './createVueAppStore';
 export declare const getRouterHooksKey: (routerKey: import('vue').InjectionKey<import('../main').Router>) => import('vue').InjectionKey<RouterHooks>;
 export type RouterHooks = HasVueAppStore & {
-    runBeforeRouteHooks: RouterRouteHookBeforeRunner;
-    runAfterRouteHooks: RouterRouteHookAfterRunner;
-    runErrorHooks: RouterRouteHookErrorRunner;
-    addComponentBeforeRouteHook: AddComponentBeforeRouteHook;
-    addComponentAfterRouteHook: AddComponentAfterRouteHook;
-    addGlobalRouteHooks: AddGlobalRouteHooks;
-    onBeforeRouteEnter: AddRouterBeforeRouteHook;
-    onBeforeRouteUpdate: AddRouterBeforeRouteHook;
-    onBeforeRouteLeave: AddRouterBeforeRouteHook;
-    onAfterRouteEnter: AddRouterAfterRouteHook;
-    onAfterRouteUpdate: AddRouterAfterRouteHook;
-    onAfterRouteLeave: AddRouterAfterRouteHook;
-    onError: AddRouterErrorHook;
+    runBeforeRouteHooks: BeforeHookRunner;
+    runAfterRouteHooks: AfterHookRunner;
+    runErrorHooks: ErrorHookRunner;
+    addComponentHook: AddComponentHook;
+    addGlobalRouteHooks: AddGlobalHooks;
+    onBeforeRouteEnter: AddBeforeEnterHook;
+    onBeforeRouteUpdate: AddBeforeUpdateHook;
+    onBeforeRouteLeave: AddBeforeLeaveHook;
+    onAfterRouteEnter: AddAfterEnterHook;
+    onAfterRouteUpdate: AddAfterUpdateHook;
+    onAfterRouteLeave: AddAfterLeaveHook;
+    onError: AddErrorHook;
 };
 export declare function createRouterHooks(): RouterHooks;

package/dist/services/createRouterPlugin.d.ts

@@ -1,4 +1,4 @@
 import { CreateRouterPluginOptions, RouterPlugin, PluginRouteHooks } from '../types/routerPlugin';
-import { Rejection } from '../types/rejection';
+import { Rejections } from '../types/rejection';
 import { Routes } from '../types/route';
-export declare function createRouterPlugin<TRoutes extends Routes = Routes, TRejections extends Rejection[] = Rejection[]>(plugin: CreateRouterPluginOptions<TRoutes, TRejections>): RouterPlugin<TRoutes, TRejections> & PluginRouteHooks<TRoutes, TRejections>;
+export declare function createRouterPlugin<TRoutes extends Routes = Routes, TRejections extends Rejections = Rejections>(plugin: CreateRouterPluginOptions<TRoutes, TRejections>): RouterPlugin<TRoutes, TRejections> & PluginRouteHooks<TRoutes, TRejections>;

package/dist/services/getGlobalHooksForRouter.d.ts

@@ -1,4 +1,3 @@
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
-import { RouterOptions } from '../types/router';
+import { Hooks } from '../models/hooks';
 import { RouterPlugin } from '../types/routerPlugin';
-export declare function getGlobalHooksForRouter(options?: RouterOptions, plugins?: RouterPlugin[]): RouterRouteHooks;
+export declare function getGlobalHooksForRouter(plugins?: RouterPlugin[]): Hooks;

package/dist/services/getGlobalRouteHooks.d.ts

@@ -1,4 +1,4 @@
 import { ResolvedRoute } from '../types/resolved';
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
-export declare function getGlobalBeforeRouteHooks(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: RouterRouteHooks): RouterRouteHooks;
-export declare function getGlobalAfterRouteHooks(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: RouterRouteHooks): RouterRouteHooks;
+import { Hooks } from '../models/hooks';
+export declare function getGlobalBeforeHooks(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: Hooks): Hooks;
+export declare function getGlobalAfterHooks(to: ResolvedRoute, from: ResolvedRoute | null, globalHooks: Hooks): Hooks;

package/dist/services/getRouteHooks.d.ts

@@ -1,4 +1,4 @@
 import { ResolvedRoute } from '../types/resolved';
-import { RouterRouteHooks } from '../models/RouterRouteHooks';
-export declare function getBeforeRouteHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): RouterRouteHooks;
-export declare function getAfterRouteHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): RouterRouteHooks;
+import { Hooks } from '../models/hooks';
+export declare function getBeforeHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): Hooks;
+export declare function getAfterHooksFromRoutes(to: ResolvedRoute, from: ResolvedRoute | null): Hooks;

package/dist/services/hooks.d.ts

@@ -1,8 +1,8 @@
-import { RouteHookLifecycle } from '../types/hooks';
+import { HookLifecycle } from '../types/hooks';
 import { ResolvedRoute } from '../types/resolved';
 type RouteHookCondition = (to: ResolvedRoute, from: ResolvedRoute | null, depth: number) => boolean;
 export declare const isRouteEnter: RouteHookCondition;
 export declare const isRouteLeave: RouteHookCondition;
 export declare const isRouteUpdate: RouteHookCondition;
-export declare function getRouteHookCondition(lifecycle: RouteHookLifecycle): RouteHookCondition;
+export declare function getRouteHookCondition(lifecycle: HookLifecycle): RouteHookCondition;
 export {};

package/dist/services/insertBaseRoute.d.ts

@@ -1,2 +1,2 @@
-import { Routes } from '../types/route';
-export declare function insertBaseRoute(routes: Routes, base?: string): Routes;
+import { Route } from '../types/route';
+export declare function insertBaseRoute(route: Route, base?: string): Route;

package/dist/services/routeMatchRules.d.ts

@@ -1,5 +1,4 @@
 import { RouteMatchRule } from '../types/routeMatchRule';
-export declare const isNamedRoute: RouteMatchRule;
 export declare const routeHostMatches: RouteMatchRule;
 export declare const routePathMatches: RouteMatchRule;
 export declare const routeQueryMatches: RouteMatchRule;

package/dist/services/routeMatchScore.d.ts

@@ -3,5 +3,5 @@ import { QuerySource } from '../types/querySource';
 type RouteSortMethod = (aRoute: Route, bRoute: Route) => number;
 export declare function getRouteScoreSortMethod(url: string): RouteSortMethod;
 export declare function countExpectedPathParams(route: Route, actualPath: string): number;
-export declare function countExpectedQueryParams(route: Route, actual: QuerySource): number;
+export declare function countExpectedQueryParams(route: Route, actualQuery: QuerySource): number;
 export {};

package/dist/services/routeRegex.d.ts

@@ -3,6 +3,7 @@ import { WithParams } from './withParams';
 export declare function splitByMatches(string: string, regexp: RegExp): string[];
 export declare function generateRouteHostRegexPattern(route: Route): RegExp;
 export declare function generateRoutePathRegexPattern(route: Route): RegExp;
+export declare function generateRouteHashRegexPattern(route: Route): RegExp;
 export declare function generateRouteQueryRegexPatterns(route: Route): RegExp[];
 export declare function replaceParamSyntaxWithCatchAlls(value: string): string;
 export declare function replaceIndividualParamWithCaptureGroup(path: string, paramName: string): string;

package/dist/services/urlAssembly.d.ts

@@ -1,10 +1,10 @@
 import { Route } from '../types/route';
-import { Url } from '../types/url';
+import { UrlString } from '../types/urlString';
 import { QuerySource } from '../types/querySource';
 type AssembleUrlOptions = {
     params?: Record<string, unknown>;
     query?: QuerySource;
     hash?: string;
 };
-export declare function assembleUrl(route: Route, options?: AssembleUrlOptions): Url;
+export declare function assembleUrl(route: Route, options?: AssembleUrlOptions): UrlString;
 export {};

package/dist/services/urlCombine.d.ts

@@ -1,2 +1,2 @@
-import { Url, UrlParts } from '../types/url';
-export declare function combineUrl(previous: Url | Partial<UrlParts>, updated: Url | Partial<UrlParts>): Url;
+import { UrlString, UrlParts } from '../types/urlString';
+export declare function combineUrl(previous: UrlString | Partial<UrlParts>, updated: UrlString | Partial<UrlParts>): UrlString;

package/dist/services/urlCreator.d.ts

@@ -1,2 +1,2 @@
-import { Url, UrlParts } from '../types/url';
-export declare function createUrl({ protocol, host, pathname, search, searchParams, hash }: Partial<UrlParts>): Url;
+import { UrlString, UrlParts } from '../types/urlString';
+export declare function createUrl({ protocol, host, pathname, search, searchParams, hash }: Partial<UrlParts>): UrlString;

package/dist/services/urlParser.d.ts

@@ -1,2 +1,2 @@
-import { UrlParts } from '../types/url';
+import { UrlParts } from '../types/urlString';
 export declare function parseUrl(value: string): UrlParts;

package/dist/types/callbackContext.d.ts

@@ -0,0 +1,15 @@
+import { RouterPush } from './routerPush';
+export type CallbackContextSuccess = {
+    status: 'SUCCESS';
+};
+export type CallbackContextPush = {
+    status: 'PUSH';
+    to: Parameters<RouterPush>;
+};
+export type CallbackContextReject = {
+    status: 'REJECT';
+    type: string;
+};
+export type CallbackContextAbort = {
+    status: 'ABORT';
+};

package/dist/types/createRouteOptions.d.ts

@@ -15,7 +15,6 @@ import { MaybePromise } from './utilities';
 import { ToMeta } from './meta';
 import { ToState } from './state';
 import { ToName } from './name';
-import { WithHooks } from './hooks';
 import { ToWithParams, WithParams } from '../services/withParams';
 import { RouteContext, ToRouteContext } from './routeContext';
 import { RouterViewProps } from '../components/routerView';
@@ -47,7 +46,7 @@ export declare function isWithComponents<T extends Record<string, unknown>>(opti
 export declare function isWithComponentPropsRecord<T extends Record<string, unknown>>(options: T): options is T & {
     props: RoutePropsRecord;
 };
-export 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 & {
+export 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> = {
     /**
      * Name for route, used to create route keys and in navigation.
      */
@@ -94,15 +93,9 @@ export type CreateRouteOptions<TName extends string | undefined = string | undef
      * Related routes and rejections for the route. The context is exposed to the hooks and props callback functions for this route.
      */
     context?: RouteContext[];
-    /**
-     * Props have been moved to the second argument of `createRoute`. This property can no longer be used.
-     *
-     * @deprecated
-     */
-    props?: never;
 };
-export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions>) => MaybePromise<ComponentProps<TComponent>>;
-export type RouterViewPropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions> = (route: ResolvedRoute<ToRoute<TOptions, undefined>>, context: PropsCallbackContext<TOptions>) => MaybePromise<RouterViewProps & Record<string, unknown>>;
+export type PropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions, TComponent extends Component = Component> = (route: ResolvedRoute<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<ComponentProps<TComponent>>;
+export type RouterViewPropsGetter<TOptions extends CreateRouteOptions = CreateRouteOptions> = (route: ResolvedRoute<ToRoute<TOptions>>, context: PropsCallbackContext<ToRoute<TOptions>, TOptions>) => MaybePromise<RouterViewProps & Record<string, unknown>>;
 type ComponentPropsAreOptional<TComponent extends Component> = Partial<ComponentProps<TComponent>> extends ComponentProps<TComponent> ? true : false;
 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]>;
@@ -121,13 +114,13 @@ type ToMatch<TOptions extends CreateRouteOptions, TProps extends CreateRouteProp
 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>];
-export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined> = CreateRouteOptions extends TOptions ? Route : TOptions extends {
+export type ToRoute<TOptions extends CreateRouteOptions, TProps extends CreateRouteProps<TOptions> | undefined = 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']>, 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, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>, [
     ...ToRouteContext<TParent['context']>,
     ...ToRouteContext<TOptions['context']>
 ]> : 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>, ToRouteContext<TOptions['context']>>;
+} ? ToWithParams<TOptions['host']> : WithParams<'', {}>, ToWithParams<TOptions['path']>, ToWithParams<TOptions['query']>, ToWithParams<TOptions['hash']>, ToMeta<TOptions['meta']>, ToState<TOptions['state']>, ToMatches<TOptions, CreateRouteProps<TOptions> extends TProps ? undefined : TProps>, ToRouteContext<TOptions['context']>>;
 export declare function combineRoutes(parent: Route, child: Route): Route;
 export {};