@kitbag/router 0.4.1 → 0.5.0

package/dist/kitbag-router.d.ts

@@ -55,13 +55,6 @@ 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.
@@ -69,13 +62,6 @@ declare type AddAfterRouteHook_2 = (hook: AfterRouteHook_2) => RouteHookRemove_2
  */
 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.
@@ -84,24 +70,11 @@ declare type AddBeforeRouteHook_2 = (hook: BeforeRouteHook_2) => RouteHookRemove
  */
 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.
  */
@@ -115,21 +88,6 @@ 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>;
-    };
-    query: {
-        params: Record<string, unknown>;
-    };
-};
-
-declare type BaseResolvedRoute_2 = Route_2 & { path: { params: Record<string, unknown> }, query: { params: Record<string, unknown> } }
-
 declare type BaseRoute = {
     key: string;
     disabled: false;
@@ -141,8 +99,6 @@ 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.
@@ -151,14 +107,6 @@ declare type BaseRoute_2 = { key: string, disabled: false, path: { params: Recor
  */
 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.
@@ -167,14 +115,6 @@ 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.
  */
@@ -188,12 +128,8 @@ export declare type BeforeRouteHookResponse<TRoutes extends Routes> = RouteHookS
 
 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.
  */
@@ -220,32 +156,6 @@ 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 {
@@ -290,6 +200,8 @@ export declare function component<TComponent extends Component>(component: TComp
 
 declare type Constructor = new (...args: any) => any;
 
+export declare function createExternalRoutes<const TRoutes extends ExternalRouteProps[]>(routes: TRoutes): FlattenRoutes<TRoutes>;
+
 export declare function createParam<TParam extends ParamWithDefault>(param: TParam): TParam;
 
 export declare function createParam<TParam extends Param>(param: TParam): ParamGetSet<ExtractParamType<TParam>>;
@@ -321,6 +233,8 @@ export declare function createParam<TParam extends Param>(param: TParam, default
  */
 export declare function createRouter<const T extends Routes>(routes: T, options?: RouterOptions): Router<T>;
 
+export declare function createRouter<const T extends Routes>(arrayOfRoutes: T[], options?: RouterOptions): Router<T>;
+
 /**
  * Creates an array of routes from a defined set of route properties, handling hierarchical route combinations.
  * This function also validates for duplicate parameter keys across the combined routes.
@@ -328,7 +242,7 @@ export declare function createRouter<const T extends Routes>(routes: T, options?
  * @param routesProps - An array of route properties used to configure and create routes.
  * @returns An array of fully configured Route instances.
  */
-export declare function createRoutes<const TRoutes extends Readonly<RouteProps[]>>(routes: TRoutes): FlattenRoutes<TRoutes>;
+export declare function createRoutes<const TRoutes extends RouteProps[]>(routes: TRoutes): FlattenRoutes<TRoutes>;
 
 /**
  * An error thrown when duplicate parameters are detected in a route when creating a router.
@@ -343,62 +257,82 @@ export declare class DuplicateParamsError extends Error {
     constructor(paramName: string);
 }
 
-/**
- * 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.
- */
-export declare type ExtractParamName<TParam extends string> = TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam;
+declare type ExternalRouteChildProps = {
+    /**
+     * Represents the host for this route. Used for external routes.
+     */
+    host?: string;
+    /**
+     * 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;
+    /**
+     * Query (aka search) part of URL.
+     */
+    query?: string | Query;
+    /**
+     * Children routes, cannot have a value for a child route.
+     */
+    children?: never;
+};
+
+declare type ExternalRouteParentProps = {
+    /**
+     * Represents the host for this route. Used for external routes.
+     */
+    host?: string;
+    /**
+     * Name for route, used to create route keys and in navigation.
+     */
+    name?: string;
+    /**
+     * Disabled routes will not ever match but can still provide physical structure, nested children behave normally.
+     */
+    disabled?: boolean;
+    /**
+     * Path part of URL.
+     */
+    path: string | Path;
+    /**
+     * Query (aka search) part of URL.
+     */
+    query?: string | Query;
+    /**
+     * Children routes, expected type comes from `createExternalRoutes()`
+     */
+    children: ExternalRoutes;
+};
+
+declare type ExternalRouteProps = ExternalRouteParentProps | ExternalRouteChildProps;
+
+declare type ExternalRoutes = Route<string, '', Path, Query, boolean>[];
 
 /**
  * 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
+export declare type ExtractParamName<TParam extends PropertyKey> = 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>;
+    [P in 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.
- */
-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
+export declare type ExtractParamType<TParam extends Param, TParamKey extends PropertyKey = string> = TParam extends ParamGetSet<infer Type> ? TParamKey extends `?${string}` ? TParam extends ParamWithDefault ? Type : Type | undefined : Type : TParam extends ParamGetter ? TParamKey extends `?${string}` ? ReturnType<TParam> | undefined : ReturnType<TParam> : TParamKey extends `?${string}` ? string | undefined : string;
 
 /**
  * Transforms a record of parameter types into a type with optional properties where the original type allows undefined.
@@ -406,43 +340,14 @@ declare type ExtractParamType_2<TParam extends Param_2> = TParam extends ParamGe
  * @returns A new type with the appropriate properties marked as optional.
  */
 export declare type ExtractParamTypes<TParams extends Record<string, Param>> = Identity<MakeOptional<{
-    [K in keyof TParams]: ExtractParamType<TParams[K]>;
+    [K in keyof TParams as ExtractParamName<K>]: ExtractParamType<TParams[K], 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]>;
+    [K in keyof TParams as ExtractParamName<K>]: ExtractParamTypeWithoutLosingOptional<TParams[K], 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] extends Param ? OptionalParamGetSet<TParams[OptionalParam]> : OptionalParamGetSet<StringConstructor> : OptionalParamGetSet<StringConstructor> : TParam extends keyof TParams ? TParams[TParam] : StringConstructor;
+declare type ExtractParamTypeWithoutLosingOptional<TParam extends Param, TParamKey extends PropertyKey> = TParam extends ParamGetSet<infer Type> ? TParamKey extends `?${string}` ? Type | undefined : Type : TParam extends ParamGetter ? TParamKey extends `?${string}` ? ReturnType<TParam> | undefined : ReturnType<TParam> : TParamKey extends `?${string}` ? string | undefined : string;
 
 /**
  * Determines the type of a path parameter from a record of parameter types, considering optional parameters.
@@ -450,31 +355,13 @@ export declare type ExtractPathParamType<TParam extends string, TParams extends
  * @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
+export declare type ExtractPathParamType<TParam extends string, TParams extends Record<string, Param | undefined>> = TParam extends `?${infer OptionalParam}` ? OptionalParam extends keyof TParams ? TParams[OptionalParam] : 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>;
+    [P in 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'] : [] : [];
+declare type ExtractRouteChildren<TRoute extends RouteProps | ExternalRouteProps> = 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.
@@ -489,20 +376,7 @@ export declare type ExtractRouteParamTypes<TRoute> = TRoute extends {
     query: {
         params: infer QueryParams extends Record<string, Param>;
     };
-} ? 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>
+} ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : {};
 
 declare type ExtractRouteParamTypesWithoutLosingOptional<TRoute> = TRoute extends {
     path: {
@@ -513,23 +387,18 @@ declare type ExtractRouteParamTypesWithoutLosingOptional<TRoute> = TRoute extend
     };
 } ? 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 = 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>,
+declare type FlattenRoute<TRoute extends RouteProps | ExternalRouteProps, TKey extends string = string & TRoute['name'], THost extends string = TRoute extends {
+    host: infer T extends string;
+} ? T : '', 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, THost, 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']>;
+    [K in keyof TChildren]: Route<CombineName<TKey, TChildren[K]['key']>, THost, CombinePath<TPath, TChildren[K]['path']>, CombineQuery<TQuery, TChildren[K]['query']>, TChildren[K]['disabled']>;
 }
 ];
 
-declare type FlattenRoutes<TRoutes extends Readonly<RouteProps[]>> = Flatten<[
+declare type FlattenRoutes<TRoutes extends Readonly<RouteProps[] | ExternalRouteProps[]>> = Flatten<[
 ...{
     [K in keyof TRoutes]: FlattenRoute<TRoutes[K]>;
 }
@@ -539,22 +408,8 @@ 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.
@@ -582,7 +437,27 @@ 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<TRoute extends RouterRoute, TRouteKey extends TRoute['key']>(route: TRoute, routeKey: TRouteKey, options: IsRouteOptions & {
+    exact: true;
+}): route is TRoute & {
+    key: TRouteKey;
+};
+
+export declare function isRoute<TRoute extends RouterRoute, TRouteKey extends TRoute['key']>(route: TRoute, routeKey: TRouteKey, options?: IsRouteOptions): route is TRoute & {
+    key: `${TRouteKey}${string}`;
+};
+
+export declare function isRoute<TRouteKey extends RegisteredRoutesKey>(route: unknown, routeKey: TRouteKey, options: IsRouteOptions & {
+    exact: true;
+}): route is RegisteredRouterRoute & {
+    key: TRouteKey;
+};
+
+export declare function isRoute<TRouteKey extends RegisteredRoutesKey>(route: unknown, routeKey: TRouteKey, options?: IsRouteOptions): route is RegisteredRouterRoute & {
+    key: `${TRouteKey}${string}`;
+};
+
+export declare function isRoute(route: unknown, routeKey?: string, options?: IsRouteOptions): boolean;
 
 declare type IsRouteOptions = {
     exact?: boolean;
@@ -602,20 +477,10 @@ declare type MakeOptional<T> = {
     [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.
@@ -626,29 +491,8 @@ 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.
@@ -698,72 +542,32 @@ 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.
  */
@@ -794,37 +598,7 @@ export declare type ParentRouteProps = Partial<WithComponent | WithComponents> &
     meta?: RouteMeta;
 };
 
-/**
- * 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>> = {
+declare type Path<TPath extends string = string, TParams extends PathParamsWithParamNameExtracted<TPath> = Record<string, Param | undefined>> = {
     path: TPath;
     params: string extends TPath ? Record<string, Param> : Identity<ExtractParamsFromPathString<TPath, TParams>>;
     toString: () => string;
@@ -853,30 +627,21 @@ declare type Path<TPath extends string = string, TParams extends PathParams<TPat
  * ])
  * ```
  */
-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,
-}
+export declare function path<TPath extends string, TParams extends PathParamsWithParamNameExtracted<TPath>>(path: TPath, params: Identity<TParams>): Path<TPath, TParams>;
 
 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 PathParamsWithParamNameExtracted<TPath extends string> = {
+    [K in keyof ExtractParamsFromPathString<TPath> as ExtractParamName<K>]?: Param;
+};
 
 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<TQuery extends string = string, TQueryParams extends QueryParams<TQuery> = Record<string, Param | undefined>> = {
+declare type Query<TQuery extends string = string, TQueryParams extends QueryParamsWithParamNameExtracted<TQuery> = Record<string, Param | undefined>> = {
     query: TQuery;
     params: string extends TQuery ? Record<string, Param> : Identity<ExtractQueryParamsFromQueryString<TQuery, TQueryParams>>;
     toString: () => string;
@@ -905,24 +670,15 @@ declare type Query<TQuery extends string = string, TQueryParams extends QueryPar
  * ])
  * ```
  */
-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,
-}
+export declare function query<TQuery extends string, TParams extends QueryParamsWithParamNameExtracted<TQuery>>(query: TQuery, params: Identity<TParams>): Query<TQuery, TParams>;
 
 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
-}
+declare type QueryParamsWithParamNameExtracted<T extends string> = {
+    [K in keyof ExtractQueryParamsFromQueryString<T> as ExtractParamName<K>]?: Param;
+};
 
 /**
  * Represents the state of currently registered router, and rejections. Used to provide correct type context for
@@ -940,21 +696,6 @@ declare type QueryParams_2<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}
  */
@@ -962,13 +703,6 @@ 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}
  */
@@ -986,20 +720,15 @@ 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}
+ * Represents the Router property within {@link Register}
  */
-declare type RegisteredRouterReplace_2 = RouterReplace_2<RegisteredRoutes_2>
+export declare type RegisteredRouterRoute = RegisteredRouter['route'];
 
 /**
  * Represents the State property registered within {@link Register}
@@ -1013,14 +742,7 @@ export declare type RegisteredRouterState = Register extends {
  */
 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>[]
+} ? TRoutes : Route<string, '', Path<'', {}>, Query<'', {}>, false>[];
 
 /**
  * Represents the union of all possible RouteKeys registered within {@link Register}
@@ -1031,7 +753,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> = Readonly<{
+declare type ResolvedRoute<TRoute extends Route = Route> = Readonly<{
     /**
      * The specific route properties that were matched in the current route.
      */
@@ -1052,47 +774,14 @@ declare type ResolvedRoute<TRoute extends Route = BaseResolvedRoute> = Readonly<
     /**
      * Key value pair for route params, values will be the user provided value from current browser location.
      */
-    params: BaseResolvedRoute extends TRoute ? Record<string, unknown> : ExtractRouteParamTypes<TRoute>;
+    params: 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.
@@ -1100,7 +789,7 @@ declare type ResolvedRouteQuery_2 = {
  * @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 = string, TPath extends string | Path = Path, TQuery extends string | Query = Query, TDisabled extends boolean = boolean> = {
+export declare type Route<TKey extends string = string, THost extends string = string, TPath extends Path = Path, TQuery extends Query = Query, TDisabled extends boolean = boolean> = {
     /**
      * The specific route properties that were matched in the current route.
      */
@@ -1115,65 +804,26 @@ export declare type Route<TKey extends string = string, TPath extends string | P
      */
     key: TKey;
     /**
-     * Represents the structured path of the route, including path params.
-     */
-    path: ToPath<TPath>;
-    /**
-     * Represents the structured query of the route, including query params.
-     */
-    query: ToQuery<TQuery>;
-    depth: number;
-    /**
-     * Indicates if the route is disabled.
+     * Represents the host for this route. Used for external routes.
      */
-    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,
+    host: THost;
     /**
      * Represents the structured path of the route, including path params.
      */
-    path: ToPath_2<TPath>,
+    path: TPath;
     /**
      * Represents the structured query of the route, including query params.
      */
-    query: ToQuery_2<TQuery>,
-    depth: number,
+    query: TQuery;
+    depth: number;
     /**
      * Indicates if the route is disabled.
      */
-    disabled: TDisabled extends boolean ? TDisabled : false,
-}
+    disabled: TDisabled;
+};
 
 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.
  */
@@ -1184,11 +834,6 @@ 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.
  */
@@ -1206,16 +851,6 @@ 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.
  */
@@ -1243,11 +878,6 @@ 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.
@@ -1275,36 +905,13 @@ declare type RouteHookSuccessResponse = {
 export declare interface RouteMeta extends Record<string, unknown> {
 }
 
-/**
- * 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.
  */
@@ -1312,16 +919,11 @@ 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.
      */
-    route: RouterRoute;
+    route: RouterRoutes<TRoutes>;
     /**
      * Resolves a URL to a route object.
      */
@@ -1386,103 +988,19 @@ export declare type Router<TRoutes extends Routes = any> = Plugin_2 & {
      * A promise that resolves when the router is fully initialized.
      */
     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.
+     * Given a URL, returns true if host does not match host stored on router instance
      */
-    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>,
-}
+    isExternal: (url: string) => boolean;
+};
 
 declare type RouterFind<TRoutes extends Routes> = {
     <TSource extends RoutesKey<TRoutes>>(source: TSource, ...args: RouterFindArgs<TRoutes, TSource>): ResolvedRoute | undefined;
     (source: Url): ResolvedRoute | undefined;
 };
 
-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';
 
 export declare const routerInjectionKey: InjectionKey<RegisteredRouter>;
@@ -1519,7 +1037,7 @@ export declare class RouterNotInstalledError extends Error {
  */
 export declare type RouterOptions = {
     /**
-     * Initial URL for the router to use. Required if using Node environment.
+     * Initial URL for the router to use. Required if using Node environment. Defaults to window.location when using browser.
      *
      * @default window.location.toString()
      */
@@ -1535,37 +1053,15 @@ declare type RouterPush<TRoutes extends Routes = any> = {
     (source: Url, options?: RouterPushOptions): Promise<void>;
 };
 
-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;
@@ -1579,64 +1075,26 @@ 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 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 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 RouterResolveOptions_2 = {
-    query?: Record<string, string>,
-}
-
 declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = Readonly<{
     key: TRoute['key'];
     matched: TRoute['matched'];
@@ -1646,14 +1104,12 @@ declare type RouterRoute<TRoute extends ResolvedRoute = ResolvedRoute> = Readonl
     update: RouteUpdate<TRoute>;
 }>;
 
-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>,
-}>
+/**
+ * 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];
 
 export declare const RouterView: __VLS_WithTemplateSlots<DefineComponent<__VLS_TypePropsToRuntimeProps<{
 name?: string | undefined;
@@ -1666,14 +1122,11 @@ name?: string | undefined;
             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>;
-            }>>;
+            params: Writable<    {}>;
+            update: {
+                (key: string, value: unknown, options?: RouterPushOptions | undefined): Promise<void>;
+                (params: Partial<{}>, options?: RouterPushOptions | undefined): Promise<void>;
+            };
         }>;
         component: Component;
         rejection: {
@@ -1690,14 +1143,11 @@ name?: string | undefined;
             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>;
-            }>>;
+            params: Writable<    {}>;
+            update: {
+                (key: string, value: unknown, options?: RouterPushOptions | undefined): Promise<void>;
+                (params: Partial<{}>, options?: RouterPushOptions | undefined): Promise<void>;
+            };
         }>;
         component: Component;
         rejection: {
@@ -1714,57 +1164,34 @@ 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> = {
+declare type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = ResolvedRoute extends TRoute ? {
+    (key: string, value: unknown, options?: RouterPushOptions): Promise<void>;
+    (params: Partial<TRoute['params']>, options?: RouterPushOptions): Promise<void>;
+} : {
     <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;
 
+export declare function throwIfDuplicateParamsAreFound(routes: Route[]): void;
+
 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`
@@ -1833,9 +1260,17 @@ export declare function useRejection(): RouterRejection;
  * The function also sets up a reactive watcher on the route object from the router to continually check the validity of the route key
  * if provided, throwing an error if the validation fails at any point during the component's lifecycle.
  */
-export declare function useRoute<TRouteKey extends string & keyof RegisteredRouteMap>(routeKey: TRouteKey, options?: UseRouteOptions): RouterRoute<ResolvedRoute<RegisteredRouteMap[TRouteKey]>>;
+export declare function useRoute(): RegisteredRouterRoute;
+
+export declare function useRoute<TRouteKey extends RegisteredRoutesKey>(routeKey: TRouteKey, options: IsRouteOptions & {
+    exact: true;
+}): RegisteredRouterRoute & {
+    key: TRouteKey;
+};
 
-export declare function useRoute(): RouterRoute;
+export declare function useRoute<TRouteKey extends RegisteredRoutesKey>(routeKey: TRouteKey, options?: IsRouteOptions): RegisteredRouterRoute & {
+    key: `${TRouteKey}${string}`;
+};
 
 /**
  * An error thrown when there is a mismatch between an expected route and the one actually used.
@@ -1850,10 +1285,6 @@ export declare class UseRouteInvalidError extends Error {
     constructor(routeName: string, actualRouteName: string);
 }
 
-export declare type UseRouteOptions = {
-    exact?: boolean;
-};
-
 /**
  * A composition to access the registered router instance within a Vue component.
  *
@@ -1870,13 +1301,6 @@ 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.
@@ -1884,13 +1308,6 @@ 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>;
 
 /**
@@ -1905,32 +1322,14 @@ 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 { }