@devp0nt/route0 1.0.0-next.8 → 1.0.0-next.81

package/dist/esm/index.d.ts

@@ -1,99 +1,455 @@
-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 RouteToken = {
+    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;
+    private _routeSegments?;
+    private _routeTokens?;
+    private _routePatternCandidates?;
+    private _pathParamsDefinition?;
+    private _definitionWithoutTrailingWildcard?;
+    private _routeRegexBaseStringRaw?;
+    private _regexBaseString?;
+    private _regexString?;
+    private _regex?;
+    private _regexAncestor?;
+    private _regexDescendantMatchers?;
+    private _captureKeys?;
+    private _normalizedDefinition?;
+    private _definitionParts?;
+    static normalizeSlash: (value: string) => string;
+    private static _getRouteSegments;
+    private static _validateRouteDefinition;
+    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<NormalizeRouteDefinition<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<NormalizeRouteDefinition<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>>;
+    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?: GetPathInput<TDefinition, TSearchInput> | undefined, abs?: boolean | string | undefined] : [input: GetPathInput<TDefinition, TSearchInput>, abs?: boolean | string | undefined]): string;
+    /** Returns path param keys extracted from route definition. */
+    getParamsKeys(): string[];
+    getTokens(): RouteToken[];
+    /** Clones route with optional config override. */
+    clone(config?: RouteConfigInput): CallableRoute<TDefinition>;
+    get regexBaseString(): string;
+    get regexString(): string;
+    get regex(): RegExp;
+    get regexAncestor(): RegExp;
+    private get regexDescendantMatchers();
+    private get captureKeys();
+    private get routeSegments();
+    private get routeTokens();
+    private get routePatternCandidates();
+    private get pathParamsDefinition();
+    private get definitionWithoutTrailingWildcard();
+    private get routeRegexBaseStringRaw();
+    private get normalizedDefinition();
+    private get definitionParts();
+    /** Fast pathname exact match check without building a full relation object. */
+    isExact(pathname: string, normalize?: boolean): boolean;
+    /** Fast pathname exact or ancestor match check without building a full relation object. */
+    isExactOrAncestor(pathname: string, normalize?: boolean): boolean;
+    /** True when route is ancestor of pathname (pathname is deeper). */
+    isAncestor(pathname: string, normalize?: boolean): boolean;
+    /** True when route is descendant of pathname (pathname is shallower). */
+    isDescendant(pathname: string, normalize?: boolean): boolean;
+    /** 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 evaluates pathname relation to this route.
+     */
+    getRelation(href: `${string}://${string}`): RouteRelation<TDefinition>;
+    getRelation(hrefRel: `/${string}`): RouteRelation<TDefinition>;
+    getRelation(hrefOrHrefRel: string): RouteRelation<TDefinition>;
+    getRelation(location: AnyLocation): RouteRelation<TDefinition>;
+    getRelation(url: URL): RouteRelation<TDefinition>;
+    getRelation(hrefOrHrefRelOrLocation: string | AnyLocation | URL): RouteRelation<TDefinition>;
+    private _validateParamsInput;
+    private _safeParseSchemaResult;
+    private _parseSchemaResult;
+    /** Standard Schema for route params input. */
+    readonly schema: SchemaRoute0<ParamsInput<TDefinition>, ParamsOutput<TDefinition>>;
+    /** True when two route patterns can match the same concrete URL. */
+    isOverlap(other: AnyRoute | string | undefined): boolean;
+    /**
+     * True when overlap is not resolvable by route ordering inside one route set.
+     *
+     * Non-conflicting overlap means one route is a strict subset of another
+     * (e.g. `/x/y` is a strict subset of `/x/:id`) and can be safely ordered first.
+     */
+    isConflict(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;
+/**
+ * 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 Params<TRoute0 extends Route0<any, any, any, any>> = {
-        [K in keyof TRoute0['paramsDefinition']]: string;
+    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 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;
+}
+/** 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 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, else empty string.
+     *
+     * Example:
+     * - `?tab=posts&sort=desc`
+     */
+    searchString: string;
+    /**
+     * Raw hash with leading `#`, if present, else empty string.
+     *
+     * Example:
+     * - `#section`
+     */
+    hash: string;
+    /**
+     * URL origin for absolute inputs.
+     *
+     * Example:
+     * - href: `https://example.com/users/42`
+     * - origin: `https://example.com`
+     */
+    origin: string | undefined;
+    /**
+     * Full absolute href for absolute inputs.
+     *
+     * Example:
+     * - `https://example.com/users/42?tab=posts#section`
+     */
+    href: string | undefined;
+    /**
+     * 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 | undefined;
+    host: string | undefined;
+    hostname: string | undefined;
+};
+/** Location state before matching against a concrete route. */
+type UnknownLocationState = {
+    route: undefined;
+    params: undefined;
+};
+type UnknownLocation = _GeneralLocation & UnknownLocationState;
+/** Exact match state for a known route. */
+type ExactLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    route: Definition<TRoute>;
+    params: ParamsOutput<TRoute>;
+};
+type ExactLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & ExactLocationState<TRoute>;
+type ExactRouteRelation<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    type: 'exact';
+    route: Definition<TRoute>;
+    params: ParamsOutput<TRoute>;
+    exact: true;
+    ascendant: false;
+    descendant: false;
+    unmatched: false;
+};
+type AscendantRouteRelation<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    type: 'ascendant';
+    route: Definition<TRoute>;
+    params: ParamsOutput<TRoute> & {
+        [key: string]: string | undefined;
     };
