@kitbag/router 0.5.4 → 0.7.0

package/dist/kitbag-router.d.ts

@@ -88,6 +88,8 @@ export declare type AfterRouteHookResponse<TRoutes extends Routes> = RouteHookSu
 
 declare type AllPropertiesAreOptional<T> = Record<string, unknown> extends T ? true : IsEmptyObject<OnlyRequiredProperties<T>>;
 
+declare type AsNamedRoute<T extends Route> = IsRouteUnnamed<T> extends true ? never : T;
+
 /**
  * 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.
@@ -119,33 +121,7 @@ declare const builtInRejections: ['NotFound'];
 
 declare type BuiltInRejectionType = typeof builtInRejections[number];
 
-/**
- * Represents properties for child routes, including required component, name, and path.
- */
-export declare type ChildRouteProps = (WithComponent | WithComponents) & WithHooks & {
-    /**
-     * 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;
-    /**
-     * Represents additional metadata associated with a route, customizable via declaration merging.
-     */
-    meta?: RouteMeta;
-};
-
-declare type CombineName<TParentName extends string | undefined, TChildName extends string | undefined> = StringHasValue<TParentName> extends true ? StringHasValue<TChildName> extends true ? `${TParentName}.${TChildName}` : TParentName : StringHasValue<TChildName> extends true ? TChildName : '';
+declare type CombineKey<TParentKey extends string | undefined, TChildKey extends string | undefined> = StringHasValue<TParentKey> extends true ? StringHasValue<TChildKey> extends true ? `${TParentKey}.${TChildKey}` : TParentKey : StringHasValue<TChildKey> extends true ? TChildKey : '';
 
 declare type CombinePath<TParent extends Path, TChild extends Path> = ToPath<TParent> extends {
     path: infer TParentPath extends string;
@@ -153,15 +129,15 @@ declare type CombinePath<TParent extends Path, TChild extends Path> = ToPath<TPa
 } ? ToPath<TChild> extends {
     path: infer TChildPath extends string;
     params: infer TChildParams extends Record<string, unknown>;
-} ? MergeParams<RemoveLeadingQuestionMarkFromKeys<TParentParams>, RemoveLeadingQuestionMarkFromKeys<TChildParams>> extends PathParamsWithParamNameExtracted<`${TParentPath}${TChildPath}`> ? Path<`${TParentPath}${TChildPath}`, MergeParams<RemoveLeadingQuestionMarkFromKeys<TParentParams>, RemoveLeadingQuestionMarkFromKeys<TChildParams>>> : Path<'', {}> : Path<'', {}> : Path<'', {}>;
+} ? RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams> extends PathParamsWithParamNameExtracted<`${TParentPath}${TChildPath}`> ? Path<`${TParentPath}${TChildPath}`, RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams>> : Path<'', {}> : Path<'', {}> : Path<'', {}>;
 
-declare type CombineQuery<TParent extends Query | undefined, TChild extends Query | undefined> = ToQuery<TParent> extends {
+declare type CombineQuery<TParent extends Query, TChild extends Query> = ToQuery<TParent> extends {
     query: infer TParentQuery extends string;
     params: infer TParentParams extends Record<string, unknown>;
 } ? ToQuery<TChild> extends {
     query: infer TChildQuery extends string;
     params: infer TChildParams extends Record<string, unknown>;
-} ? MergeParams<RemoveLeadingQuestionMarkFromKeys<TParentParams>, RemoveLeadingQuestionMarkFromKeys<TChildParams>> extends QueryParamsWithParamNameExtracted<CombineQueryString<TParentQuery, TChildQuery>> ? Query<CombineQueryString<TParentQuery, TChildQuery>, MergeParams<RemoveLeadingQuestionMarkFromKeys<TParentParams>, RemoveLeadingQuestionMarkFromKeys<TChildParams>>> : Query<'', {}> : Query<'', {}> : Query<'', {}>;
+} ? RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams> extends QueryParamsWithParamNameExtracted<CombineQueryString<TParentQuery, TChildQuery>> ? Query<CombineQueryString<TParentQuery, TChildQuery>, RemoveLeadingQuestionMarkFromKeys<TParentParams> & RemoveLeadingQuestionMarkFromKeys<TChildParams>> : Query<'', {}> : Query<'', {}> : Query<'', {}>;
 
 declare type CombineQueryString<TParent extends string | undefined, TChild extends string | undefined> = StringHasValue<TParent> extends true ? StringHasValue<TChild> extends true ? `${TParent}&${TChild}` : TParent : TChild;
 
