@devp0nt/route0 1.0.0-next.7 → 1.0.0-next.71

package/dist/cjs/index.d.cts

@@ -1,99 +1,447 @@
-declare class Route0<TPathOriginalDefinition extends string, TPathDefinition extends Route0._PathDefinition<TPathOriginalDefinition>, TParamsDefinition extends Route0._ParamsDefinition<TPathOriginalDefinition>, TQueryDefinition extends Route0._QueryDefinition<TPathOriginalDefinition>> {
-    pathOriginalDefinition: TPathOriginalDefinition;
-    private readonly pathDefinition;
-    paramsDefinition: TParamsDefinition;
-    queryDefinition: TQueryDefinition;
-    baseUrl: string;
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+type PathToken = {
+    kind: 'static';
+    value: string;
+} | {
+    kind: 'param';
+    name: string;
+    optional: boolean;
+} | {
+    kind: 'wildcard';
+    prefix: string;
+    optional: boolean;
+};
+/**
+ * Strongly typed route descriptor and URL builder.
+ *
+ * A route definition uses:
+ * - path params: `/users/:id`
+ * - named search keys: `/users&tab&sort`
+ * - loose search mode: trailing `&`, e.g. `/users&`
+ *
+ * Instances are callable (same as `.get()`), so `route(input)` and
+ * `route.get(input)` are equivalent.
+ */
+declare class Route0<TDefinition extends string, TSearchInput extends UnknownSearchInput = UnknownSearchInput> {
+    readonly definition: TDefinition;
+    readonly params: _ParamsDefinition<TDefinition>;
+    private _origin;
+    private _callable;
+    Infer: {
+        ParamsDefinition: _ParamsDefinition<TDefinition>;
+        ParamsInput: _ParamsInput<TDefinition>;
+        ParamsInputStringOnly: _ParamsInputStringOnly<TDefinition>;
+        ParamsOutput: ParamsOutput<TDefinition>;
+        SearchInput: TSearchInput;
+    };
+    /** Base URL used when generating absolute URLs (`abs: true`). */
+    get origin(): string;
+    set origin(origin: string);
     private constructor();
-    static create<TPathOriginalDefinition extends string, TPathDefinition extends Route0._PathDefinition<TPathOriginalDefinition>, TParamsDefinition extends Route0._ParamsDefinition<TPathOriginalDefinition>, TQueryDefinition extends Route0._QueryDefinition<TPathOriginalDefinition>>(definition: TPathOriginalDefinition, config?: Route0.RouteConfigInput): Route0.Callable<Route0<TPathOriginalDefinition, TPathDefinition, TParamsDefinition, TQueryDefinition>>;
-    private static _splitPathDefinitionAndQueryTailDefinition;
+    /**
+     * Creates a callable route instance.
+     *
+     * If an existing route/callable route is provided, it is cloned.
+     */
+    static create<TDefinition extends string>(definition: TDefinition | AnyRoute<TDefinition> | CallableRoute<TDefinition>, config?: RouteConfigInput): CallableRoute<TDefinition>;
+    /**
+     * Normalizes a definition/route into a callable route.
+     *
+     * Unlike `create`, passing a callable route returns the same instance.
+     */
+    static from<TDefinition extends string, TSearchInput extends UnknownSearchInput>(definition: TDefinition | AnyRoute<TDefinition, TSearchInput> | CallableRoute<TDefinition, TSearchInput>): CallableRoute<TDefinition, TSearchInput>;
     private static _getAbsPath;
-    private static _getPathDefinitionByOriginalDefinition;
-    private static _getParamsDefinitionByRouteDefinition;
-    private static _getQueryDefinitionByRouteDefinition;
-    static overrideMany<T extends Record<string, Route0<any, any, any, any>>>(routes: T, config: Route0.RouteConfigInput): T;
-    extend<TSuffixDefinition extends string>(suffixDefinition: TSuffixDefinition): Route0.Callable<Route0<Route0._RoutePathOriginalDefinitionExtended<TPathOriginalDefinition, TSuffixDefinition>, Route0._PathDefinition<Route0._RoutePathOriginalDefinitionExtended<TPathOriginalDefinition, TSuffixDefinition>>, Route0._ParamsDefinition<Route0._RoutePathOriginalDefinitionExtended<TPathOriginalDefinition, TSuffixDefinition>>, Route0._QueryDefinition<Route0._RoutePathOriginalDefinitionExtended<TPathOriginalDefinition, TSuffixDefinition>>>>;
-    get(input: Route0._OnlyIfHasParams<TParamsDefinition, Route0._WithParamsInput<TParamsDefinition, {
-        query?: undefined;
-        abs?: false;
-    }>>): Route0._OnlyIfHasParams<TParamsDefinition, Route0._PathOnlyRouteValue<TPathOriginalDefinition>>;
-    get(input: Route0._OnlyIfHasParams<TParamsDefinition, Route0._WithParamsInput<TParamsDefinition, {
-        query: Route0._QueryInput<TQueryDefinition>;
-        abs?: false;
-    }>>): Route0._OnlyIfHasParams<TParamsDefinition, Route0._WithQueryRouteValue<TPathOriginalDefinition>>;
-    get(input: Route0._OnlyIfHasParams<TParamsDefinition, Route0._WithParamsInput<TParamsDefinition, {
-        query?: undefined;
-        abs: true;
-    }>>): Route0._OnlyIfHasParams<TParamsDefinition, Route0._AbsolutePathOnlyRouteValue<TPathOriginalDefinition>>;
-    get(input: Route0._OnlyIfHasParams<TParamsDefinition, Route0._WithParamsInput<TParamsDefinition, {
-        query: Route0._QueryInput<TQueryDefinition>;
-        abs: true;
-    }>>): Route0._OnlyIfHasParams<TParamsDefinition, Route0._AbsoluteWithQueryRouteValue<TPathOriginalDefinition>>;
-    get(...args: Route0._OnlyIfNoParams<TParamsDefinition, [], [never]>): Route0._PathOnlyRouteValue<TPathOriginalDefinition>;
-    get(input: Route0._OnlyIfNoParams<TParamsDefinition, {
-        query?: undefined;
-        abs?: false;
-    }>): Route0._OnlyIfNoParams<TParamsDefinition, Route0._PathOnlyRouteValue<TPathOriginalDefinition>>;
-    get(input: Route0._OnlyIfNoParams<TParamsDefinition, {
-        query: Route0._QueryInput<TQueryDefinition>;
-        abs?: false;
-    }>): Route0._OnlyIfNoParams<TParamsDefinition, Route0._WithQueryRouteValue<TPathOriginalDefinition>>;
-    get(input: Route0._OnlyIfNoParams<TParamsDefinition, {
-        query?: undefined;
-        abs: true;
-    }>): Route0._OnlyIfNoParams<TParamsDefinition, Route0._AbsolutePathOnlyRouteValue<TPathOriginalDefinition>>;
-    get(input: Route0._OnlyIfNoParams<TParamsDefinition, {
-        query: Route0._QueryInput<TQueryDefinition>;
-        abs: true;
-    }>): Route0._OnlyIfNoParams<TParamsDefinition, Route0._AbsoluteWithQueryRouteValue<TPathOriginalDefinition>>;
-    getDefinition(): TPathDefinition;
-    clone(config?: Route0.RouteConfigInput): Route0<TPathOriginalDefinition, Route0._TrimQueryTailDefinition<TPathOriginalDefinition>, Route0._ParamsDefinition<TPathOriginalDefinition>, Route0._QueryDefinition<TPathOriginalDefinition>>;
+    private static _getParamsDefinitionByDefinition;
+    search<TNewSearchInput extends UnknownSearchInput>(): CallableRoute<TDefinition, TNewSearchInput>;
+    /** Extends the current route definition by appending a suffix route. */
+    extend<TSuffixDefinition extends string>(suffixDefinition: TSuffixDefinition): CallableRoute<PathExtended<TDefinition, TSuffixDefinition>, TSearchInput>;
+    get(...args: IsParamsOptional<TDefinition> extends true ? [abs: boolean | string | undefined] : never): string;
+    get(...args: IsParamsOptional<TDefinition> extends true ? [
+        input?: (_ParamsInput<TDefinition> & {
+            '?'?: TSearchInput;
+            '#'?: string | number;
+        }) | undefined,
+        abs?: boolean | string | undefined
+    ] : [
+        input: _ParamsInput<TDefinition> & {
+            '?'?: TSearchInput;
+            '#'?: string | number;
+        },
+        abs?: boolean | string | undefined
+    ]): string;
+    /** Returns path param keys extracted from route definition. */
+    getParamsKeys(): string[];
+    getPathTokens(): PathToken[];
+    /** Clones route with optional config override. */
+    clone(config?: RouteConfigInput): CallableRoute<TDefinition>;
+    getRegexBaseStrictString(): string;
+    getRegexBaseString(): string;
+    getRegexStrictString(): string;
+    getRegexString(): string;
+    getRegexStrict(): RegExp;
+    getRegex(): RegExp;
+    /** Creates a grouped strict regex pattern string from many routes. */
+    static getRegexStrictStringGroup(routes: AnyRoute[]): string;
+    /** Creates a strict grouped regex from many routes. */
+    static getRegexStrictGroup(routes: AnyRoute[]): RegExp;
+    /** Creates a grouped regex pattern string from many routes. */
+    static getRegexStringGroup(routes: AnyRoute[]): string;
+    /** Creates a grouped regex from many routes. */
+    static getRegexGroup(routes: AnyRoute[]): RegExp;
+    /** Converts any location shape to relative form (removes host/origin fields). */
+    static toRelLocation<TLocation extends AnyLocation>(location: TLocation): TLocation;
+    /** Converts a location to absolute form using provided origin URL. */
+    static toAbsLocation<TLocation extends AnyLocation>(location: TLocation, origin: string): TLocation;
+    /**
+     * Parses a URL-like input into raw location object (without route knowledge).
+     *
+     * Result is always `UnknownLocation` because no route matching is applied.
+     */
+    static getLocation(href: `${string}://${string}`): UnknownLocation;
+    static getLocation(hrefRel: `/${string}`): UnknownLocation;
+    static getLocation(hrefOrHrefRel: string): UnknownLocation;
+    static getLocation(location: AnyLocation): UnknownLocation;
+    static getLocation(url: URL): UnknownLocation;
+    static getLocation(hrefOrHrefRelOrLocation: string | AnyLocation | URL): UnknownLocation;
+    /**
+     * Parses input and matches it against this route definition.
+     *
+     * Result includes relation flags:
+     * - `exact`
+     * - `ancestor`
+     * - `descendant`
+     * - `unmatched`
+     */
+    getLocation(href: `${string}://${string}`): KnownLocation<TDefinition>;
+    getLocation(hrefRel: `/${string}`): KnownLocation<TDefinition>;
+    getLocation(hrefOrHrefRel: string): KnownLocation<TDefinition>;
+    getLocation(location: AnyLocation): KnownLocation<TDefinition>;
+    getLocation(url: AnyLocation): KnownLocation<TDefinition>;
+    getLocation(hrefOrHrefRelOrLocation: string | AnyLocation | URL): KnownLocation<TDefinition>;
+    private _validateParamsInput;
+    private _safeParseSchemaResult;
+    private _parseSchemaResult;
+    /** Standard Schema for route params input. */
+    readonly schema: SchemaRoute0<ParamsInput<TDefinition>, ParamsOutput<TDefinition>>;
+    /** True when path structure is equal (param names are ignored). */
+    isSame(other: AnyRoute): boolean;
+    /** Static convenience wrapper for `isSame`. */
+    static isSame(a: AnyRoute | string | undefined, b: AnyRoute | string | undefined): boolean;
+    /** True when current route is more specific/deeper than `other`. */
+    isDescendant(other: AnyRoute | string | undefined): boolean;
+    /** True when current route is broader/shallower than `other`. */
+    isAncestor(other: AnyRoute | string | undefined): boolean;
+    /** True when two route patterns can match the same concrete URL. */
+    isConflict(other: AnyRoute | string | undefined): boolean;
+    /** True when paths are same or can overlap when optional parts are omitted. */
+    isMayBeSame(other: AnyRoute | string | undefined): boolean;
+    /** Specificity comparator used for deterministic route ordering. */
+    isMoreSpecificThan(other: AnyRoute | string | undefined): boolean;
 }
-declare namespace Route0 {
-    type Callable<T extends Route0<any, any, any, any>> = T & T['get'];
-    type RouteConfigInput = {
-        baseUrl?: string;
-    };
-    type Params<TRoute0 extends Route0<any, any, any, any>> = {
-        [K in keyof TRoute0['paramsDefinition']]: string;
+/**
+ * Typed route collection with deterministic matching order.
+ *
+ * `Routes.create()` accepts either plain string definitions or route objects
+ * and returns a "pretty" object with direct route access + helper methods under `._`.
+ */
+declare class Routes<const T extends RoutesRecord = any> {
+    _routes: RoutesRecordHydrated<T>;
+    _pathsOrdering: string[];
+    _keysOrdering: string[];
+    _ordered: CallableRoute[];
+    _: {
+        routes: Routes<T>['_routes'];
+        getLocation: Routes<T>['_getLocation'];
+        clone: Routes<T>['_clone'];
+        pathsOrdering: Routes<T>['_pathsOrdering'];
+        keysOrdering: Routes<T>['_keysOrdering'];
+        ordered: Routes<T>['_ordered'];
     };
-    type Query<TRoute0 extends Route0<any, any, any, any>> = Partial<{
-        [K in keyof TRoute0['queryDefinition']]: string | undefined;
-    } & Record<string, string | undefined>>;
-    type _TrimQueryTailDefinition<S extends string> = S extends `${infer P}&${string}` ? P : S;
-    type _QueryTailDefinitionWithoutFirstAmp<S extends string> = S extends `${string}&${infer T}` ? T : '';
-    type _QueryTailDefinitionWithFirstAmp<S extends string> = S extends `${string}&${infer T}` ? `&${T}` : '';
-    type _AmpSplit<S extends string> = S extends `${infer A}&${infer B}` ? A | _AmpSplit<B> : S;
-    type _NonEmpty<T> = [T] extends ['' | never] ? never : T;
-    type _ExtractPathParams<S extends string> = S extends `${string}:${infer After}` ? After extends `${infer Name}/${infer Rest}` ? Name | _ExtractPathParams<`/${Rest}`> : After : never;
-    type _ReplacePathParams<S extends string> = S extends `${infer Head}:${infer Tail}` ? Tail extends `${infer _Param}/${infer Rest}` ? _ReplacePathParams<`${Head}${string}/${Rest}`> : `${Head}${string}` : S;
-    type _DedupeSlashes<S extends string> = S extends `${infer A}//${infer B}` ? _DedupeSlashes<`${A}/${B}`> : S;
-    type _EmptyRecord = Record<never, never>;
-    type _JoinPath<Parent extends string, Suffix extends string> = _DedupeSlashes<_PathDefinition<Parent> extends infer A extends string ? _PathDefinition<Suffix> extends infer B extends string ? A extends '' ? B extends '' ? '' : B extends `/${string}` ? B : `/${B}` : B extends '' ? A : A extends `${string}/` ? `${A}${B}` : B extends `/${string}` ? `${A}${B}` : `${A}/${B}` : never : never>;
-    type _OnlyIfNoParams<TParams extends object, Yes, No = never> = keyof TParams extends never ? Yes : No;
-    type _OnlyIfHasParams<TParams extends object, Yes, No = never> = keyof TParams extends never ? No : Yes;
-    type _PathDefinition<TPathOriginalDefinition extends string> = _TrimQueryTailDefinition<TPathOriginalDefinition>;
-    type _ParamsDefinition<TPathOriginalDefinition extends string> = _ExtractPathParams<_PathDefinition<TPathOriginalDefinition>> extends infer U ? [U] extends [never] ? _EmptyRecord : {
-        [K in Extract<U, string>]: true;
-    } : _EmptyRecord;
-    type _QueryDefinition<TPathOriginalDefinition extends string> = _NonEmpty<_QueryTailDefinitionWithoutFirstAmp<TPathOriginalDefinition>> extends infer Tail extends string ? _AmpSplit<Tail> extends infer U ? [U] extends [never] ? _EmptyRecord : {
-        [K in Extract<U, string>]: true;
-    } : _EmptyRecord : _EmptyRecord;
-    type _RoutePathOriginalDefinitionExtended<TSourcePathOriginalDefinition extends string, TSuffixPathOriginalDefinition extends string> = `${_JoinPath<TSourcePathOriginalDefinition, TSuffixPathOriginalDefinition>}${_QueryTailDefinitionWithFirstAmp<TSuffixPathOriginalDefinition>}`;
-    type _ParamsInput<TParamsDefinition extends object> = {
-        [K in keyof TParamsDefinition]: string | number;
+    private constructor();
+    /** Creates and hydrates a typed routes collection. */
+    static create<const T extends RoutesRecord>(routes: T, override?: RouteConfigInput): RoutesPretty<T>;
+    private static prettify;
+    private static hydrate;
+    /**
+     * Matches an input URL against collection routes.
+     *
+     * Returns first exact match according to precomputed ordering,
+     * otherwise returns `UnknownLocation`.
+     */
+    _getLocation(href: `${string}://${string}`): UnknownLocation | ExactLocation;
+    _getLocation(hrefRel: `/${string}`): UnknownLocation | ExactLocation;
+    _getLocation(hrefOrHrefRel: string): UnknownLocation | ExactLocation;
+    _getLocation(location: AnyLocation): UnknownLocation | ExactLocation;
+    _getLocation(url: URL): UnknownLocation | ExactLocation;
+    _getLocation(hrefOrHrefRelOrLocation: string | AnyLocation | URL): UnknownLocation | ExactLocation;
+    private static makeOrdering;
+    /** Returns a cloned routes collection with config applied to each route. */
+    _clone(config: RouteConfigInput): RoutesPretty<T>;
+    static _: {
+        prettify: typeof Routes.prettify;
+        hydrate: typeof Routes.hydrate;
+        makeOrdering: typeof Routes.makeOrdering;
     };
-    type _QueryInput<TQueryDefinition extends object> = Partial<{
-        [K in keyof TQueryDefinition]: string | number;
-    }> & Record<string, string | number>;
-    type _WithParamsInput<TParamsDefinition extends object, T extends {
-        query?: _QueryInput<any>;
-        abs?: boolean;
-    }> = _ParamsInput<TParamsDefinition> & T;
-    type _PathOnlyRouteValue<TPathOriginalDefinition extends string> = `${_ReplacePathParams<_PathDefinition<TPathOriginalDefinition>>}`;
-    type _WithQueryRouteValue<TPathOriginalDefinition extends string> = `${_ReplacePathParams<_PathDefinition<TPathOriginalDefinition>>}?${string}`;
-    type _AbsolutePathOnlyRouteValue<TPathOriginalDefinition extends string> = `${string}${_PathOnlyRouteValue<TPathOriginalDefinition>}`;
-    type _AbsoluteWithQueryRouteValue<TPathOriginalDefinition extends string> = `${string}${_WithQueryRouteValue<TPathOriginalDefinition>}`;
 }
+/** Any route instance shape, preserving literal path type when known. */
+type AnyRoute<T extends Route0<string> | string = string, TSearch extends UnknownSearchInput = UnknownSearchInput> = T extends string ? Route0<T, TSearch> : T;
+/** Callable route (`route(input)`) plus route instance methods/properties. */
+type CallableRoute<T extends Route0<string> | string = string, TSearch extends UnknownSearchInput = UnknownSearchInput> = AnyRoute<T, TSearch> & AnyRoute<T, TSearch>['get'];
+/** Route input accepted by most APIs: definition string or route object/callable. */
+type AnyRouteOrDefinition<T extends string = string> = AnyRoute<T> | CallableRoute<T> | T;
+/** Route-level runtime configuration. */
+type RouteConfigInput = {
+    origin?: string;
+};
+/** User-provided routes map (plain definitions or route instances). */
+type RoutesRecord = Record<string, AnyRoute | string>;
+/** Same as `RoutesRecord` but all values normalized to callable routes. */
+type RoutesRecordHydrated<TRoutesRecord extends RoutesRecord = any> = {
+    [K in keyof TRoutesRecord]: CallableRoute<TRoutesRecord[K]>;
+};
+/** Public shape returned by `Routes.create()`. Default `any` so `satisfies RoutesPretty` accepts any created routes. */
+type RoutesPretty<TRoutesRecord extends RoutesRecord = any> = RoutesRecordHydrated<TRoutesRecord> & Omit<Routes<TRoutesRecord>, '_routes' | '_getLocation' | '_clone' | '_pathsOrdering' | '_keysOrdering' | '_ordered'>;
+type ExtractRoutesKeys<TRoutes extends RoutesPretty | RoutesRecord> = TRoutes extends RoutesPretty ? Extract<keyof TRoutes['_']['routes'], string> : TRoutes extends RoutesRecord ? Extract<keyof TRoutes, string> : never;
+type ExtractRoute<TRoutes extends RoutesPretty | RoutesRecord, TKey extends ExtractRoutesKeys<TRoutes>> = TRoutes extends RoutesPretty ? TRoutes['_']['routes'][TKey] : TRoutes extends RoutesRecord ? TRoutes[TKey] : never;
+type Definition<T extends AnyRoute | string> = T extends AnyRoute ? T['definition'] : T extends string ? T : never;
+type ParamsDefinition<T extends AnyRoute | string> = T extends AnyRoute ? T['params'] : T extends string ? _ParamsDefinition<T> : undefined;
+type Extended<T extends AnyRoute | string | undefined, TSuffixDefinition extends string, TSearchInput extends UnknownSearchInput = UnknownSearchInput> = T extends AnyRoute ? Route0<PathExtended<T['definition'], TSuffixDefinition>, TSearchInput> : T extends string ? Route0<PathExtended<T, TSuffixDefinition>, TSearchInput> : T extends undefined ? Route0<TSuffixDefinition, TSearchInput> : never;
+type IsAncestor<T extends AnyRoute | string, TAncestor extends AnyRoute | string> = _IsAncestor<Definition<T>, Definition<TAncestor>>;
+type IsDescendant<T extends AnyRoute | string, TDescendant extends AnyRoute | string> = _IsDescendant<Definition<T>, Definition<TDescendant>>;
+type IsSame<T extends AnyRoute | string, TExact extends AnyRoute | string> = _IsSame<Definition<T>, Definition<TExact>>;
+type IsSameParams<T1 extends AnyRoute | string, T2 extends AnyRoute | string> = _IsSameParams<ParamsDefinition<T1>, ParamsDefinition<T2>>;
+type HasParams<T extends AnyRoute | string> = keyof _ParamsDefinition<Definition<T>> extends never ? false : true;
+type HasWildcard<T extends AnyRoute | string> = Definition<T> extends `${string}*${string}` ? true : false;
+type HasRequiredParams<T extends AnyRoute | string> = _RequiredParamKeys<Definition<T>> extends never ? false : true;
+type ParamsOutput<T extends AnyRoute | string> = {
+    [K in keyof ParamsDefinition<T>]: ParamsDefinition<T>[K] extends true ? string : string | undefined;
+};
+type ParamsInput<T extends AnyRoute | string = string> = _ParamsInput<Definition<T>>;
+type IsParamsOptional<T extends AnyRoute | string> = HasRequiredParams<Definition<T>> extends true ? false : true;
+type ParamsInputStringOnly<T extends AnyRoute | string = string> = _ParamsInputStringOnly<Definition<T>>;
+type LocationParams<TDefinition extends string> = {
+    [K in keyof _ParamsDefinition<TDefinition>]: _ParamsDefinition<TDefinition>[K] extends true ? string : string | undefined;
+};
+/**
+ * URL location primitives independent from route-matching state.
+ *
+ * `hrefRel` is relative href and includes `pathname + search + hash`.
+ */
+type _GeneralLocation = {
+    /**
+     * Path without search/hash (normalized for trailing slash).
+     *
+     * Example:
+     * - input: `https://example.com/users/42?tab=posts#section`
+     * - pathname: `/users/42`
+     */
+    pathname: string;
+    /**
+     * Parsed query object.
+     *
+     * Example:
+     * - `{ tab: "posts", sort: "desc" }`
+     */
+    search: UnknownSearchParsed;
+    /**
+     * Raw query string with leading `?`, if present.
+     *
+     * Example:
+     * - `?tab=posts&sort=desc`
+     */
+    searchString: string;
+    /**
+     * Raw hash with leading `#`, if present.
+     *
+     * Example:
+     * - `#section`
+     */
+    hash: string;
+    /**
+     * URL origin for absolute inputs.
+     *
+     * Example:
+     * - href: `https://example.com/users/42`
+     * - origin: `https://example.com`
+     */
+    origin?: string;
+    /**
+     * Full absolute href for absolute inputs.
+     *
+     * Example:
+     * - `https://example.com/users/42?tab=posts#section`
+     */
+    href?: string;
+    /**
+     * Relative href (`pathname + search + hash`).
+     *
+     * Example:
+     * - pathname: `/users/42`
+     * - search: `?tab=posts`
+     * - hash: `#section`
+     * - hrefRel: `/users/42?tab=posts#section`
+     */
+    hrefRel: string;
+    /**
+     * Whether input was absolute URL.
+     *
+     * Examples:
+     * - `https://example.com/users/42` -> `true`
+     * - `/users/42` -> `false`
+     */
+    abs: boolean;
+    port?: string;
+    host?: string;
+    hostname?: string;
+};
+/** Location state before matching against a concrete route. */
+type UnknownLocationState = {
+    known: false;
+    route: undefined;
+    params: undefined;
+    exact: false;
+    ancestor: false;
+    descendant: false;
+    unmatched: false;
+};
+type UnknownLocation = _GeneralLocation & UnknownLocationState;
+/** Known route context, but no exact/ancestor/descendant relation matched. */
+type UnmatchedLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    known: true;
+    route: Definition<TRoute>;
+    params: Record<never, never>;
+    exact: false;
+    ancestor: false;
+    descendant: false;
+    unmatched: true;
+};
+type UnmatchedLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & UnmatchedLocationState<TRoute>;
+/** Exact match state for a known route. */
+type ExactLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    known: true;
+    route: Definition<TRoute>;
+    params: ParamsOutput<TRoute>;
+    exact: true;
+    ancestor: false;
+    descendant: false;
+    unmatched: false;
+};
+type ExactLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & ExactLocationState<TRoute>;
+/** Input URL is a descendant of route definition (route is ancestor). */
+type AncestorLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    known: true;
+    route: Definition<TRoute>;
+    params: ParamsOutput<TRoute>;
+    exact: false;
+    ancestor: true;
+    descendant: false;
+    unmatched: false;
+};
+type AncestorLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & AncestorLocationState<TRoute>;
+/** It is when route not match at all, but params match. */
+type WeakAncestorLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    known: true;
+    route: Definition<TRoute>;
+    params: ParamsOutput<TRoute>;
+    exact: false;
+    ancestor: true;
+    descendant: false;
+    unmatched: false;
+};
+type WeakAncestorLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & WeakAncestorLocationState<TRoute>;
+/** Input URL is an ancestor prefix of route definition (route is descendant). */
+type DescendantLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    known: true;
+    route: Definition<TRoute>;
+    params: Partial<ParamsOutput<TRoute>>;
+    exact: false;
+    ancestor: false;
+    descendant: true;
+    unmatched: false;
+};
+type DescendantLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & DescendantLocationState<TRoute>;
+type UnknownSearchParsedValue = string | UnknownSearchParsed | Array<UnknownSearchParsedValue>;
+interface UnknownSearchParsed {
+    [key: string]: UnknownSearchParsedValue;
+}
+type UnknownSearchInputValue = string | number | boolean | undefined | UnknownSearchInput | Array<UnknownSearchInputValue>;
+interface UnknownSearchInput {
+    [key: string]: UnknownSearchInputValue;
+}
+/** It is when route not match at all, but params partially match. */
+type WeakDescendantLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    known: true;
+    route: Definition<TRoute>;
+    params: Partial<ParamsOutput<TRoute>>;
+    exact: false;
+    ancestor: false;
+    descendant: true;
+    unmatched: false;
+};
+type WeakDescendantLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & WeakDescendantLocationState<TRoute>;
+type KnownLocation<TRoute extends AnyRoute | string = AnyRoute | string> = UnmatchedLocation<TRoute> | ExactLocation<TRoute> | AncestorLocation<TRoute> | WeakAncestorLocation<TRoute> | DescendantLocation<TRoute> | WeakDescendantLocation<TRoute>;
+type AnyLocation<TRoute extends AnyRoute | string = AnyRoute | string> = UnknownLocation | KnownLocation<TRoute>;
+type _ParamsDefinition<TDefinition extends string> = _ExtractParamsDefinitionBySegments<_SplitPathSegments<Definition<TDefinition>>>;
+type _Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type _IfNoKeys<T extends object, TYes, TNo> = keyof T extends never ? TYes : TNo;
+type _ParamsInput<TDefinition extends string> = _ParamsDefinition<TDefinition> extends infer TDef extends Record<string, boolean> ? _IfNoKeys<TDef, Record<never, never>, _Simplify<{
+    [K in keyof TDef as TDef[K] extends true ? K : never]: string | number;
+} & {
+    [K in keyof TDef as TDef[K] extends false ? K : never]?: string | number | undefined;
+}>> : Record<never, never>;
+type _ParamsInputStringOnly<TDefinition extends string> = _ParamsDefinition<TDefinition> extends infer TDef extends Record<string, boolean> ? _IfNoKeys<TDef, Record<never, never>, _Simplify<{
+    [K in keyof TDef as TDef[K] extends true ? K : never]: string;
+} & {
+    [K in keyof TDef as TDef[K] extends false ? K : never]?: string | undefined;
+}>> : Record<never, never>;
+type _SplitPathSegments<TPath extends string> = TPath extends '' ? [] : TPath extends '/' ? [] : TPath extends `/${infer Rest}` ? _SplitPathSegments<Rest> : TPath extends `${infer Segment}/${infer Rest}` ? Segment extends '' ? _SplitPathSegments<Rest> : [Segment, ..._SplitPathSegments<Rest>] : TPath extends '' ? [] : [TPath];
+type _ParamDefinitionFromSegment<TSegment extends string> = TSegment extends `:${infer Name}?` ? {
+    [K in Name]: false;
+} : TSegment extends `:${infer Name}` ? {
+    [K in Name]: true;
+} : TSegment extends `${string}*?` ? {
+    '*': false;
+} : TSegment extends `${string}*` ? {
+    '*': true;
+} : Record<never, never>;
+type _MergeParamDefinitions<A extends Record<string, boolean>, B extends Record<string, boolean>> = {
+    [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;
+};
+type _ExtractParamsDefinitionBySegments<TSegments extends string[]> = TSegments extends [
+    infer Segment extends string,
+    ...infer Rest extends string[]
+] ? _MergeParamDefinitions<_ParamDefinitionFromSegment<Segment>, _ExtractParamsDefinitionBySegments<Rest>> : Record<never, never>;
+type _RequiredParamKeys<TDefinition extends string> = {
+    [K in keyof _ParamsDefinition<TDefinition>]: _ParamsDefinition<TDefinition>[K] extends true ? K : never;
+}[keyof _ParamsDefinition<TDefinition>];
+type ReplacePathParams<S extends string> = S extends `${infer Head}:${infer Tail}` ? Tail extends `${infer _Param}/${infer Rest}` ? ReplacePathParams<`${Head}${string}/${Rest}`> : `${Head}${string}` : S;
+type DedupeSlashes<S extends string> = S extends `${infer A}//${infer B}` ? DedupeSlashes<`${A}/${B}`> : S;
+type EmptyRecord = Record<never, never>;
+type JoinPath<Parent extends string, Suffix extends string> = DedupeSlashes<Definition<Parent> extends infer A extends string ? Definition<Suffix> extends infer B extends string ? A extends '' ? B extends '' ? '' : B extends `/${string}` ? B : `/${B}` : B extends '' ? A : A extends `${string}/` ? `${A}${B}` : B extends `/${string}` ? `${A}${B}` : `${A}/${B}` : never : never>;
+type OnlyIfNoParams<TRoute extends AnyRoute | string, Yes, No = never> = HasParams<TRoute> extends false ? Yes : No;
+type OnlyIfHasParams<TRoute extends AnyRoute | string, Yes, No = never> = HasParams<TRoute> extends true ? Yes : No;
+type PathExtended<TSourceDefinitionDefinition extends string, TSuffixDefinitionDefinition extends string> = `${JoinPath<StripTrailingWildcard<TSourceDefinitionDefinition>, TSuffixDefinitionDefinition>}`;
+type StripTrailingWildcard<TDefinition extends string> = TDefinition extends `${infer TPath}*?` ? TPath : TDefinition extends `${infer TPath}*` ? TPath : TDefinition;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type _IsSameParams<T1 extends object | undefined, T2 extends object | undefined> = T1 extends undefined ? T2 extends undefined ? true : false : T2 extends undefined ? false : T1 extends T2 ? T2 extends T1 ? true : false : false;
+type _IsAncestor<T extends string, TAncestor extends string> = T extends TAncestor ? false : T extends `${TAncestor}${string}` ? true : false;
+type _IsDescendant<T extends string, TDescendant extends string> = TDescendant extends T ? false : TDescendant extends `${T}${string}` ? true : false;
+type _IsSame<T extends string, TExact extends string> = T extends TExact ? TExact extends T ? true : false : false;
+type _SafeParseInputResult<TInputParsed extends Record<string, unknown>> = {
+    success: true;
+    data: TInputParsed;
+    error: undefined;
+} | {
+    success: false;
+    data: undefined;
+    error: Error;
+};
+type SchemaRoute0<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>> = StandardSchemaV1<TInput, TOutput> & {
+    parse: (input: unknown) => TOutput;
+    safeParse: (input: unknown) => _SafeParseInputResult<TOutput>;
+};
 
-export { Route0 };
+export { type AncestorLocation, type AncestorLocationState, type AnyLocation, type AnyRoute, type AnyRouteOrDefinition, type CallableRoute, type DedupeSlashes, type Definition, type DescendantLocation, type DescendantLocationState, type EmptyRecord, type ExactLocation, type ExactLocationState, type Extended, type ExtractRoute, type ExtractRoutesKeys, type HasParams, type HasRequiredParams, type HasWildcard, type IsAncestor, type IsAny, type IsDescendant, type IsParamsOptional, type IsSame, type IsSameParams, type JoinPath, type KnownLocation, type LocationParams, type OnlyIfHasParams, type OnlyIfNoParams, type ParamsDefinition, type ParamsInput, type ParamsInputStringOnly, type ParamsOutput, type PathExtended, type PathToken, type ReplacePathParams, Route0, type RouteConfigInput, Routes, type RoutesPretty, type RoutesRecord, type RoutesRecordHydrated, type SchemaRoute0, type StripTrailingWildcard, type UnknownLocation, type UnknownLocationState, type UnknownSearchInput, type UnknownSearchInputValue, type UnknownSearchParsed, type UnknownSearchParsedValue, type UnmatchedLocation, type UnmatchedLocationState, type WeakAncestorLocation, type WeakAncestorLocationState, type WeakDescendantLocation, type WeakDescendantLocationState, type _ExtractParamsDefinitionBySegments, type _GeneralLocation, type _IfNoKeys, type _IsAncestor, type _IsDescendant, type _IsSame, type _IsSameParams, type _MergeParamDefinitions, type _ParamDefinitionFromSegment, type _ParamsDefinition, type _ParamsInput, type _ParamsInputStringOnly, type _RequiredParamKeys, type _SafeParseInputResult, type _Simplify, type _SplitPathSegments };