-    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>}`;
+    exact: false;
+    ascendant: true;
+    descendant: false;
+    unmatched: false;
+};
+type DescendantRouteRelation<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    type: 'descendant';
+    route: Definition<TRoute>;
+    params: Partial<ParamsOutput<TRoute>>;
+    exact: false;
+    ascendant: false;
+    descendant: true;
+    unmatched: false;
+};
+type UnmatchedRouteRelation<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    type: 'unmatched';
+    route: Definition<TRoute>;
+    params: Record<never, never>;
+    exact: false;
+    ascendant: false;
+    descendant: false;
+    unmatched: true;
+};
+type RouteRelation<TRoute extends AnyRoute | string = AnyRoute | string> = ExactRouteRelation<TRoute> | AscendantRouteRelation<TRoute> | DescendantRouteRelation<TRoute> | UnmatchedRouteRelation<TRoute>;
+type UnknownSearchParsedValue = string | UnknownSearchParsed | Array<UnknownSearchParsedValue>;
+interface UnknownSearchParsed {
+    [key: string]: UnknownSearchParsedValue;
 }
+type UnknownSearchInput = Record<string, unknown>;
+/** Input URL is a descendant of route definition (route is ancestor). */
+type AncestorLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    route: string;
+    params: IsAny<TRoute> extends true ? any : ParamsOutput<TRoute> & {
+        [key: string]: string | undefined;
+    };
+};
+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> = {
+    route: string;
+    params: IsAny<TRoute> extends true ? any : ParamsOutput<TRoute> & {
+        [key: string]: string | undefined;
+    };
+};
+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> = {
+    route: string;
+    params: Partial<ParamsOutput<TRoute>>;
+};
+type DescendantLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & DescendantLocationState<TRoute>;
+/** It is when route not match at all, but params partially match. */
+type WeakDescendantLocationState<TRoute extends AnyRoute | string = AnyRoute | string> = {
+    route: string;
+    params: Partial<ParamsOutput<TRoute>>;
+};
+type WeakDescendantLocation<TRoute extends AnyRoute | string = AnyRoute | string> = _GeneralLocation & WeakDescendantLocationState<TRoute>;
+type KnownLocation<TRoute extends AnyRoute | string = AnyRoute | string> = 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 EnsureLeadingSlash<S extends string> = S extends '' ? '/' : S extends `/${string}` ? S : `/${S}`;
+type TrimTrailingSlash<S extends string> = S extends '/' ? '/' : S extends `${infer V}/` ? TrimTrailingSlash<V> : S;
+type NormalizeRouteDefinition<S extends string> = TrimTrailingSlash<EnsureLeadingSlash<DedupeSlashes<S>>>;
+type EmptyRecord = Record<never, never>;
+type JoinPath<Parent extends string, Suffix extends string> = NormalizeRouteDefinition<Definition<Parent> extends infer A extends string ? Definition<Suffix> extends infer B extends string ? NormalizeRouteDefinition<A> extends infer ANormalized extends string ? NormalizeRouteDefinition<B> extends infer BNormalized extends string ? BNormalized extends '/' ? ANormalized : ANormalized extends '/' ? BNormalized : `${ANormalized}/${BNormalized}` : never : never : never : never>;
+type PathExtended<TSourceDefinitionDefinition extends string, TSuffixDefinitionDefinition extends string> = `${NormalizeRouteDefinition<JoinPath<StripTrailingWildcard<TSourceDefinitionDefinition>, TSuffixDefinitionDefinition>>}`;
+type StripTrailingWildcard<TDefinition extends string> = TDefinition extends `${infer TPath}*?` ? NormalizeRouteDefinition<TPath> : TDefinition extends `${infer TPath}*` ? NormalizeRouteDefinition<TPath> : NormalizeRouteDefinition<TDefinition>;
+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 GetPathInput<TDefinition extends string, TSearchInput extends UnknownSearchInput> = _ParamsInput<TDefinition> & {
+    '?'?: TSearchInput;
+    '#'?: string | number;
+};
+type GetPathInputByRoute<TRoute extends AnyRoute | CallableRoute | string> = TRoute extends AnyRoute<any, infer TSearchInput> ? GetPathInput<Definition<TRoute>, TSearchInput> : TRoute extends string ? GetPathInput<TRoute, UnknownSearchInput> : never;
+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 _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 AscendantRouteRelation, type CallableRoute, type DedupeSlashes, type Definition, type DescendantLocation, type DescendantLocationState, type DescendantRouteRelation, type EmptyRecord, type EnsureLeadingSlash, type ExactLocation, type ExactLocationState, type ExactRouteRelation, type Extended, type ExtractRoute, type ExtractRoutesKeys, type GetPathInput, type GetPathInputByRoute, type HasParams, type HasRequiredParams, type HasWildcard, type IsAny, type IsParamsOptional, type IsSameParams, type JoinPath, type KnownLocation, type LocationParams, type NormalizeRouteDefinition, type OnlyIfHasParams, type OnlyIfNoParams, type ParamsDefinition, type ParamsInput, type ParamsInputStringOnly, type ParamsOutput, type PathExtended, type ReplacePathParams, Route0, type RouteConfigInput, type RouteRelation, type RouteToken, Routes, type RoutesPretty, type RoutesRecord, type RoutesRecordHydrated, type SchemaRoute0, type StripTrailingWildcard, type TrimTrailingSlash, type UnknownLocation, type UnknownLocationState, type UnknownSearchInput, type UnknownSearchParsed, type UnknownSearchParsedValue, type UnmatchedRouteRelation, type WeakAncestorLocation, type WeakAncestorLocationState, type WeakDescendantLocation, type WeakDescendantLocationState, type _ExtractParamsDefinitionBySegments, type _GeneralLocation, type _IfNoKeys, type _IsSameParams, type _MergeParamDefinitions, type _ParamDefinitionFromSegment, type _ParamsDefinition, type _ParamsInput, type _ParamsInputStringOnly, type _RequiredParamKeys, type _SafeParseInputResult, type _Simplify, type _SplitPathSegments };