@@ -174,22 +150,26 @@ declare type CombineQueryString<TParent extends string | undefined, TChild exten
  *
  * @example
  * ```ts
- * import { createRoutes, component } from '@kitbag/router'
+ * import { createRoute, component } from '@kitbag/router'
  *
- * export const routes = createRoutes([
- *   {
- *     name: 'User',
- *     path: '/',
- *     component: component(User, () => ({ userId: 1 }))
- *   },
- * ])
+ * export const routes = createRoute({
+ *   name: 'User',
+ *   path: '/',
+ *   component: component(User, () => ({ userId: 1 }))
+ * })
  * ```
  */
-export declare function component<TComponent extends Component>(component: TComponent, props: PropsGetter<TComponent>): Component;
+export declare function component<TComponent extends Component>(component: TComponent, props: ComponentPropsGetter<TComponent>): Component;
+
+export 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 : never;
+
+declare type ComponentPropsGetter<TComponent extends Component> = () => MaybePromise<ComponentProps<TComponent>>;
 
 declare type Constructor = new (...args: any) => any;
 
-export declare function createExternalRoutes<const TRoutes extends ExternalRouteProps[]>(routes: TRoutes): FlattenRoutes<TRoutes>;
+export declare function createExternalRoute<const THost extends string | Host, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined>(options: CreateRouteOptions<TName, TPath, TQuery> & WithHost<THost> & WithoutParent): Route<ToKey<TName>, ToHost<THost>, ToPath<TPath>, ToQuery<TQuery>>;
+
+export declare function createExternalRoute<const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined>(options: CreateRouteOptions<TName, TPath, TQuery> & WithoutHost & WithParent<TParent>): Route<CombineKey<TParent['key'], ToKey<TName>>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>>;
 
 export declare function createParam<TParam extends ParamWithDefault>(param: TParam): TParam;
 
@@ -197,25 +177,63 @@ export declare function createParam<TParam extends Param>(param: TParam): ParamG
 
 export declare function createParam<TParam extends Param>(param: TParam, defaultValue: ExtractParamType<TParam>): ParamWithDefault<TParam>;
 
+export declare function createRoute<const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithoutComponents & WithoutParent): Route<ToKey<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>>;
+
+export declare function createRoute<const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithoutComponents & WithParent<TParent>): Route<CombineKey<TParent['key'], ToKey<TName>>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>>;
+
+export declare function createRoute<TComponent extends Component, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponent<TComponent, RouteParams<TPath, TQuery>> & WithoutParent): Route<ToKey<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>>;
+
+export declare function createRoute<TComponent extends Component, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponent<TComponent, RouteParams<TPath, TQuery, TParent>> & WithParent<TParent>): Route<CombineKey<TParent['key'], ToKey<TName>>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>>;
+
+export declare function createRoute<TComponents extends Record<string, Component>, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponents<TComponents, RouteParams<TPath, TQuery>> & WithoutParent): Route<ToKey<TName>, Host<'', {}>, ToPath<TPath>, ToQuery<TQuery>>;
+
+export declare function createRoute<TComponents extends Record<string, Component>, const TParent extends Route, const TName extends string | undefined = undefined, const TPath extends string | Path | undefined = undefined, const TQuery extends string | Query | undefined = undefined, const TMeta extends RouteMeta = RouteMeta>(options: CreateRouteOptions<TName, TPath, TQuery, TMeta> & WithHooks & WithComponents<TComponents, RouteParams<TPath, TQuery, TParent>> & WithParent<TParent>): Route<CombineKey<TParent['key'], ToKey<TName>>, Host<'', {}>, CombinePath<TParent['path'], ToPath<TPath>>, CombineQuery<TParent['query'], ToQuery<TQuery>>>;
+
+export declare type CreateRouteOptions<TName extends string | undefined = string | undefined, TPath extends string | Path | undefined = string | Path | undefined, TQuery extends string | Query | undefined = string | Query | undefined, TMeta extends RouteMeta = RouteMeta> = {
+    /**
+     * 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;
+    /**
+     * Represents additional metadata associated with a route, customizable via declaration merging.
+     */
+    meta?: TMeta;
+};
+
+/**
+ * The Route properties originally provided to `createRoute`. The only change is normalizing meta to always default to an empty object.
+ */
+export declare type CreateRouteOptionsMatched = CreateRouteOptions & WithHooks & (WithHost | WithoutHost) & (WithComponent | WithComponents | WithoutComponents) & (WithParent | WithoutParent) & {
+    meta: RouteMeta;
+};
+
 /**
  * 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 createRoutes method to create the route definitions.
+ * 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 { createRoutes, createRouter } from '@kitbag/router'
+ * import { createRoute, createRouter } from '@kitbag/router'
  *
  * const Home = { template: '<div>Home</div>' }
  * const About = { template: '<div>About</div>' }
  *
- * export const routes = createRoutes([
- *   { name: 'home', path: '/', component: Home },
- *   { name: 'path', path: '/about', component: About },
- * ])
+ * export const routes = [
+ *   createRoute({ name: 'home', path: '/', component: Home }),
+ *   createRoute({ name: 'path', path: '/about', component: About }),
+ * ]
  *
  * const router = createRouter(routes)
  * ```
@@ -224,15 +242,6 @@ export declare function createRouter<const T extends Routes>(routes: T, options?
 
 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.
- *
- * @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 RouteProps[]>(routes: TRoutes): FlattenRoutes<TRoutes>;
-
 /**
  * An error thrown when duplicate parameters are detected in a route when creating a router.
  * When defining routes, param names must be unique. This includes params defined in a path
@@ -246,78 +255,20 @@ export declare class DuplicateParamsError extends Error {
     constructor(paramName: string);
 }
 
-declare type ExternalChildRoutes = Route<string, never>[];
-
-declare type ExternalRouteChildProps = {
-    /**
-     * Represents the host for this route. Used for external routes.
-     */
-    host?: string | Host;
-    /**
-     * 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 | Host;
-    /**
-     * 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: ExternalChildRoutes;
-};
-
-declare type ExternalRouteProps = ExternalRouteParentProps | ExternalRouteChildProps;
-
 /**
  * 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 PropertyKey> = TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam;
+declare type ExtractParamName<TParam extends PropertyKey> = TParam extends `?${infer Param}` ? Param extends '' ? never : Param : TParam extends '' ? never : TParam;
 
-declare type ExtractParamsFromHostString<THost extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = THost extends `${string}${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? MergeParams<{
+declare type ExtractParamsFromHostString<THost extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = THost extends `${string}${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? {
     [P in Param]: ExtractPathParamType<Param, TParams>;
-}, ExtractParamsFromHostString<Rest, TParams>> : Record<never, never>;
+} & ExtractParamsFromHostString<Rest, TParams> : Record<never, never>;
 
-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<{
+declare type ExtractParamsFromPathString<TPath extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TPath extends `${string}${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? {
     [P in Param]: ExtractPathParamType<Param, TParams>;
-}, ExtractParamsFromPathString<Rest, TParams>> : Record<never, never>;
+} & ExtractParamsFromPathString<Rest, TParams> : Record<never, never>;
 
 /**
  * Extracts the actual type from a parameter type, handling getters, setters, and potential undefined values.
@@ -325,14 +276,14 @@ declare type ExtractParamsFromPathString<TPath extends string, TParams extends R
  * @template TParam - The parameter type.
  * @returns The extracted type, or 'string' as a fallback.
  */
-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;
+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.
  * @template TParams - The record of parameter types, possibly including undefined.
  * @returns A new type with the appropriate properties marked as optional.
  */
-export declare type ExtractParamTypes<TParams extends Record<string, Param>> = Identity<MakeOptional<{
+declare type ExtractParamTypes<TParams extends Record<string, Param>> = Identity<MakeOptional<{
     [K in keyof TParams as ExtractParamName<K>]: ExtractParamType<TParams[K], K>;
 }>>;
 
@@ -348,13 +299,11 @@ declare type ExtractParamTypeWithoutLosingOptional<TParam extends Param, TParamK
  * @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] : StringConstructor : TParam extends keyof TParams ? TParams[TParam] : StringConstructor;
+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<{
+declare type ExtractQueryParamsFromQueryString<TQuery extends string, TParams extends Record<string, Param | undefined> = Record<never, never>> = TQuery extends `${string}=${ParamStart}${infer Param}${ParamEnd}${infer Rest}` ? {
     [P in Param]: ExtractPathParamType<Param, TParams>;
-}, ExtractQueryParamsFromQueryString<Rest, TParams>> : Record<never, never>;
-
-declare type ExtractRouteChildren<TRoute extends RouteProps | ExternalRouteProps> = TRoute extends ParentRouteProps ? TRoute['children'] extends Route[] ? TRoute['children'] : [] : [];
+} & ExtractQueryParamsFromQueryString<Rest, TParams> : Record<never, never>;
 
 /**
  * Extracts combined types of path and query parameters for a given route, creating a unified parameter object.
@@ -362,14 +311,17 @@ declare type ExtractRouteChildren<TRoute extends RouteProps | ExternalRouteProps
  * @template TRoute - The route type from which to extract and merge parameter types.
  * @returns A record of parameter names to their respective types, extracted and merged from both path and query parameters.
  */
-export declare type ExtractRouteParamTypes<TRoute> = TRoute extends {
+declare type ExtractRouteParamTypes<TRoute> = TRoute extends {
     path: {
         params: infer PathParams extends Record<string, Param>;
     };
     query: {
         params: infer QueryParams extends Record<string, Param>;
     };
-} ? ExtractParamTypes<MergeParams<PathParams, QueryParams>> : {};
+    host: {
+        params: infer HostParams extends Record<string, Param>;
+    };
+} ? ExtractParamTypes<HostParams & PathParams & QueryParams> : {};
 
 declare type ExtractRouteParamTypesWithoutLosingOptional<TRoute> = TRoute extends {
     host: {
@@ -381,26 +333,7 @@ declare type ExtractRouteParamTypesWithoutLosingOptional<TRoute> = TRoute extend
     query: {
         params: infer QueryParams extends Record<string, Param>;
     };
-} ? ExtractParamTypesWithoutLosingOptional<MergeParams<HostParams, MergeParams<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 | ExternalRouteProps, TKey extends string = TRoute extends {
-    name: infer T extends string;
-} ? T : '', THost extends Host = TRoute extends {
-    host: infer T extends Host | string;
-} ? ToHost<T> : never, 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']>, THost, CombinePath<TPath, TChildren[K]['path']>, CombineQuery<TQuery, TChildren[K]['query']>, TChildren[K]['disabled']>;
-}
-];
-
-declare type FlattenRoutes<TRoutes extends Readonly<RouteProps[] | ExternalRouteProps[]>> = Flatten<[
-...{
-    [K in keyof TRoutes]: FlattenRoute<TRoutes[K]>;
-}
-]>;
+} ? ExtractParamTypesWithoutLosingOptional<HostParams & PathParams & QueryParams> : Record<string, unknown>;
 
 declare type Host<THost extends string = string, TParams extends HostParamsWithParamNameExtracted<THost> = Record<string, Param | undefined>> = {
     host: THost;
@@ -418,31 +351,8 @@ declare type Identity<T> = T extends object ? {} & {
 
 declare type IsEmptyObject<T> = T extends Record<string, never> ? (keyof T extends never ? true : false) : false;
 
-/**
- * Type guard to check if a value conforms to the ParamGetSet type.
- * @param value - The value to check.
- * @returns True if the value is an object with both 'get' and 'set' functions defined.
- */
-export declare function isParamGetSet(value: Param): value is ParamGetSet;
-
-/**
- * Type guard to check if a value conforms to the ParamGetter type.
- * @param value - The value to check.
- * @returns True if the value is a function that is not a constructor.
- */
-export declare function isParamGetter(value: Param): value is ParamGetter;
-
 export declare function isParamWithDefault(param: Param): param is ParamWithDefault;
 
-/**
- * Type guard function to determine if a given route configuration is a parent route, based on the presence of children.
- * @param value - The route configuration to check.
- * @returns True if the route configuration has children, indicating it is a parent route.
- */
-export declare function isParentRoute(value: RouteProps): value is ParentRouteProps;
-
-export declare function isParentRouteWithoutComponent(value: RouteProps): value is Omit<ParentRouteProps, 'component' | 'components'>;
-
 export declare function isRoute(route: unknown): route is RouterRoute;
 
 export declare function isRoute<TRoute extends RouterRoute, TRouteKey extends TRoute['key']>(route: TRoute, routeKey: TRouteKey, options: IsRouteOptions & {
@@ -467,24 +377,12 @@ export declare function isRoute<TRouteKey extends RegisteredRoutesKey>(route: un
 
 export declare function isRoute(route: unknown, routeKey?: string, options?: IsRouteOptions): boolean;
 
-declare type IsRouteDisabled<T extends Route> = T extends {
-    disabled: true;
-} ? true : false;
-
 declare type IsRouteOptions = {
     exact?: boolean;
 };
 
 declare type IsRouteUnnamed<T extends Route> = StringHasValue<T['key']> extends true ? false : true;
 
-export declare function isRouteWithComponent(value: RouteProps): value is RouteProps & WithComponent;
-
-export declare function isRouteWithComponent(value: Readonly<RouteProps>): value is Readonly<RouteProps & WithComponent>;
-
-export declare function isRouteWithComponents(value: RouteProps): value is RouteProps & WithComponents;
-
-export declare function isRouteWithComponents(value: Readonly<RouteProps>): value is Readonly<RouteProps & WithComponents>;
-
 declare type MakeOptional<T> = {
     [P in WithOptionalProperties<T>]?: T[P];
 } & {
@@ -495,16 +393,6 @@ declare type MaybeArray<T> = T | T[];
 
 declare type MaybePromise<T> = T | Promise<T>;
 
-/**
- * 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.
- */
-export declare type MergeParams<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;
-};
-
 /**
  * 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.
@@ -556,9 +444,9 @@ declare type OnlyRequiredProperties<T> = {
 
 export declare type Param = ParamGetter | ParamGetSet | RegExp | BooleanConstructor | NumberConstructor | StringConstructor | DateConstructor | JSON;
 
-export declare type ParamEnd = typeof paramEnd;
+declare type ParamEnd = typeof paramEnd;
 
-export declare const paramEnd = "]";
+declare const paramEnd = "]";
 
 export declare type ParamExtras = {
     invalid: (message?: string) => never;
@@ -574,41 +462,15 @@ export declare type ParamGetter<T = any> = (value: string, extras: ParamExtras)
 
 export declare type ParamSetter<T = any> = (value: T, extras: ParamExtras) => string;
 
-export declare type ParamStart = typeof paramStart;
+declare type ParamStart = typeof paramStart;
 
-export declare const paramStart = "[";
+declare const paramStart = "[";
 
 export declare type ParamWithDefault<TParam extends Param = Param> = Required<ParamGetSet<ExtractParamType<TParam>>>;
 
-/**
- * Represents properties common to parent routes in a route configuration, including hooks, path, and optional query parameters.
- */
-export declare type ParentRouteProps = Partial<WithComponent | WithComponents> & WithHooks & {
-    /**
-     * Name for route, used to create route keys and in navigation.
-     */
-    name?: string;
-    /**
-     * Path part of URL.
-     */
-    path?: string | Path;
-    /**
-     * Query (aka search) part of URL.
-     */
-    query?: string | Query;
-    /**
-     * 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;
-    /**
-     * Represents additional metadata associated with a route, customizable via declaration merging.
-     */
-    meta?: RouteMeta;
-};
+declare type ParentPath<TParent extends Route | undefined> = TParent extends Route ? TParent['path'] : Path<'', {}>;
+
+declare type ParentQuery<TParent extends Route | undefined> = TParent extends Route ? TParent['query'] : Query<'', {}>;
 
 declare type Path<TPath extends string = string, TParams extends PathParamsWithParamNameExtracted<TPath> = Record<string, Param | undefined>> = {
     path: TPath;
@@ -628,15 +490,13 @@ declare type Path<TPath extends string = string, TParams extends PathParamsWithP
  *
  * @example
  * ```ts
- * import { createRoutes, path } from '@kitbag/router'
+ * import { createRoute, path } from '@kitbag/router'
  *
- * export const routes = createRoutes([
- *   {
- *     name: 'home',
- *     path: path('/[foo]', { foo: Number }),
- *     component: Home
- *   },
- * ])
+ * export const routes = createRoute({
+ *   name: 'home',
+ *   path: path('/[foo]', { foo: Number }),
+ *   component: Home
+ * })
  * ```
  */
 export declare function path<TPath extends string, TParams extends PathParamsWithParamNameExtracted<TPath>>(path: TPath, params: Identity<TParams>): Path<TPath, TParams>;
@@ -645,10 +505,6 @@ 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 QueryParamsWithParamNameExtracted<TQuery> = Record<string, Param | undefined>> = {
     query: TQuery;
     params: string extends TQuery ? Record<string, Param> : Identity<ExtractQueryParamsFromQueryString<TQuery, TQueryParams>>;
@@ -667,15 +523,13 @@ declare type Query<TQuery extends string = string, TQueryParams extends QueryPar
  *
  * @example
  * ```ts
- * import { createRoutes, query } from '@kitbag/router'
+ * import { createRoute, query } from '@kitbag/router'
  *
- * export const routes = createRoutes([
- *   {
- *     name: 'home',
- *     query: query('bar=[bar]', { bar: Boolean }),
- *     component: Home
- *   },
- * ])
+ * export const routes = createRoute({
+ *   name: 'home',
+ *   query: query('bar=[bar]', { bar: Boolean }),
+ *   component: Home
+ * })
  * ```
  */
 export declare function query<TQuery extends string, TParams extends QueryParamsWithParamNameExtracted<TQuery>>(query: TQuery, params: Identity<TParams>): Query<TQuery, TParams>;
@@ -685,7 +539,7 @@ declare type QueryParamsWithParamNameExtracted<T extends string> = {
 };
 
 /**
- * Represents the state of currently registered router, and rejections. Used to provide correct type context for
+ * Represents the state of currently registered router, rejections, and route meta. Used to provide correct type context for
  * components like `RouterLink`, as well as for composables like `useRouter`, `useRoute`, and hooks.
  *
  * @example
@@ -693,6 +547,8 @@ declare type QueryParamsWithParamNameExtracted<T extends string> = {
  * declare module '@kitbag/router' {
  *   interface Register {
  *     router: typeof router
+ *     rejections: ["NotAuthorized"],
+ *     routeMeta: { public?: boolean }
  *   }
  * }
  * ```
@@ -734,19 +590,12 @@ export declare type RegisteredRouterReplace = RouterReplace<RegisteredRoutes>;
  */
 export declare type RegisteredRouterRoute = RegisteredRouter['route'];
 
-/**
- * Represents the State property registered within {@link Register}
- */
-export declare type RegisteredRouterState = Register extends {
-    state: infer TState;
-} ? TState : {};
-
 /**
  * Represents the Router routes property within {@link Register}
  */
 export declare type RegisteredRoutes = Register extends {
     router: Router<infer TRoutes extends Routes>;
-} ? TRoutes : Route<string, Host, Path, Query, false>[];
+} ? TRoutes : Route[];
 
 /**
  * Represents the union of all possible RouteKeys registered within {@link Register}
@@ -793,22 +642,23 @@ declare type ResolvedRouteQuery = {
 };
 
 /**
- * Represents the structure of a route within the application. Return value of `createRoutes`
+ * Represents the structure of a route within the application. Return value of `createRoute`
  * @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.
  */
-export declare type Route<TKey extends string = string, THost extends Host = Host, TPath extends Path = Path, TQuery extends Query = Query, TDisabled extends boolean = boolean> = {
+export declare type Route<TKey extends string = string, THost extends Host = Host, TPath extends Path = Path, TQuery extends Query = Query, TMeta extends RouteMeta = RouteMeta> = {
     /**
      * The specific route properties that were matched in the current route.
      */
-    matched: RoutePropsWithMeta;
+    matched: CreateRouteOptionsMatched & {
+        meta: TMeta;
+    };
     /**
      * 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[];
+    matches: CreateRouteOptionsMatched[];
     /**
      * Unique identifier for the route, generated by joining route `name` by period. Key is used for routing and for matching.
      */
@@ -826,10 +676,6 @@ export declare type Route<TKey extends string = string, THost extends Host = Hos
      */
     query: TQuery;
     depth: number;
-    /**
-     * Indicates if the route is disabled.
-     */
-    disabled: TDisabled;
 };
 
 declare type RouteGetByKey<TRoutes extends Routes, TKey extends RoutesKey<TRoutes>> = RoutesMap<TRoutes>[TKey];
@@ -901,35 +747,16 @@ declare type RouteHookSuccessResponse = {
     status: 'SUCCESS';
 };
 
-declare type RouteIsNamedAndNotDisabled<T extends Route> = IsRouteDisabled<T> extends true ? never : IsRouteUnnamed<T> extends true ? never : T;
-
 /**
  * Represents additional metadata associated with a route, customizable via declaration merging.
- * @example
- * ```ts
- * declare module '@kitbag/router' {
- *   interface RouteMeta {
- *     pageTitle?: string
- *   }
- * }
- * ```
  */
-export declare interface RouteMeta extends Record<string, unknown> {
-}
+export declare type RouteMeta = Register extends {
+    routeMeta: infer RouteMeta extends Record<string, unknown>;
+} ? RouteMeta : Record<string, unknown>;
 
-declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypesWithoutLosingOptional<RouteGetByKey<TRoutes, TKey>>;
+declare type RouteParams<TPath extends string | Path | undefined, TQuery extends string | Query | undefined, TParent extends Route | undefined = undefined> = ExtractParamTypes<Identity<CombinePath<ParentPath<TParent>, ToPath<TPath>>['params'] & CombineQuery<ParentQuery<TParent>, ToQuery<TQuery>>['params']>>;
 
-/**
- * Unifies the properties of both parent and child routes, ensuring type safety and consistency across route configurations.
- */
-export declare type RouteProps = Readonly<ParentRouteProps | ChildRouteProps>;
-
-/**
- * The Route properties originally provided to `createRoutes`. The only change is normalizing meta to always default to an empty object.
- */
-export declare type RoutePropsWithMeta = RouteProps & {
-    meta: RouteMeta;
-};
+declare type RouteParamsByKey<TRoutes extends Routes, TKey extends string> = ExtractRouteParamTypesWithoutLosingOptional<RouteGetByKey<TRoutes, TKey>>;
 
 export declare type Router<TRoutes extends Routes = any> = Plugin_2 & {
     /**
@@ -1131,13 +958,21 @@ name?: string | undefined;
     default?: ((props: {
         route: Readonly<{
             key: string;
-            matched: RoutePropsWithMeta;
-            matches: RoutePropsWithMeta[];
+            matched: CreateRouteOptionsMatched & {
+                meta: Record<string, unknown>;
+            };
+            matches: CreateRouteOptionsMatched[];
             query: ResolvedRouteQuery;
-            params: Writable<    {}>;
+            params: Writable<    {
+            [x: string]: any;
+            [x: number]: any;
+            }>;
             update: {
                 (key: string, value: unknown, options?: RouterPushOptions | undefined): Promise<void>;
-                (params: Partial<{}>, options?: RouterPushOptions | undefined): Promise<void>;
+                (params: Partial<{
+                    [x: string]: any;
+                    [x: number]: any;
+                }>, options?: RouterPushOptions | undefined): Promise<void>;
             };
         }>;
         component: Component;
@@ -1152,13 +987,21 @@ name?: string | undefined;
     default?: ((props: {
         route: Readonly<{
             key: string;
-            matched: RoutePropsWithMeta;
-            matches: RoutePropsWithMeta[];
+            matched: CreateRouteOptionsMatched & {
+                meta: Record<string, unknown>;
+            };
+            matches: CreateRouteOptionsMatched[];
             query: ResolvedRouteQuery;
-            params: Writable<    {}>;
+            params: Writable<    {
+            [x: string]: any;
+            [x: number]: any;
+            }>;
             update: {
                 (key: string, value: unknown, options?: RouterPushOptions | undefined): Promise<void>;
-                (params: Partial<{}>, options?: RouterPushOptions | undefined): Promise<void>;
+                (params: Partial<{
+                    [x: string]: any;
+                    [x: number]: any;
+                }>, options?: RouterPushOptions | undefined): Promise<void>;
             };
         }>;
         component: Component;
@@ -1172,14 +1015,14 @@ name?: string | undefined;
 }>;
 
 /**
- * Represents an immutable array of Route instances. Return value of `createRoutes`, expected param for `createRouter`.
+ * Represents an immutable array of Route instances. Return value of `createRoute`, expected param for `createRouter`.
  */
 export declare type Routes = Readonly<Route[]>;
 
 declare type RoutesKey<TRoutes extends Routes> = string & keyof RoutesMap<TRoutes>;
 
 declare type RoutesMap<TRoutes extends Routes = []> = {
-    [K in TRoutes[number] as RouteIsNamedAndNotDisabled<K>['key']]: RouteIsNamedAndNotDisabled<K>;
+    [K in TRoutes[number] as AsNamedRoute<K>['key']]: AsNamedRoute<K>;
 };
 
 declare type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = ResolvedRoute extends TRoute ? {
@@ -1192,11 +1035,11 @@ declare type RouteUpdate<TRoute extends ResolvedRoute = ResolvedRoute> = Resolve
 
 declare type StringHasValue<T> = string extends T ? true : '' extends T ? false : T extends string ? true : false;
 
-export declare function throwIfDuplicateParamsAreFound(routes: Route[]): void;
-
 declare type ToCallback = (resolve: RegisteredRouter['resolve']) => string;
 
-declare type ToHost<T extends string | Host> = T extends string ? Host<T, {}> : T;
+declare type ToHost<T extends string | Host | undefined> = T extends string ? Host<T, {}> : T extends undefined ? Host<'', {}> : unknown extends T ? Host<'', {}> : T;
+
+declare type ToKey<T extends string | undefined> = T extends string ? T : '';
 
 declare type ToPath<T extends string | Path | undefined> = T extends string ? Path<T, {}> : T extends undefined ? Path<'', {}> : unknown extends T ? Path<'', {}> : T;
 
@@ -1306,18 +1149,22 @@ export declare class UseRouteInvalidError extends Error {
  */
 export declare function useRouter(): RegisteredRouter;
 
-declare type WithComponent = {
+declare type WithComponent<TComponent extends Component = Component, TParams extends Record<string, unknown> = Record<string, unknown>> = {
     /**
      * A Vue component, which can be either synchronous or asynchronous components.
      */
-    component: Component;
+    component: TComponent;
+    props?: (params: TParams) => TComponent extends Component ? MaybePromise<ComponentProps<TComponent>> : {};
 };
 
-declare type WithComponents = {
+declare type WithComponents<TComponents extends Record<string, Component> = Record<string, Component>, TParams extends Record<string, unknown> = Record<string, unknown>> = {
     /**
      * Multiple components for named views, which can be either synchronous or asynchronous components.
      */
-    components: Record<string, Component>;
+    components: TComponents;
+    props?: {
+        [TKey in keyof TComponents]?: (params: TParams) => TComponents[TKey] extends Component ? MaybePromise<ComponentProps<TComponents[TKey]>> : {};
+    };
 };
 
 export declare function withDefault<TParam extends Param>(param: TParam, defaultValue: ExtractParamType<TParam>): ParamWithDefault<TParam>;
@@ -1334,10 +1181,35 @@ declare type WithHooks = {
     onAfterRouteLeave?: MaybeArray<AfterRouteHook>;
 };
 
+declare type WithHost<THost extends string | Host = string | Host> = {
+    /**
+     * Host part of URL.
+     */
+    host: THost;
+};
+
 declare type WithOptionalProperties<T> = {
     [P in keyof T]-?: undefined extends T[P] ? P : never;
 }[keyof T];
 
+declare type WithoutComponents = {
+    component?: never;
+    components?: never;
+    props?: never;
+};
+
+declare type WithoutHost = {
+    host?: never;
+};
+
+declare type WithoutParent = {
+    parent?: never;
+};
+
+declare type WithParent<TParent extends Route = Route> = {
+    parent: TParent;
+};
+
 declare type Writable<T> = {
     -readonly [P in keyof T]: T[P];
 };