@tanstack/router-core 0.0.1-beta.16 → 0.0.1-beta.161

package/build/types/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * router-core
+ * @tanstack/router-core/src/index.ts
  *
  * Copyright (c) TanStack
  *
@@ -8,120 +8,134 @@
  *
  * @license MIT
  */
-import { BrowserHistory, MemoryHistory, HashHistory, History } from 'history';
-export { createBrowserHistory, createHashHistory, createMemoryHistory } from 'history';
 export { default as invariant } from 'tiny-invariant';
+export { default as warning } from 'tiny-warning';
+import { Store } from '@tanstack/react-store';
 
-interface FrameworkGenerics {
-}
-declare type GetFrameworkGeneric<U> = U extends keyof FrameworkGenerics ? FrameworkGenerics[U] : any;
-
-interface RouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> extends Route<TAllRouteInfo, TRouteInfo> {
-    matchId: string;
-    pathname: string;
-    params: TRouteInfo['params'];
-    parentMatch?: RouteMatch;
-    childMatches: RouteMatch[];
-    routeSearch: TRouteInfo['searchSchema'];
-    search: TRouteInfo['fullSearchSchema'];
-    status: 'idle' | 'loading' | 'success' | 'error';
-    updatedAt?: number;
-    error?: unknown;
-    isInvalid: boolean;
-    getIsInvalid: () => boolean;
-    loaderData: TRouteInfo['loaderData'];
-    routeLoaderData: TRouteInfo['routeLoaderData'];
-    isFetching: boolean;
-    invalidAt: number;
-    __: {
-        component?: GetFrameworkGeneric<'Component'>;
-        errorComponent?: GetFrameworkGeneric<'Component'>;
-        pendingComponent?: GetFrameworkGeneric<'Component'>;
-        loadPromise?: Promise<void>;
-        componentsPromise?: Promise<void>;
-        dataPromise?: Promise<TRouteInfo['routeLoaderData']>;
-        onExit?: void | ((matchContext: {
-            params: TRouteInfo['allParams'];
-            search: TRouteInfo['fullSearchSchema'];
-        }) => void);
-        abortController: AbortController;
-        latestId: string;
-        validate: () => void;
-        notify: () => void;
-        resolve: () => void;
-    };
-    cancel: () => void;
-    load: (loaderOpts?: {
-        preload: true;
-        maxAge: number;
-        gcMaxAge: number;
-    } | {
-        preload?: false;
-        maxAge?: never;
-        gcMaxAge?: never;
-    }) => Promise<TRouteInfo['routeLoaderData']>;
-    fetch: (opts?: {
-        maxAge?: number;
-    }) => Promise<TRouteInfo['routeLoaderData']>;
-    invalidate: () => void;
-    hasLoaders: () => boolean;
-}
-declare function createRouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo>(router: Router<any, any>, route: Route<TAllRouteInfo, TRouteInfo>, opts: {
-    parentMatch?: RouteMatch<any, any>;
-    matchId: string;
-    params: TRouteInfo['allParams'];
+interface RouterHistory {
+    location: RouterLocation;
+    listen: (cb: () => void) => () => void;
+    push: (path: string, state?: any) => void;
+    replace: (path: string, state?: any) => void;
+    go: (index: number) => void;
+    back: () => void;
+    forward: () => void;
+    createHref: (href: string) => string;
+    block: (blockerFn: BlockerFn) => () => void;
+}
+interface ParsedPath {
+    href: string;
     pathname: string;
-}): RouteMatch<TAllRouteInfo, TRouteInfo>;
+    search: string;
+    hash: string;
+}
+interface RouterLocation extends ParsedPath {
+    state: any;
+}
+type BlockerFn = (retry: () => void, cancel: () => void) => void;
+declare function createBrowserHistory(opts?: {
+    getHref?: () => string;
+    createHref?: (path: string) => string;
+}): RouterHistory;
+declare function createHashHistory(): RouterHistory;
+declare function createMemoryHistory(opts?: {
+    initialEntries: string[];
+    initialIndex?: number;
+}): RouterHistory;
 
-declare type NoInfer<T> = [T][T extends any ? 0 : never];
-declare type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N;
-declare type IsAnyBoolean<T> = 1 extends 0 & T ? true : false;
-declare type IsKnown<T, Y, N> = unknown extends T ? N : Y;
-declare type PickAsRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
-declare type PickAsPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-declare type PickUnsafe<T, K> = K extends keyof T ? Pick<T, K> : never;
-declare type PickExtra<T, K> = Expand<{
+type NoInfer<T> = [T][T extends any ? 0 : never];
+type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N;
+type IsAnyBoolean<T> = 1 extends 0 & T ? true : false;
+type IsKnown<T, Y, N> = unknown extends T ? N : Y;
+type PickAsRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+type PickAsPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type PickUnsafe<T, K> = K extends keyof T ? Pick<T, K> : never;
+type PickExtra<T, K> = {
     [TKey in keyof K as string extends TKey ? never : TKey extends keyof T ? never : TKey]: K[TKey];
-}>;
-declare type PickRequired<T> = {
+};
+type PickRequired<T> = {
     [K in keyof T as undefined extends T[K] ? never : K]: T[K];
 };
-declare type Expand<T> = T extends object ? T extends infer O ? {
+type Expand<T> = T extends object ? T extends infer O ? {
     [K in keyof O]: O[K];
 } : never : T;
-declare type Values<O> = O[ValueKeys<O>];
-declare type ValueKeys<O> = Extract<keyof O, PropertyKey>;
-declare type DeepAwaited<T> = T extends Promise<infer A> ? DeepAwaited<A> : T extends Record<infer A, Promise<infer B>> ? {
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => any ? I : never;
+type Compute<T> = {
+    [K in keyof T]: T[K];
+} | never;
+type AllKeys<T> = T extends any ? keyof T : never;
+type MergeUnion<T, Keys extends keyof T = keyof T> = Compute<{
+    [K in Keys]: T[Keys];
+} & {
+    [K in AllKeys<T>]?: T extends any ? K extends keyof T ? T[K] : never : never;
+}>;
+type Values<O> = O[ValueKeys<O>];
+type ValueKeys<O> = Extract<keyof O, PropertyKey>;
+type DeepAwaited<T> = T extends Promise<infer A> ? DeepAwaited<A> : T extends Record<infer A, Promise<infer B>> ? {
     [K in A]: DeepAwaited<B>;
 } : T;
-declare type PathParamMask<TRoutePath extends string> = TRoutePath extends `${infer L}/:${infer C}/${infer R}` ? PathParamMask<`${L}/${string}/${R}`> : TRoutePath extends `${infer L}/:${infer C}` ? PathParamMask<`${L}/${string}`> : TRoutePath;
-declare type Timeout = ReturnType<typeof setTimeout>;
-declare type Updater<TPrevious, TResult = TPrevious> = TResult | ((prev?: TPrevious) => TResult);
-declare type PickExtract<T, U> = {
+type PathParamMask<TRoutePath extends string> = TRoutePath extends `${infer L}/$${infer C}/${infer R}` ? PathParamMask<`${L}/${string}/${R}`> : TRoutePath extends `${infer L}/$${infer C}` ? PathParamMask<`${L}/${string}`> : TRoutePath;
+type Timeout = ReturnType<typeof setTimeout>;
+type Updater<TPrevious, TResult = TPrevious> = TResult | ((prev?: TPrevious) => TResult);
+type PickExtract<T, U> = {
     [K in keyof T as T[K] extends U ? K : never]: T[K];
 };
-declare type PickExclude<T, U> = {
+type PickExclude<T, U> = {
     [K in keyof T as T[K] extends U ? never : K]: T[K];
 };
+declare function last<T>(arr: T[]): T | undefined;
+declare function functionalUpdate<TResult>(updater: Updater<TResult>, previous: TResult): TResult;
+declare function pick<T, K extends keyof T>(parent: T, keys: K[]): Pick<T, K>;
 /**
  * This function returns `a` if `b` is deeply equal.
  * If not, it will replace any deeply equal children of `b` with those of `a`.
- * This can be used for structural sharing between JSON values for example.
+ * This can be used for structural sharing between immutable JSON values for example.
+ * Do not use this with signals
  */
-declare function replaceEqualDeep(prev: any, next: any): any;
-declare function last<T>(arr: T[]): T | undefined;
-declare function warning(cond: any, message: string): cond is true;
-declare function functionalUpdate<TResult>(updater: Updater<TResult>, previous: TResult): TResult;
-declare function pick<T, K extends keyof T>(parent: T, keys: K[]): Pick<T, K>;
+declare function replaceEqualDeep<T>(prev: any, _next: T): T;
+declare function isPlainObject(o: any): boolean;
+declare function partialDeepEqual(a: any, b: any): boolean;
+
+type ParseRoute<TRouteTree extends AnyRoute> = TRouteTree | ParseRouteChildren<TRouteTree>;
+type ParseRouteChildren<TRouteTree extends AnyRoute> = TRouteTree extends Route<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, infer TChildren, any> ? unknown extends TChildren ? never : TChildren extends AnyRoute[] ? {
+    [TId in TChildren[number]['id'] as string]: ParseRoute<TChildren[number]>;
+}[string] : never : never;
+type RoutesById<TRouteTree extends AnyRoute> = {
+    [K in ParseRoute<TRouteTree>['id'] as K['id']]: K;
+};
+type RouteById<TRouteTree extends AnyRoute, TId> = Extract<ParseRoute<TRouteTree>, {
+    id: TId;
+}>;
+type RouteIds<TRouteTree extends AnyRoute> = AnyRoute extends TRouteTree ? string : ParseRoute<TRouteTree>['id'];
+type RoutesByPath<TRouteTree extends AnyRoute> = {
+    [K in ParseRoute<TRouteTree>['fullPath'] as K['fullPath']]: K;
+};
+type RouteByPath<TRouteTree extends AnyRoute, TPath> = Extract<ParseRoute<TRouteTree>, {
+    fullPath: TPath;
+}>;
+type RoutePaths<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree>['fullPath'] | '/';
+type FullSearchSchema<TRouteTree extends AnyRoute> = MergeUnion<ParseRoute<TRouteTree>['__types']['fullSearchSchema']> & {};
+type AllParams<TRouteTree extends AnyRoute> = MergeUnion<ParseRoute<TRouteTree>['__types']['allParams']>;
 
+declare global {
+    interface Window {
+        __TSR_DEHYDRATED__?: HydrationCtx;
+    }
+}
+interface Register {
+}
+type AnyRouter = Router<any, any>;
+type RegisteredRouter = Register extends {
+    router: infer TRouter extends AnyRouter;
+} ? TRouter : AnyRouter;
 interface LocationState {
 }
-interface Location<TSearchObj extends AnySearchSchema = {}, TState extends LocationState = LocationState> {
+interface ParsedLocation<TSearchObj extends AnySearchSchema = {}> {
     href: string;
     pathname: string;
     search: TSearchObj;
     searchStr: string;
-    state: TState;
+    state: LocationState;
     hash: string;
     key?: string;
 }
@@ -131,107 +145,95 @@ interface FromLocation {
     key?: string;
     hash?: string;
 }
-declare type SearchSerializer = (searchObj: Record<string, any>) => string;
-declare type SearchParser = (searchStr: string) => Record<string, any>;
-declare type FilterRoutesFn = <TRoute extends Route<any, RouteInfo>>(routeConfigs: TRoute[]) => TRoute[];
-interface RouterOptions<TRouteConfig extends AnyRouteConfig> {
-    history?: BrowserHistory | MemoryHistory | HashHistory;
+type SearchSerializer = (searchObj: Record<string, any>) => string;
+type SearchParser = (searchStr: string) => Record<string, any>;
+type HydrationCtx = {
+    router: DehydratedRouter;
+    payload: Record<string, any>;
+};
+interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRoute extends AnyRoute = AnyRoute> {
+    id: string;
+    key?: string;
+    routeId: string;
+    pathname: string;
+    params: TRoute['__types']['allParams'];
+    status: 'pending' | 'success' | 'error';
+    isFetching: boolean;
+    invalid: boolean;
+    error: unknown;
+    paramsError: unknown;
+    searchError: unknown;
+    updatedAt: number;
+    invalidAt: number;
+    preloadInvalidAt: number;
+    loaderData: TRoute['__types']['loader'];
+    loadPromise?: Promise<void>;
+    __resolveLoadPromise?: () => void;
+    routeContext: TRoute['__types']['routeContext'];
+    context: TRoute['__types']['context'];
+    routeSearch: TRoute['__types']['searchSchema'];
+    search: FullSearchSchema<TRouteTree> & TRoute['__types']['fullSearchSchema'];
+    fetchedAt: number;
+    abortController: AbortController;
+}
+type AnyRouteMatch = RouteMatch<AnyRoute, AnyRoute>;
+type RouterContextOptions<TRouteTree extends AnyRoute> = AnyContext extends TRouteTree['__types']['routerContext'] ? {
+    context?: TRouteTree['__types']['routerContext'];
+} : {
+    context: TRouteTree['__types']['routerContext'];
+};
+interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any>> {
+    history?: RouterHistory;
     stringifySearch?: SearchSerializer;
     parseSearch?: SearchParser;
-    filterRoutes?: FilterRoutesFn;
     defaultPreload?: false | 'intent';
-    defaultPreloadMaxAge?: number;
-    defaultPreloadGcMaxAge?: number;
     defaultPreloadDelay?: number;
-    useErrorBoundary?: boolean;
-    defaultComponent?: GetFrameworkGeneric<'Component'>;
-    defaultErrorComponent?: GetFrameworkGeneric<'Component'>;
-    defaultPendingComponent?: GetFrameworkGeneric<'Component'>;
-    defaultLoaderMaxAge?: number;
-    defaultLoaderGcMaxAge?: number;
+    defaultComponent?: RegisteredRouteComponent<RouteProps<unknown, AnySearchSchema, AnyPathParams, AnyContext, AnyContext>>;
+    defaultErrorComponent?: RegisteredRouteErrorComponent<RouteProps<unknown, AnySearchSchema, AnyPathParams, AnyContext, AnyContext>>;
+    defaultPendingComponent?: RegisteredRouteComponent<RouteProps<unknown, AnySearchSchema, AnyPathParams, AnyContext, AnyContext>>;
+    defaultMaxAge?: number;
+    defaultGcMaxAge?: number;
+    defaultPreloadMaxAge?: number;
     caseSensitive?: boolean;
-    routeConfig?: TRouteConfig;
+    routeTree?: TRouteTree;
     basepath?: string;
-    createRouter?: (router: Router<any, any>) => void;
     createRoute?: (opts: {
         route: AnyRoute;
-        router: Router<any, any>;
+        router: AnyRouter;
     }) => void;
-    loadComponent?: (component: GetFrameworkGeneric<'Component'>) => Promise<GetFrameworkGeneric<'Component'>>;
-}
-interface Action<TPayload = unknown, TResponse = unknown> {
-    submit: (submission?: TPayload, actionOpts?: {
-        invalidate?: boolean;
-        multi?: boolean;
-    }) => Promise<TResponse>;
-    current?: ActionState<TPayload, TResponse>;
-    latest?: ActionState<TPayload, TResponse>;
-    submissions: ActionState<TPayload, TResponse>[];
-}
-interface ActionState<TPayload = unknown, TResponse = unknown> {
-    submittedAt: number;
-    status: 'idle' | 'pending' | 'success' | 'error';
-    submission: TPayload;
-    isMulti: boolean;
-    data?: TResponse;
-    error?: unknown;
-}
-interface Loader<TFullSearchSchema extends AnySearchSchema = {}, TAllParams extends AnyPathParams = {}, TRouteLoaderData = AnyLoaderData> {
-    fetch: keyof PickRequired<TFullSearchSchema> extends never ? keyof TAllParams extends never ? (loaderContext: {
-        signal?: AbortSignal;
-    }) => Promise<TRouteLoaderData> : (loaderContext: {
-        params: TAllParams;
-        search?: TFullSearchSchema;
-        signal?: AbortSignal;
-    }) => Promise<TRouteLoaderData> : keyof TAllParams extends never ? (loaderContext: {
-        search: TFullSearchSchema;
-        params: TAllParams;
-        signal?: AbortSignal;
-    }) => Promise<TRouteLoaderData> : (loaderContext: {
-        search: TFullSearchSchema;
-        signal?: AbortSignal;
-    }) => Promise<TRouteLoaderData>;
-    current?: LoaderState<TFullSearchSchema, TAllParams>;
-    latest?: LoaderState<TFullSearchSchema, TAllParams>;
-    pending: LoaderState<TFullSearchSchema, TAllParams>[];
-}
-interface LoaderState<TFullSearchSchema = unknown, TAllParams = unknown> {
-    loadedAt: number;
-    loaderContext: LoaderContext<TFullSearchSchema, TAllParams>;
-}
-interface RouterState {
-    status: 'idle' | 'loading';
-    location: Location;
-    matches: RouteMatch[];
-    lastUpdated: number;
-    actions: Record<string, Action>;
-    loaders: Record<string, Loader>;
-    pending?: PendingState;
+    onRouteChange?: () => void;
+    context?: TRouteTree['__types']['routerContext'];
+    Wrap?: React.ComponentType<{
+        children: React.ReactNode;
+        dehydratedState?: TDehydrated;
+    }>;
+    dehydrate?: () => TDehydrated;
+    hydrate?: (dehydrated: TDehydrated) => void;
+}
+interface RouterState<TRouteTree extends AnyRoute = AnyRoute> {
+    status: 'idle' | 'pending';
     isFetching: boolean;
-    isPreloading: boolean;
-}
-interface PendingState {
-    location: Location;
-    matches: RouteMatch[];
+    matchesById: Record<string, RouteMatch<TRouteTree, AnyRoute>>;
+    matchIds: string[];
+    pendingMatchIds: string[];
+    matches: RouteMatch<TRouteTree, AnyRoute>[];
+    pendingMatches: RouteMatch<TRouteTree, AnyRoute>[];
+    location: ParsedLocation<FullSearchSchema<TRouteTree>>;
+    resolvedLocation: ParsedLocation<FullSearchSchema<TRouteTree>>;
+    lastUpdated: number;
 }
-declare type Listener = (router: Router<any, any>) => void;
-declare type ListenerFn = () => void;
+type ListenerFn = () => void;
 interface BuildNextOptions {
     to?: string | number | null;
-    params?: true | Updater<Record<string, any>>;
+    params?: true | Updater<unknown>;
     search?: true | Updater<unknown>;
     hash?: true | Updater<string>;
     state?: LocationState;
     key?: string;
     from?: string;
     fromCurrent?: boolean;
-    __preSearchFilters?: SearchFilter<any>[];
-    __postSearchFilters?: SearchFilter<any>[];
+    __matches?: AnyRouteMatch[];
 }
-declare type MatchCacheEntry = {
-    gc: number;
-    match: RouteMatch;
-};
 interface MatchLocation {
     to?: string | number | null;
     fuzzy?: boolean;
@@ -240,206 +242,207 @@ interface MatchLocation {
     fromCurrent?: boolean;
 }
 interface MatchRouteOptions {
-    pending: boolean;
+    pending?: boolean;
     caseSensitive?: boolean;
+    includeSearch?: boolean;
+    fuzzy?: boolean;
 }
 interface DehydratedRouterState extends Pick<RouterState, 'status' | 'location' | 'lastUpdated'> {
-    matches: DehydratedRouteMatch[];
 }
-interface DehydratedRouteMatch extends Pick<RouteMatch<any, any>, 'matchId' | 'status' | 'routeLoaderData' | 'loaderData' | 'isInvalid' | 'invalidAt'> {
+interface DehydratedRouter {
+    state: DehydratedRouterState;
 }
-interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>> {
-    history: BrowserHistory | MemoryHistory | HashHistory;
-    options: PickAsRequired<RouterOptions<TRouteConfig>, 'stringifySearch' | 'parseSearch'>;
+type RouterConstructorOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any>> = Omit<RouterOptions<TRouteTree, TDehydrated>, 'context'> & RouterContextOptions<TRouteTree>;
+declare const componentTypes: readonly ["component", "errorComponent", "pendingComponent"];
+declare class Router<TRouteTree extends AnyRoute = AnyRoute, TDehydrated extends Record<string, any> = Record<string, any>> {
+    #private;
+    types: {
+        RootRoute: TRouteTree;
+    };
+    options: PickAsRequired<RouterOptions<TRouteTree, TDehydrated>, 'stringifySearch' | 'parseSearch' | 'context'>;
+    history: RouterHistory;
     basepath: string;
-    allRouteInfo: TAllRouteInfo;
-    listeners: Listener[];
-    location: Location;
-    navigateTimeout?: Timeout;
-    nextAction?: 'push' | 'replace';
-    state: RouterState;
-    routeTree: Route<TAllRouteInfo, RouteInfo>;
-    routesById: RoutesById<TAllRouteInfo>;
-    navigationPromise: Promise<void>;
-    startedLoadingAt: number;
-    resolveNavigation: () => void;
-    subscribe: (listener: Listener) => () => void;
+    routeTree: TRouteTree;
+    routesById: RoutesById<TRouteTree>;
+    routesByPath: RoutesByPath<TRouteTree>;
+    flatRoutes: ParseRoute<TRouteTree>[];
+    navigateTimeout: undefined | Timeout;
+    nextAction: undefined | 'push' | 'replace';
+    navigationPromise: undefined | Promise<void>;
+    __store: Store<RouterState<TRouteTree>>;
+    state: RouterState<TRouteTree>;
+    dehydratedData?: TDehydrated;
+    constructor(options: RouterConstructorOptions<TRouteTree, TDehydrated>);
     reset: () => void;
-    notify: () => void;
-    mount: () => () => void;
-    onFocus: () => void;
-    update: <TRouteConfig extends RouteConfig = RouteConfig>(opts?: RouterOptions<TRouteConfig>) => Router<TRouteConfig>;
-    buildNext: (opts: BuildNextOptions) => Location;
+    mount: () => void;
+    update: (opts?: RouterOptions<any, any>) => this;
+    buildNext: (opts: BuildNextOptions) => ParsedLocation;
     cancelMatches: () => void;
-    load: (next?: Location) => Promise<void>;
-    matchCache: Record<string, MatchCacheEntry>;
-    cleanMatchCache: () => void;
-    getRoute: <TId extends keyof TAllRouteInfo['routeInfoById']>(id: TId) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]>;
-    loadRoute: (navigateOpts: BuildNextOptions) => Promise<RouteMatch[]>;
-    preloadRoute: (navigateOpts: BuildNextOptions, loaderOpts: {
+    cancelMatch: (id: string) => void;
+    safeLoad: (opts?: {
+        next?: ParsedLocation;
+    }) => Promise<void>;
+    latestLoadPromise: Promise<void>;
+    load: (opts?: {
+        next?: ParsedLocation;
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    getRoute: (id: string) => Route;
+    preloadRoute: (navigateOpts?: BuildNextOptions & {
+        maxAge?: number;
+    }) => Promise<RouteMatch<TRouteTree, ParseRoute<TRouteTree>>[]>;
+    cleanMatches: () => void;
+    matchRoutes: (pathname: string, locationSearch: AnySearchSchema, opts?: {
+        throwOnError?: boolean;
+        debug?: boolean;
+    }) => RouteMatch<TRouteTree, ParseRoute<TRouteTree>>[];
+    loadMatches: (resolvedMatches: AnyRouteMatch[], opts?: {
+        preload?: boolean;
         maxAge?: number;
-        gcMaxAge?: number;
-    }) => Promise<RouteMatch[]>;
-    matchRoutes: (pathname: string, opts?: {
-        strictParseParams?: boolean;
-    }) => RouteMatch[];
-    loadMatches: (resolvedMatches: RouteMatch[], loaderOpts?: {
-        preload: true;
-        maxAge: number;
-        gcMaxAge: number;
-    } | {
-        preload?: false;
-        maxAge?: never;
-        gcMaxAge?: never;
     }) => Promise<void>;
-    invalidateRoute: (opts: MatchLocation) => void;
     reload: () => Promise<void>;
     resolvePath: (from: string, path: string) => string;
-    navigate: <TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'>(opts: NavigateOptionsAbsolute<TAllRouteInfo, TFrom, TTo>) => Promise<void>;
-    matchRoute: <TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'>(matchLocation: ToOptions<TAllRouteInfo, TFrom, TTo>, opts?: MatchRouteOptions) => boolean;
-    buildLink: <TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'>(opts: LinkOptions<TAllRouteInfo, TFrom, TTo>) => LinkInfo;
-    dehydrateState: () => DehydratedRouterState;
-    hydrateState: (state: DehydratedRouterState) => void;
-    __: {
-        buildRouteTree: (routeConfig: RouteConfig) => Route<TAllRouteInfo, AnyRouteInfo>;
-        parseLocation: (location: History['location'], previousLocation?: Location) => Location;
-        buildLocation: (dest: BuildNextOptions) => Location;
-        commitLocation: (next: Location, replace?: boolean) => Promise<void>;
-        navigate: (location: BuildNextOptions & {
-            replace?: boolean;
-        }) => Promise<void>;
-    };
-}
-declare function createRouter<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>>(userOptions?: RouterOptions<TRouteConfig>): Router<TRouteConfig, TAllRouteInfo>;
-
-interface AnyRoute extends Route<any, any> {
-}
-interface Route<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> {
-    routeId: TRouteInfo['id'];
-    routeRouteId: TRouteInfo['routeId'];
-    routePath: TRouteInfo['path'];
-    fullPath: TRouteInfo['fullPath'];
-    parentRoute?: AnyRoute;
-    childRoutes?: AnyRoute[];
-    options: RouteOptions;
-    router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>;
-    buildLink: <TTo extends string = '.'>(options: Omit<LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>) => LinkInfo;
-    matchRoute: <TTo extends string = '.', TResolved extends string = ResolveRelativePath<TRouteInfo['id'], TTo>>(matchLocation: CheckRelativePath<TAllRouteInfo, TRouteInfo['fullPath'], NoInfer<TTo>> & Omit<ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>, opts?: MatchRouteOptions) => RouteInfoByPath<TAllRouteInfo, TResolved>['allParams'];
-    navigate: <TTo extends string = '.'>(options: Omit<LinkOptions<TAllRouteInfo, TRouteInfo['id'], TTo>, 'from'>) => Promise<void>;
-    action: unknown extends TRouteInfo['actionResponse'] ? Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']> | undefined : Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>;
-    loader: unknown extends TRouteInfo['routeLoaderData'] ? Action<LoaderContext<TRouteInfo['fullSearchSchema'], TRouteInfo['allParams']>, TRouteInfo['routeLoaderData']> | undefined : Loader<TRouteInfo['fullSearchSchema'], TRouteInfo['allParams'], TRouteInfo['routeLoaderData']>;
-}
-declare function createRoute<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo>(routeConfig: RouteConfig, options: TRouteInfo['options'], parent: undefined | Route<TAllRouteInfo, any>, router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>): Route<TAllRouteInfo, TRouteInfo>;
-
-interface AnyAllRouteInfo {
-    routeConfig: AnyRouteConfig;
-    routeInfo: AnyRouteInfo;
-    routeInfoById: Record<string, AnyRouteInfo>;
-    routeInfoByFullPath: Record<string, AnyRouteInfo>;
-    routeIds: any;
-    routePaths: any;
-}
-interface DefaultAllRouteInfo {
-    routeConfig: RouteConfig;
-    routeInfo: RouteInfo;
-    routeInfoById: Record<string, RouteInfo>;
-    routeInfoByFullPath: Record<string, RouteInfo>;
-    routeIds: string;
-    routePaths: string;
-}
-interface AllRouteInfo<TRouteConfig extends AnyRouteConfig = RouteConfig> extends RoutesInfoInner<TRouteConfig, ParseRouteConfig<TRouteConfig>> {
-}
-declare type ParseRouteConfig<TRouteConfig = AnyRouteConfig> = TRouteConfig extends AnyRouteConfig ? RouteConfigRoute<TRouteConfig> | ParseRouteChildren<TRouteConfig> : never;
-declare type ParseRouteChildren<TRouteConfig> = TRouteConfig extends AnyRouteConfigWithChildren<infer TChildren> ? unknown extends TChildren ? never : TChildren extends AnyRouteConfig[] ? Values<{
-    [TId in TChildren[number]['id']]: ParseRouteChild<TChildren[number], TId>;
-}> : never : never;
-declare type ParseRouteChild<TRouteConfig, TId> = TRouteConfig & {
-    id: TId;
-} extends AnyRouteConfig ? ParseRouteConfig<TRouteConfig> : never;
-declare type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<infer TId, infer TRouteId, infer TPath, infer TFullPath, infer TParentLoaderData, infer TRouteLoaderData, infer TLoaderData, infer TActionPayload, infer TActionResponse, infer TParentSearchSchema, infer TSearchSchema, infer TFullSearchSchema, infer TParentParams, infer TParams, infer TAllParams, any> ? string extends TRouteId ? never : RouteInfo<TId, TRouteId, TPath, TFullPath, TParentLoaderData, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams> : never;
-interface RoutesInfoInner<TRouteConfig extends AnyRouteConfig, TRouteInfo extends RouteInfo<string, string, any, any, any, any, any, any, any, any, any, any, any, any, any> = RouteInfo, TRouteInfoById = {
-    [TInfo in TRouteInfo as TInfo['id']]: TInfo;
-}, TRouteInfoByFullPath = {
-    [TInfo in TRouteInfo as TInfo['fullPath'] extends RootRouteId ? never : string extends TInfo['fullPath'] ? never : TInfo['fullPath']]: TInfo;
-}> {
-    routeConfig: TRouteConfig;
-    routeInfo: TRouteInfo;
-    routeInfoById: TRouteInfoById;
-    routeInfoByFullPath: TRouteInfoByFullPath;
-    routeIds: keyof TRouteInfoById;
-    routePaths: keyof TRouteInfoByFullPath;
-}
-interface AnyRouteInfo extends RouteInfo<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
-}
-interface RouteInfo<TId extends string = string, TRouteId extends string = string, TPath extends string = string, TFullPath extends string = string, TParentRouteLoaderData extends AnyLoaderData = {}, TRouteLoaderData extends AnyLoaderData = {}, TLoaderData extends AnyLoaderData = {}, TActionPayload = unknown, TActionResponse = unknown, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}, TParams extends Record<ParsePathParams<TPath>, unknown> = Record<ParsePathParams<TPath>, string>, TAllParams extends AnyPathParams = {}> {
-    id: TId;
-    routeId: TRouteId;
-    path: TPath;
-    fullPath: TFullPath;
-    parentRouteLoaderData: TParentRouteLoaderData;
-    routeLoaderData: TRouteLoaderData;
-    loaderData: TLoaderData;
-    actionPayload: TActionPayload;
-    actionResponse: TActionResponse;
-    searchSchema: TSearchSchema;
-    fullSearchSchema: TFullSearchSchema;
-    parentParams: TParentParams;
-    params: TParams;
-    allParams: TAllParams;
-    options: RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams>;
-}
-declare type RoutesById<TAllRouteInfo extends AnyAllRouteInfo> = {
-    [K in keyof TAllRouteInfo['routeInfoById']]: Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][K]>;
+    navigate: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "">({ from, to, search, hash, replace, params, }: NavigateOptions<TRouteTree, TFrom, TTo>) => Promise<void>;
+    matchRoute: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "", TResolved extends string = ResolveRelativePath<TFrom, NoInfer<TTo>>>(location: ToOptions<TRouteTree, TFrom, TTo, ResolveRelativePath<TFrom, NoInfer<TTo>>>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>["__types"]["allParams"];
+    buildLink: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "">({ from, to, search, params, hash, target, replace, activeOptions, preload, preloadDelay: userPreloadDelay, disabled, state, }: LinkOptions<TRouteTree, TFrom, TTo>) => LinkInfo;
+    dehydrate: () => DehydratedRouter;
+    hydrate: (__do_not_use_server_ctx?: HydrationCtx) => Promise<void>;
+    injectedHtml: (string | (() => Promise<string> | string))[];
+    injectHtml: (html: string | (() => Promise<string> | string)) => Promise<void>;
+    dehydrateData: <T>(key: any, getData: T | (() => T | Promise<T>)) => () => T | undefined;
+    hydrateData: <T = unknown>(key: any) => T | undefined;
+    getRouteMatch: (id: string) => undefined | RouteMatch<TRouteTree, AnyRoute>;
+    setRouteMatch: (id: string, updater: (prev: RouteMatch<TRouteTree, AnyRoute>) => RouteMatch<TRouteTree, AnyRoute>) => void;
+    setRouteMatchData: (id: string, updater: (prev: any) => any, opts?: {
+        updatedAt?: number;
+        maxAge?: number;
+    }) => void;
+    invalidate: (opts?: {
+        matchId?: string;
+        reload?: boolean;
+    }) => Promise<void>;
+    getIsInvalid: (opts?: {
+        matchId: string;
+        preload?: boolean;
+    }) => boolean;
+}
+type AnyRedirect = Redirect<any, any, any>;
+type Redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo> & {
+    code?: number;
 };
-declare type RouteInfoById<TAllRouteInfo extends AnyAllRouteInfo, TId> = TId extends keyof TAllRouteInfo['routeInfoById'] ? IsAny<TAllRouteInfo['routeInfoById'][TId]['id'], RouteInfo, TAllRouteInfo['routeInfoById'][TId]> : never;
-declare type RouteInfoByPath<TAllRouteInfo extends AnyAllRouteInfo, TPath> = TPath extends keyof TAllRouteInfo['routeInfoByFullPath'] ? IsAny<TAllRouteInfo['routeInfoByFullPath'][TPath]['id'], RouteInfo, TAllRouteInfo['routeInfoByFullPath'][TPath]> : never;
+declare function redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''>(opts: Redirect<TRouteTree, TFrom, TTo>): Redirect<TRouteTree, TFrom, TTo>;
+declare function isRedirect(obj: any): obj is AnyRedirect;
+declare class SearchParamError extends Error {
+}
+declare class PathParamError extends Error {
+}
+declare function lazyFn<T extends Record<string, (...args: any[]) => any>, TKey extends keyof T = 'default'>(fn: () => Promise<T>, key?: TKey): (...args: Parameters<T[TKey]>) => Promise<ReturnType<T[TKey]>>;
 
 declare const rootRouteId: "__root__";
-declare type RootRouteId = typeof rootRouteId;
-declare type AnyLoaderData = {};
-declare type AnyPathParams = {};
-declare type AnySearchSchema = {};
+type RootRouteId = typeof rootRouteId;
+type AnyPathParams = {};
+type AnySearchSchema = {};
+type AnyContext = {};
 interface RouteMeta {
 }
-declare type SearchSchemaValidator<TReturn, TParentSchema> = SearchSchemaValidatorObj<TReturn, TParentSchema> | SearchSchemaValidatorFn<TReturn, TParentSchema>;
-declare type SearchSchemaValidatorObj<TReturn, TParentSchema> = {
-    parse?: SearchSchemaValidatorFn<TReturn, TParentSchema>;
+interface RouteContext {
+}
+interface RegisterRouteComponent<TProps> {
+}
+interface RegisterRouteErrorComponent<TProps> {
+}
+type RegisteredRouteComponent<TProps> = RegisterRouteComponent<TProps> extends {
+    RouteComponent: infer T;
+} ? T : (props: TProps) => unknown;
+type RegisteredRouteErrorComponent<TProps> = RegisterRouteErrorComponent<TProps> extends {
+    RouteErrorComponent: infer T;
+} ? T : (props: TProps) => unknown;
+type PreloadableObj = {
+    preload?: () => Promise<void>;
 };
-declare type SearchSchemaValidatorFn<TReturn, TParentSchema> = (searchObj: Record<string, unknown>) => {} extends TParentSchema ? TReturn : keyof TReturn extends keyof TParentSchema ? {
-    error: 'Top level search params cannot be redefined by child routes!';
-    keys: keyof TReturn & keyof TParentSchema;
-} : TReturn;
-declare type DefinedPathParamWarning = 'Path params cannot be redefined by child routes!';
-declare type ParentParams<TParentParams> = AnyPathParams extends TParentParams ? {} : {
-    [Key in keyof TParentParams]?: DefinedPathParamWarning;
+type RoutePathOptions<TCustomId, TPath> = {
+    path: TPath;
+} | {
+    id: TCustomId;
 };
-declare type LoaderFn<TParentRouteLoaderData extends AnyLoaderData = {}, TRouteLoaderData extends AnyLoaderData = {}, TFullSearchSchema extends AnySearchSchema = {}, TAllParams extends AnyPathParams = {}> = (loaderContext: LoaderContext<TParentRouteLoaderData, TFullSearchSchema, TAllParams>) => Promise<TRouteLoaderData>;
-interface LoaderContext<TParentRouteLoaderData extends AnyLoaderData = {}, TFullSearchSchema extends AnySearchSchema = {}, TAllParams extends AnyPathParams = {}> {
+type RoutePathOptionsIntersection<TCustomId, TPath> = UnionToIntersection<RoutePathOptions<TCustomId, TPath>>;
+type MetaOptions = keyof PickRequired<RouteMeta> extends never ? {
+    meta?: RouteMeta;
+} : {
+    meta: RouteMeta;
+};
+type AnyRouteProps = RouteProps<any, any, any, any, any>;
+type ComponentPropsFromRoute<TRoute> = TRoute extends Route<infer TParentRoute, infer TPath, infer TFullPath, infer TCustomId, infer TId, infer TLoader, infer TSearchSchema, infer TFullSearchSchema, infer TParams, infer TAllParams, infer TParentContext, infer TAllParentContext, infer TRouteContext, infer TContext, infer TRouterContext, infer TChildren, infer TRouteTree> ? RouteProps<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TContext> : never;
+type ComponentFromRoute<TRoute> = RegisteredRouteComponent<ComponentPropsFromRoute<TRoute>>;
+type RouteLoaderFromRoute<TRoute extends AnyRoute> = LoaderFn<TRoute['__types']['loader'], TRoute['__types']['searchSchema'], TRoute['__types']['fullSearchSchema'], TRoute['__types']['allParams'], TRoute['__types']['routeContext'], TRoute['__types']['context']>;
+type RouteProps<TLoader extends any = unknown, TFullSearchSchema extends AnySearchSchema = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TRouteContext extends AnyContext = AnyContext, TContext extends AnyContext = AnyContext> = {
+    useMatch: () => RouteMatch<any, any>;
+    useLoader: () => UseLoaderResult<TLoader>;
+    useSearch: <TStrict extends boolean = true, TSearch = TFullSearchSchema, TSelected = TSearch>(opts?: {
+        strict?: TStrict;
+        select?: (search: TSearch) => TSelected;
+    }) => TStrict extends true ? TSelected : TSelected | undefined;
+    useParams: <TDefaultSelected = TAllParams, TSelected = TDefaultSelected>(opts?: {
+        select?: (params: TDefaultSelected) => TSelected;
+    }) => TSelected;
+    useContext: <TDefaultSelected = TContext, TSelected = TDefaultSelected>(opts?: {
+        select?: (context: TDefaultSelected) => TSelected;
+    }) => TSelected;
+    useRouteContext: <TDefaultSelected = TRouteContext, TSelected = TDefaultSelected>(opts?: {
+        select?: (context: TDefaultSelected) => TSelected;
+    }) => TSelected;
+};
+type RouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TLoader = unknown, TParentSearchSchema extends AnySearchSchema = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = TSearchSchema, TParams extends AnyPathParams = AnyPathParams, TAllParams extends AnyPathParams = TParams, TParentContext extends AnyContext = AnyContext, TAllParentContext extends AnyContext = AnyContext, TRouteContext extends RouteContext = RouteContext, TAllContext extends AnyContext = AnyContext> = BaseRouteOptions<TParentRoute, TCustomId, TPath, TLoader, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TAllContext> & UpdatableRouteOptions<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>;
+type ParamsFallback<TPath extends string, TParams> = unknown extends TParams ? Record<ParsePathParams<TPath>, string> : TParams;
+type BaseRouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TLoader = unknown, TParentSearchSchema extends AnySearchSchema = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = TSearchSchema, TParams extends AnyPathParams = {}, TAllParams = ParamsFallback<TPath, TParams>, TParentContext extends AnyContext = AnyContext, TAllParentContext extends AnyContext = AnyContext, TRouteContext extends RouteContext = RouteContext, TAllContext extends AnyContext = AnyContext> = RoutePathOptions<TCustomId, TPath> & {
+    layoutLimit?: string;
+    getParentRoute: () => TParentRoute;
+    validateSearch?: SearchSchemaValidator<TSearchSchema>;
+    loader?: LoaderFn<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, NoInfer<TRouteContext>, TAllContext>;
+} & ([TLoader] extends [never] ? {
+    loader: 'Loaders must return a type other than never. If you are throwing a redirect() and not returning anything, return a redirect() instead.';
+} : {}) & ({
+    parseParams?: (rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>) => TParams extends Record<ParsePathParams<TPath>, any> ? TParams : 'parseParams must return an object';
+    stringifyParams?: (params: NoInfer<ParamsFallback<TPath, TParams>>) => Record<ParsePathParams<TPath>, string>;
+} | {
+    stringifyParams?: never;
+    parseParams?: never;
+}) & (keyof PickRequired<RouteContext> extends never ? {
+    getContext?: GetContextFn<TParentRoute, TAllParams, TFullSearchSchema, TParentContext, TAllParentContext, TRouteContext>;
+} : {
+    getContext: GetContextFn<TParentRoute, TAllParams, TFullSearchSchema, TParentContext, TAllParentContext, TRouteContext>;
+});
+type GetContextFn<TParentRoute, TAllParams, TFullSearchSchema, TParentContext, TAllParentContext, TRouteContext> = (opts: {
     params: TAllParams;
     search: TFullSearchSchema;
-    signal?: AbortSignal;
-    parentLoaderPromise?: Promise<TParentRouteLoaderData>;
-}
-declare type ActionFn<TActionPayload = unknown, TActionResponse = unknown> = (submission: TActionPayload) => TActionResponse | Promise<TActionResponse>;
-declare type UnloaderFn<TPath extends string> = (routeMatch: RouteMatch<any, RouteInfo<string, TPath>>) => void;
-declare type RouteOptions<TRouteId extends string = string, TPath extends string = string, TParentRouteLoaderData extends AnyLoaderData = {}, TRouteLoaderData extends AnyLoaderData = {}, TLoaderData extends AnyLoaderData = {}, TActionPayload = unknown, TActionResponse = unknown, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = TSearchSchema, TParentParams extends AnyPathParams = {}, TParams extends Record<ParsePathParams<TPath>, unknown> = Record<ParsePathParams<TPath>, string>, TAllParams extends AnyPathParams = {}> = ({
-    path: TPath;
-} | {
-    id: TRouteId;
-}) & {
+} & (TParentRoute extends undefined ? {
+    context?: TAllParentContext;
+    parentContext?: TParentContext;
+} : {
+    context: TAllParentContext;
+    parentContext: TParentContext;
+})) => TRouteContext;
+type UpdatableRouteOptions<TLoader, TSearchSchema extends AnySearchSchema, TFullSearchSchema extends AnySearchSchema, TAllParams extends AnyPathParams, TRouteContext extends AnyContext, TContext extends AnyContext> = MetaOptions & {
+    key?: null | false | GetKeyFn<TFullSearchSchema, TAllParams>;
     caseSensitive?: boolean;
-    validateSearch?: SearchSchemaValidator<TSearchSchema, TParentSearchSchema>;
+    wrapInSuspense?: boolean;
+    component?: RegisteredRouteComponent<RouteProps<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TContext>>;
+    errorComponent?: RegisteredRouteErrorComponent<{
+        error: unknown;
+    } & Partial<RouteProps<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TContext>>>;
+    pendingComponent?: RegisteredRouteComponent<RouteProps<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TContext>>;
     preSearchFilters?: SearchFilter<TFullSearchSchema>[];
     postSearchFilters?: SearchFilter<TFullSearchSchema>[];
-    component?: GetFrameworkGeneric<'Component'>;
-    errorComponent?: GetFrameworkGeneric<'Component'>;
-    pendingComponent?: GetFrameworkGeneric<'Component'>;
-    loader?: LoaderFn<TParentRouteLoaderData, TRouteLoaderData, TFullSearchSchema, TAllParams>;
-    loaderMaxAge?: number;
-    loaderGcMaxAge?: number;
-    action?: ActionFn<TActionPayload, TActionResponse>;
-    useErrorBoundary?: boolean;
-    onMatch?: (matchContext: {
+    preloadMaxAge?: number;
+    maxAge?: number;
+    gcMaxAge?: number;
+    beforeLoad?: (opts: LoaderContext<TSearchSchema, TFullSearchSchema, TAllParams, NoInfer<TRouteContext>, TContext>) => Promise<void> | void;
+    onBeforeLoadError?: (err: any) => void;
+    onValidateSearchError?: (err: any) => void;
+    onParseParamsError?: (err: any) => void;
+    onLoadError?: (err: any) => void;
+    onError?: (err: any) => void;
+    onLoaded?: (matchContext: {
         params: TAllParams;
         search: TFullSearchSchema;
     }) => void | undefined | ((match: {
@@ -450,65 +453,209 @@ declare type RouteOptions<TRouteId extends string = string, TPath extends string
         params: TAllParams;
         search: TFullSearchSchema;
     }) => void;
-    meta?: RouteMeta;
-} & ({
-    parseParams?: never;
-    stringifyParams?: never;
-} | {
-    parseParams: (rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>) => TParams;
-    stringifyParams: (params: TParams) => Record<ParsePathParams<TPath>, string>;
-}) & (PickUnsafe<TParentParams, ParsePathParams<TPath>> extends never ? {} : 'Cannot redefined path params in child routes!');
-declare type SearchFilter<T, U = T> = (prev: T) => U;
-interface RouteConfig<TId extends string = string, TRouteId extends string = string, TPath extends string = string, TFullPath extends string = string, TParentRouteLoaderData extends AnyLoaderData = AnyLoaderData, TRouteLoaderData extends AnyLoaderData = AnyLoaderData, TLoaderData extends AnyLoaderData = AnyLoaderData, TActionPayload = unknown, TActionResponse = unknown, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}, TParams extends Record<ParsePathParams<TPath>, unknown> = Record<ParsePathParams<TPath>, string>, TAllParams extends AnyPathParams = {}, TKnownChildren = unknown> {
+};
+type ParseParamsOption<TPath extends string, TParams> = ParseParamsFn<TPath, TParams>;
+type ParseParamsFn<TPath extends string, TParams> = (rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>) => TParams extends Record<ParsePathParams<TPath>, any> ? TParams : 'parseParams must return an object';
+type ParseParamsObj<TPath extends string, TParams> = {
+    parse?: ParseParamsFn<TPath, TParams>;
+};
+type SearchSchemaValidator<TReturn> = SearchSchemaValidatorObj<TReturn> | SearchSchemaValidatorFn<TReturn>;
+type SearchSchemaValidatorObj<TReturn> = {
+    parse?: SearchSchemaValidatorFn<TReturn>;
+};
+type SearchSchemaValidatorFn<TReturn> = (searchObj: Record<string, unknown>) => TReturn;
+type DefinedPathParamWarning = 'Path params cannot be redefined by child routes!';
+type ParentParams<TParentParams> = AnyPathParams extends TParentParams ? {} : {
+    [Key in keyof TParentParams]?: DefinedPathParamWarning;
+};
+type LoaderFn<TLoader = unknown, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TAllParams = {}, TContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> = (match: LoaderContext<TSearchSchema, TFullSearchSchema, TAllParams, TContext, TAllContext> & {
+    parentMatchPromise?: Promise<void>;
+}) => Promise<TLoader> | TLoader;
+type GetKeyFn<TFullSearchSchema extends AnySearchSchema = {}, TAllParams = {}> = (loaderContext: {
+    params: TAllParams;
+    search: TFullSearchSchema;
+}) => any;
+interface LoaderContext<TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TAllParams = {}, TContext extends AnyContext = AnyContext, TAllContext extends AnyContext = AnyContext> {
+    params: TAllParams;
+    routeSearch: TSearchSchema;
+    search: TFullSearchSchema;
+    abortController: AbortController;
+    preload: boolean;
+    routeContext: TContext;
+    context: TAllContext;
+}
+type UnloaderFn<TPath extends string> = (routeMatch: RouteMatch<any, Route>) => void;
+type SearchFilter<T, U = T> = (prev: T) => U;
+type ResolveId<TParentRoute, TCustomId extends string, TPath extends string> = TParentRoute extends {
+    id: infer TParentId extends string;
+} ? RoutePrefix<TParentId, string extends TCustomId ? TPath : TCustomId> : RootRouteId;
+type InferFullSearchSchema<TRoute> = TRoute extends {
+    isRoot: true;
+    __types: {
+        searchSchema: infer TSearchSchema;
+    };
+} ? TSearchSchema : TRoute extends {
+    __types: {
+        fullSearchSchema: infer TFullSearchSchema;
+    };
+} ? TFullSearchSchema : {};
+type ResolveFullSearchSchema<TParentRoute, TSearchSchema> = InferFullSearchSchema<TParentRoute> & TSearchSchema;
+interface AnyRoute extends Route<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
+}
+type MergeParamsFromParent<T, U> = IsAny<T, U, T & U>;
+type UseLoaderResult<T> = T extends Record<PropertyKey, infer U> ? {
+    [K in keyof T]: UseLoaderResultPromise<T[K]>;
+} : UseLoaderResultPromise<T>;
+type UseLoaderResultPromise<T> = T extends Promise<infer U> ? StreamedPromise<U> : T;
+type StreamedPromise<T> = {
+    promise: Promise<T>;
+    status: 'resolved' | 'pending';
+    data: T;
+    resolve: (value: T) => void;
+};
+type RouteConstraints = {
+    TParentRoute: AnyRoute;
+    TPath: string;
+    TFullPath: string;
+    TCustomId: string;
+    TId: string;
+    TSearchSchema: AnySearchSchema;
+    TFullSearchSchema: AnySearchSchema;
+    TParams: Record<string, any>;
+    TAllParams: Record<string, any>;
+    TParentContext: AnyContext;
+    TAllParentContext: AnyContext;
+    TRouteContext: RouteContext;
+    TAllContext: AnyContext;
+    TRouterContext: AnyContext;
+    TChildren: unknown;
+    TRouteTree: AnyRoute;
+};
+declare class Route<TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, TPath extends RouteConstraints['TPath'] = '/', TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints['TCustomId'] = string, TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, TLoader = unknown, TSearchSchema extends RouteConstraints['TSearchSchema'] = {}, TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends RouteConstraints['TParams'] = Record<ParsePathParams<TPath>, string>, TAllParams extends RouteConstraints['TAllParams'] = MergeParamsFromParent<TParentRoute['__types']['allParams'], TParams>, TParentContext extends RouteConstraints['TParentContext'] = TParentRoute['__types']['routeContext'], TAllParentContext extends RouteConstraints['TAllParentContext'] = TParentRoute['__types']['context'], TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends RouteConstraints['TAllContext'] = MergeParamsFromParent<TParentRoute['__types']['context'], TRouteContext>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
+    __types: {
+        parentRoute: TParentRoute;
+        path: TPath;
+        to: TrimPathRight<TFullPath>;
+        fullPath: TFullPath;
+        customId: TCustomId;
+        id: TId;
+        loader: TLoader;
+        searchSchema: TSearchSchema;
+        fullSearchSchema: TFullSearchSchema;
+        params: TParams;
+        allParams: TAllParams;
+        parentContext: TParentContext;
+        allParentContext: TAllParentContext;
+        routeContext: TRouteContext;
+        context: TAllContext;
+        children: TChildren;
+        routeTree: TRouteTree;
+        routerContext: TRouterContext;
+    };
+    isRoot: TParentRoute extends Route<any> ? true : false;
+    options: RouteOptions<TParentRoute, TCustomId, TPath, TLoader, InferFullSearchSchema<TParentRoute>, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TAllContext> & UpdatableRouteOptions<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>;
+    parentRoute: TParentRoute;
     id: TId;
-    routeId: TRouteId;
-    path: NoInfer<TPath>;
+    path: TPath;
     fullPath: TFullPath;
-    options: RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams>;
-    children?: TKnownChildren;
-    addChildren: IsAny<TId, any, <TNewChildren extends any>(children: TNewChildren extends AnyRouteConfig[] ? TNewChildren : {
-        error: 'Invalid route detected';
-        route: TNewChildren;
-    }) => RouteConfig<TId, TRouteId, TPath, TFullPath, TParentRouteLoaderData, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams, TNewChildren>>;
-    createChildren: IsAny<TId, any, <TNewChildren extends any>(cb: (createChildRoute: CreateRouteConfigFn<false, TId, TFullPath, TRouteLoaderData, TLoaderData, TFullSearchSchema, TAllParams>) => TNewChildren extends AnyRouteConfig[] ? TNewChildren : {
-        error: 'Invalid route detected';
-        route: TNewChildren;
-    }) => RouteConfig<TId, TRouteId, TPath, TFullPath, TParentRouteLoaderData, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams, TNewChildren>>;
-    createRoute: CreateRouteConfigFn<false, TId, TFullPath, TRouteLoaderData, TLoaderData, TFullSearchSchema, TAllParams>;
-}
-declare type CreateRouteConfigFn<TIsRoot extends boolean = false, TParentId extends string = string, TParentPath extends string = string, TParentRouteLoaderData extends AnyLoaderData = {}, TParentLoaderData extends AnyLoaderData = {}, TParentSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}> = <TRouteId extends string, TPath extends string, TRouteLoaderData extends AnyLoaderData, TActionPayload, TActionResponse, TSearchSchema extends AnySearchSchema = AnySearchSchema, TParams extends Record<ParsePathParams<TPath>, unknown> = Record<ParsePathParams<TPath>, string>, TAllParams extends AnyPathParams extends TParams ? Record<ParsePathParams<TPath>, string> : NoInfer<TParams> = AnyPathParams extends TParams ? Record<ParsePathParams<TPath>, string> : NoInfer<TParams>, TKnownChildren extends RouteConfig[] = RouteConfig[], TResolvedId extends string = string extends TRouteId ? string extends TPath ? string : TPath : TRouteId>(options?: TIsRoot extends true ? Omit<RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, Expand<TParentLoaderData & DeepAwaited<NoInfer<TRouteLoaderData>>>, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, Expand<TParentSearchSchema & TSearchSchema>, TParentParams, TParams, Expand<TParentParams & TAllParams>>, 'path'> & {
-    path?: never;
-} : RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, Expand<TParentLoaderData & DeepAwaited<NoInfer<TRouteLoaderData>>>, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, Expand<TParentSearchSchema & TSearchSchema>, TParentParams, TParams, Expand<TParentParams & TAllParams>>, children?: TKnownChildren, isRoot?: boolean, parentId?: string, parentPath?: string) => RouteConfig<RoutePrefix<TParentId, TResolvedId>, TResolvedId, TPath, string extends TPath ? '' : RoutePath<RoutePrefix<TParentPath, TPath>>, TParentRouteLoaderData, TRouteLoaderData, Expand<TParentLoaderData & DeepAwaited<NoInfer<TRouteLoaderData>>>, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, Expand<TParentSearchSchema & TSearchSchema>, TParentParams, TParams, Expand<TParentParams & TAllParams>, TKnownChildren>;
-declare type RoutePath<T extends string> = T extends RootRouteId ? '/' : TrimPathRight<`${T}`>;
-declare type RoutePrefix<TPrefix extends string, TId extends string> = string extends TId ? RootRouteId : TId extends string ? `${TPrefix}/${TId}` extends '/' ? '/' : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TId>}`>}` : never;
-interface AnyRouteConfig extends RouteConfig<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
-}
-interface AnyRouteConfigWithChildren<TChildren> extends RouteConfig<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, TChildren> {
-}
-declare type TrimPath<T extends string> = '' extends T ? '' : TrimPathRight<TrimPathLeft<T>>;
-declare type TrimPathLeft<T extends string> = T extends `${RootRouteId}/${infer U}` ? TrimPathLeft<U> : T extends `/${infer U}` ? TrimPathLeft<U> : T;
-declare type TrimPathRight<T extends string> = T extends '/' ? '/' : T extends `${infer U}/` ? TrimPathRight<U> : T;
-declare const createRouteConfig: CreateRouteConfigFn<true>;
+    to: TrimPathRight<TFullPath>;
+    children?: TChildren;
+    originalIndex?: number;
+    router?: AnyRouter;
+    rank: number;
+    constructor(options: RouteOptions<TParentRoute, TCustomId, TPath, TLoader, InferFullSearchSchema<TParentRoute>, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TAllContext> & UpdatableRouteOptions<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>);
+    init: (opts: {
+        originalIndex: number;
+        router: AnyRouter;
+    }) => void;
+    addChildren: <TNewChildren extends AnyRoute[]>(children: TNewChildren) => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TLoader, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TAllContext, TRouterContext, TNewChildren, TRouteTree>;
+    update: (options: UpdatableRouteOptions<TLoader, TSearchSchema, TFullSearchSchema, TAllParams, TRouteContext, TAllContext>) => this;
+    static __onInit: (route: typeof this$1) => void;
+}
+type AnyRootRoute = RootRoute<any, any, any, any>;
+declare class RouterContext<TRouterContext extends {}> {
+    constructor();
+    createRootRoute: <TLoader = unknown, TSearchSchema extends AnySearchSchema = {}, TRouteContext extends RouteContext = RouteContext>(options?: Omit<RouteOptions<AnyRoute, "__root__", "", TLoader, TSearchSchema, TSearchSchema, TSearchSchema, {}, {}, TRouterContext, TRouterContext, TRouteContext, IsAny<TRouterContext, TRouteContext, TRouterContext & TRouteContext>>, "caseSensitive" | "id" | "path" | "getParentRoute" | "stringifyParams" | "parseParams"> | undefined) => RootRoute<TLoader, TSearchSchema, TRouteContext, TRouterContext>;
+}
+declare class RootRoute<TLoader = unknown, TSearchSchema extends AnySearchSchema = {}, TRouteContext extends RouteContext = RouteContext, TRouterContext extends {} = {}> extends Route<any, '/', '/', string, RootRouteId, TLoader, TSearchSchema, TSearchSchema, {}, {}, TRouterContext, TRouterContext, TRouteContext, MergeParamsFromParent<TRouterContext, TRouteContext>, TRouterContext, any, any> {
+    constructor(options?: Omit<RouteOptions<AnyRoute, RootRouteId, '', TLoader, TSearchSchema, TSearchSchema, TSearchSchema, {}, {}, TRouterContext, TRouterContext, TRouteContext, MergeParamsFromParent<TRouterContext, TRouteContext>>, 'path' | 'id' | 'getParentRoute' | 'caseSensitive' | 'parseParams' | 'stringifyParams'>);
+}
+type ResolveFullPath<TParentRoute extends AnyRoute, TPath extends string, TPrefixed = RoutePrefix<TParentRoute['fullPath'], TPath>> = TPrefixed extends RootRouteId ? '/' : TPrefixed;
+type RoutePrefix<TPrefix extends string, TPath extends string> = string extends TPath ? RootRouteId : TPath extends string ? TPrefix extends RootRouteId ? TPath extends '/' ? '/' : `/${TrimPath<TPath>}` : `${TPrefix}/${TPath}` extends '/' ? '/' : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TPath>}`>}` : never;
+type TrimPath<T extends string> = '' extends T ? '' : TrimPathRight<TrimPathLeft<T>>;
+type TrimPathLeft<T extends string> = T extends `${RootRouteId}/${infer U}` ? TrimPathLeft<U> : T extends `/${infer U}` ? TrimPathLeft<U> : T;
+type TrimPathRight<T extends string> = T extends '/' ? '/' : T extends `${infer U}/` ? TrimPathRight<U> : T;
+
+interface FileRoutesByPath {
+}
+type Replace<S extends string, From extends string, To extends string> = S extends `${infer Start}${From}${infer Rest}` ? `${Start}${To}${Replace<Rest, From, To>}` : S;
+type TrimLeft<T extends string, S extends string> = T extends `${S}${infer U}` ? U : T;
+type TrimRight<T extends string, S extends string> = T extends `${infer U}${S}` ? U : T;
+type Trim<T extends string, S extends string> = TrimLeft<TrimRight<T, S>, S>;
+type RemoveUnderScores<T extends string> = Replace<Replace<TrimRight<TrimLeft<T, '/_'>, '_'>, '_/', '/'>, '/_', '/'>;
+type ResolveFilePath<TParentRoute extends AnyRoute, TFilePath extends string> = TParentRoute['id'] extends RootRouteId ? TrimPathLeft<TFilePath> : Replace<TrimPathLeft<TFilePath>, TrimPathLeft<TParentRoute['__types']['customId']>, ''>;
+type FileRoutePath<TParentRoute extends AnyRoute, TFilePath extends string> = ResolveFilePath<TParentRoute, TFilePath> extends `_${infer _}` ? string : ResolveFilePath<TParentRoute, TFilePath>;
+declare class FileRoute<TFilePath extends keyof FileRoutesByPath, TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'], TId extends RouteConstraints['TId'] = TFilePath, TPath extends RouteConstraints['TPath'] = FileRoutePath<TParentRoute, TFilePath>, TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, RemoveUnderScores<TPath>>> {
+    path: TFilePath;
+    constructor(path: TFilePath);
+    createRoute: <TLoader = unknown, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends Record<string, any> = (TrimLeft<TrimRight<Split<TPath, true>[number], "_">, "_"> extends infer T ? T extends TrimLeft<TrimRight<Split<TPath, true>[number], "_">, "_"> ? T extends `$${infer L}` ? L : never : never : never) extends never ? AnyPathParams : Record<TrimLeft<TrimRight<Split<TPath, true>[number], "_">, "_"> extends infer T ? T extends TrimLeft<TrimRight<Split<TPath, true>[number], "_">, "_"> ? T extends `$${infer L}` ? L : never : never : never, string>, TAllParams extends Record<string, any> = IsAny<TParentRoute["__types"]["allParams"], TParams, TParentRoute["__types"]["allParams"] & TParams>, TParentContext extends AnyContext = TParentRoute["__types"]["routeContext"], TAllParentContext extends string = TParentRoute["__types"]["context"], TRouteContext extends RouteContext = RouteContext, TContext extends AnyContext = IsAny<TParentRoute["__types"]["context"], TRouteContext, TParentRoute["__types"]["context"] & TRouteContext>, TRouterContext extends AnyContext = AnyContext, TChildren extends unknown = unknown, TRouteTree extends AnyRoute = AnyRoute>(options: Omit<RouteOptions<TParentRoute, string, string, TLoader, InferFullSearchSchema<TParentRoute>, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TContext>, "id" | "path" | "getParentRoute"> & {
+        meta?: RouteMeta | undefined;
+    } & {
+        key?: false | GetKeyFn<TFullSearchSchema, TAllParams> | null | undefined;
+        caseSensitive?: boolean | undefined;
+        wrapInSuspense?: boolean | undefined;
+        component?: ((props: RouteProps<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TContext>) => unknown) | undefined;
+        errorComponent?: ((props: {
+            error: unknown;
+        } & Partial<RouteProps<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TContext>>) => unknown) | undefined;
+        pendingComponent?: ((props: RouteProps<TLoader, TFullSearchSchema, TAllParams, TRouteContext, TContext>) => unknown) | undefined;
+        preSearchFilters?: SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
+        postSearchFilters?: SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
+        preloadMaxAge?: number | undefined;
+        maxAge?: number | undefined;
+        gcMaxAge?: number | undefined;
+        beforeLoad?: ((opts: LoaderContext<TSearchSchema, TFullSearchSchema, TAllParams, NoInfer<TRouteContext>, TContext>) => void | Promise<void>) | undefined;
+        onBeforeLoadError?: ((err: any) => void) | undefined;
+        onValidateSearchError?: ((err: any) => void) | undefined;
+        onParseParamsError?: ((err: any) => void) | undefined;
+        onLoadError?: ((err: any) => void) | undefined;
+        onError?: ((err: any) => void) | undefined;
+        onLoaded?: ((matchContext: {
+            params: TAllParams;
+            search: TFullSearchSchema;
+        }) => void | ((match: {
+            params: TAllParams;
+            search: TFullSearchSchema;
+        }) => void) | undefined) | undefined;
+        onTransition?: ((match: {
+            params: TAllParams;
+            search: TFullSearchSchema;
+        }) => void) | undefined;
+    }) => Route<TParentRoute, TPath, TFullPath, TFilePath, TId, TLoader, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TParentContext, TAllParentContext, TRouteContext, TContext, TRouterContext, TChildren, TRouteTree>;
+}
 
-declare type LinkInfo = {
+type LinkInfo = {
     type: 'external';
     href: string;
 } | {
     type: 'internal';
-    next: Location;
+    next: ParsedLocation;
     handleFocus: (e: any) => void;
     handleClick: (e: any) => void;
     handleEnter: (e: any) => void;
     handleLeave: (e: any) => void;
+    handleTouchStart: (e: any) => void;
     isActive: boolean;
     disabled?: boolean;
 };
-declare type StartsWith<A, B> = A extends `${B extends string ? B : never}${infer _}` ? true : false;
-declare type CleanPath<T extends string> = T extends `${infer L}//${infer R}` ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`> : T extends `${infer L}//` ? `${CleanPath<L>}/` : T extends `//${infer L}` ? `/${CleanPath<L>}` : T;
-declare type Split<S, TIncludeTrailingSlash = true> = S extends unknown ? string extends S ? string[] : S extends string ? CleanPath<S> extends '' ? [] : TIncludeTrailingSlash extends true ? CleanPath<S> extends `${infer T}/` ? [...Split<T>, '/'] : CleanPath<S> extends `/${infer U}` ? Split<U> : CleanPath<S> extends `${infer T}/${infer U}` ? [...Split<T>, ...Split<U>] : [S] : CleanPath<S> extends `${infer T}/${infer U}` ? [...Split<T>, ...Split<U>] : S extends string ? [S] : never : never : never;
-declare type ParsePathParams<T extends string> = Split<T>[number] extends infer U ? U extends `:${infer V}` ? V : never : never;
-declare type Join<T> = T extends [] ? '' : T extends [infer L extends string] ? L : T extends [infer L extends string, ...infer Tail extends [...string[]]] ? CleanPath<`${L}/${Join<Tail>}`> : never;
-declare type RelativeToPathAutoComplete<AllPaths extends string, TFrom extends string, TTo extends string, SplitPaths extends string[] = Split<AllPaths, false>> = TTo extends `..${infer _}` ? SplitPaths extends [
+type CleanPath<T extends string> = T extends `${infer L}//${infer R}` ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`> : T extends `${infer L}//` ? `${CleanPath<L>}/` : T extends `//${infer L}` ? `/${CleanPath<L>}` : T;
+type Split<S, TIncludeTrailingSlash = true> = S extends unknown ? string extends S ? string[] : S extends string ? CleanPath<S> extends '' ? [] : TIncludeTrailingSlash extends true ? CleanPath<S> extends `${infer T}/` ? [...Split<T>, '/'] : CleanPath<S> extends `/${infer U}` ? Split<U> : CleanPath<S> extends `${infer T}/${infer U}` ? [...Split<T>, ...Split<U>] : [S] : CleanPath<S> extends `${infer T}/${infer U}` ? [...Split<T>, ...Split<U>] : S extends string ? [S] : never : never : never;
+type ParsePathParams<T extends string> = keyof {
+    [K in Trim<Split<T>[number], '_'> as K extends `$${infer L}` ? L : never]: K;
+};
+type Join<T, Delimiter extends string = '/'> = T extends [] ? '' : T extends [infer L extends string] ? L : T extends [infer L extends string, ...infer Tail extends [...string[]]] ? CleanPath<`${L}${Delimiter}${Join<Tail>}`> : never;
+type Last<T extends any[]> = T extends [...infer _, infer L] ? L : never;
+type RelativeToPathAutoComplete<AllPaths extends string, TFrom extends string, TTo extends string, SplitPaths extends string[] = Split<AllPaths, false>> = TTo extends `..${infer _}` ? SplitPaths extends [
     ...Split<ResolveRelativePath<TFrom, TTo>, false>,
     ...infer TToRest
 ] ? `${CleanPath<Join<[
@@ -518,65 +665,60 @@ declare type RelativeToPathAutoComplete<AllPaths extends string, TFrom extends s
     ...Split<TFrom, false>,
     ...Split<RestTTo, false>,
     ...infer RestPath
-] ? `${TTo}${Join<RestPath>}` : never : './' | '../' | AllPaths;
-declare type NavigateOptionsAbsolute<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'> = ToOptions<TAllRouteInfo, TFrom, TTo> & {
+] ? `${TTo}${Join<RestPath>}` : never : (TFrom extends `/` ? never : SplitPaths extends [...Split<TFrom, false>, ...infer RestPath] ? Join<RestPath> extends {
+    length: 0;
+} ? never : './' : never) | (TFrom extends `/` ? never : '../') | AllPaths;
+type NavigateOptions<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = ToOptions<TRouteTree, TFrom, TTo> & {
     replace?: boolean;
 };
-declare type ToOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.', TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
-    to?: ToPathOption<TAllRouteInfo, TFrom, TTo>;
+type ToOptions<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
+    to?: ToPathOption<TRouteTree, TFrom, TTo>;
     hash?: Updater<string>;
     state?: LocationState;
     from?: TFrom;
-} & CheckPath<TAllRouteInfo, NoInfer<TResolvedTo>, {}> & SearchParamOptions<TAllRouteInfo, TFrom, TResolvedTo> & PathParamOptions<TAllRouteInfo, TFrom, TResolvedTo>;
-declare type SearchParamOptions<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo, TFromSchema = RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema'], TToSchema = RouteInfoByPath<TAllRouteInfo, TTo>['fullSearchSchema']> = StartsWith<TFrom, TTo> extends true ? {
-    search?: SearchReducer<TFromSchema, TToSchema>;
-} : keyof PickRequired<TToSchema> extends never ? {
-    search?: SearchReducer<TFromSchema, TToSchema>;
+} & CheckPath<TRouteTree, NoInfer<TResolvedTo>, {}> & SearchParamOptions<TRouteTree, TFrom, TResolvedTo> & PathParamOptions<TRouteTree, TFrom, TResolvedTo>;
+type SearchParamOptions<TRouteTree extends AnyRoute, TFrom, TTo, TFromSchema = UnionToIntersection<FullSearchSchema<TRouteTree> & RouteByPath<TRouteTree, TFrom> extends never ? {} : RouteByPath<TRouteTree, TFrom>['__types']['fullSearchSchema']>, TToSchema = Partial<RouteByPath<TRouteTree, TFrom>['__types']['fullSearchSchema']> & Omit<RouteByPath<TRouteTree, TTo>['__types']['fullSearchSchema'], keyof PickRequired<RouteByPath<TRouteTree, TFrom>['__types']['fullSearchSchema']>>, TFromFullSchema = UnionToIntersection<FullSearchSchema<TRouteTree> & TFromSchema>, TToFullSchema = UnionToIntersection<FullSearchSchema<TRouteTree> & TToSchema>> = keyof PickRequired<TToSchema> extends never ? {
+    search?: true | SearchReducer<TFromFullSchema, TToFullSchema>;
 } : {
-    search: SearchReducer<TFromSchema, TToSchema>;
+    search: SearchReducer<TFromFullSchema, TToFullSchema>;
 };
-declare type SearchReducer<TFrom, TTo> = {
+type SearchReducer<TFrom, TTo> = {
     [TKey in keyof TTo]: TTo[TKey];
 } | ((current: TFrom) => TTo);
-declare type PathParamOptions<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo, TFromParams = RouteInfoByPath<TAllRouteInfo, TFrom>['allParams'], TToParams = RouteInfoByPath<TAllRouteInfo, TTo>['allParams']> = StartsWith<TFrom, TTo> extends true ? {
-    params?: ParamsReducer<TFromParams, TToParams>;
-} : AnyPathParams extends TToParams ? {
-    params?: ParamsReducer<TFromParams, Record<string, never>>;
+type PathParamOptions<TRouteTree extends AnyRoute, TFrom, TTo, TFromSchema = UnionToIntersection<RouteByPath<TRouteTree, TFrom> extends never ? {} : RouteByPath<TRouteTree, TFrom>['__types']['allParams']>, TToSchema = Partial<RouteByPath<TRouteTree, TFrom>['__types']['allParams']> & Omit<RouteByPath<TRouteTree, TTo>['__types']['allParams'], keyof PickRequired<RouteByPath<TRouteTree, TFrom>['__types']['allParams']>>, TFromFullParams = UnionToIntersection<AllParams<TRouteTree> & TFromSchema>, TToFullParams = UnionToIntersection<AllParams<TRouteTree> & TToSchema>> = keyof PickRequired<TToSchema> extends never ? {
+    params?: ParamsReducer<TFromFullParams, TToFullParams>;
 } : {
-    params: ParamsReducer<TFromParams, TToParams>;
+    params: ParamsReducer<TFromFullParams, TToFullParams>;
 };
-declare type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo);
-declare type ToPathOption<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'> = TTo | RelativeToPathAutoComplete<TAllRouteInfo['routePaths'], NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
-declare type ToIdOption<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'> = TTo | RelativeToPathAutoComplete<TAllRouteInfo['routeIds'], NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
+type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo);
+type ToPathOption<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = TTo | RelativeToPathAutoComplete<RoutePaths<TRouteTree>, NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
+type ToIdOption<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = TTo | RelativeToPathAutoComplete<RouteIds<TRouteTree>, NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
 interface ActiveOptions {
     exact?: boolean;
     includeHash?: boolean;
+    includeSearch?: boolean;
 }
-declare type LinkOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'> = NavigateOptionsAbsolute<TAllRouteInfo, TFrom, TTo> & {
+type LinkOptions<TRouteTree extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo> & {
     target?: HTMLAnchorElement['target'];
     activeOptions?: ActiveOptions;
     preload?: false | 'intent';
-    preloadMaxAge?: number;
-    preloadGcMaxAge?: number;
     preloadDelay?: number;
     disabled?: boolean;
 };
-declare type CheckRelativePath<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo> = TTo extends string ? TFrom extends string ? ResolveRelativePath<TFrom, TTo> extends TAllRouteInfo['routePaths'] ? {} : {
+type CheckRelativePath<TRouteTree extends AnyRoute, TFrom, TTo> = TTo extends string ? TFrom extends string ? ResolveRelativePath<TFrom, TTo> extends RoutePaths<TRouteTree> ? {} : {
     Error: `${TFrom} + ${TTo} resolves to ${ResolveRelativePath<TFrom, TTo>}, which is not a valid route path.`;
-    'Valid Route Paths': TAllRouteInfo['routePaths'];
+    'Valid Route Paths': RoutePaths<TRouteTree>;
 } : {} : {};
-declare type CheckPath<TAllRouteInfo extends AnyAllRouteInfo, TPath, TPass> = Exclude<TPath, TAllRouteInfo['routePaths']> extends never ? TPass : CheckPathError<TAllRouteInfo, Exclude<TPath, TAllRouteInfo['routePaths']>>;
-declare type CheckPathError<TAllRouteInfo extends AnyAllRouteInfo, TInvalids> = Expand<{
-    Error: `${TInvalids extends string ? TInvalids : never} is not a valid route path.`;
-    'Valid Route Paths': TAllRouteInfo['routePaths'];
-}>;
-declare type CheckId<TAllRouteInfo extends AnyAllRouteInfo, TPath, TPass> = Exclude<TPath, TAllRouteInfo['routeIds']> extends never ? TPass : CheckIdError<TAllRouteInfo, Exclude<TPath, TAllRouteInfo['routeIds']>>;
-declare type CheckIdError<TAllRouteInfo extends AnyAllRouteInfo, TInvalids> = Expand<{
+type CheckPath<TRouteTree extends AnyRoute, TPath, TPass> = Exclude<TPath, RoutePaths<TRouteTree>> extends never ? TPass : CheckPathError<TRouteTree, Exclude<TPath, RoutePaths<TRouteTree>>>;
+type CheckPathError<TRouteTree extends AnyRoute, TInvalids> = {
+    to: RoutePaths<TRouteTree>;
+};
+type CheckId<TRouteTree extends AnyRoute, TPath, TPass> = Exclude<TPath, RouteIds<TRouteTree>> extends never ? TPass : CheckIdError<TRouteTree, Exclude<TPath, RouteIds<TRouteTree>>>;
+type CheckIdError<TRouteTree extends AnyRoute, TInvalids> = {
     Error: `${TInvalids extends string ? TInvalids : never} is not a valid route ID.`;
-    'Valid Route IDs': TAllRouteInfo['routeIds'];
-}>;
-declare type ResolveRelativePath<TFrom, TTo = '.'> = TFrom extends string ? TTo extends string ? TTo extends '.' ? TFrom : TTo extends `./` ? Join<[TFrom, '/']> : TTo extends `./${infer TRest}` ? ResolveRelativePath<TFrom, TRest> : TTo extends `/${infer TRest}` ? TTo : Split<TTo> extends ['..', ...infer ToRest] ? Split<TFrom> extends [...infer FromRest, infer FromTail] ? ToRest extends ['/'] ? Join<[...FromRest, '/']> : ResolveRelativePath<Join<FromRest>, Join<ToRest>> : never : Split<TTo> extends ['.', ...infer ToRest] ? ToRest extends ['/'] ? Join<[TFrom, '/']> : ResolveRelativePath<TFrom, Join<ToRest>> : CleanPath<Join<['/', ...Split<TFrom>, ...Split<TTo>]>> : never : never;
-declare type ValidFromPath<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo> = undefined | (string extends TAllRouteInfo['routePaths'] ? string : TAllRouteInfo['routePaths']);
+    'Valid Route IDs': RouteIds<TRouteTree>;
+};
+type ResolveRelativePath<TFrom, TTo = '.'> = TFrom extends string ? TTo extends string ? TTo extends '.' ? TFrom : TTo extends `./` ? Join<[TFrom, '/']> : TTo extends `./${infer TRest}` ? ResolveRelativePath<TFrom, TRest> : TTo extends `/${infer TRest}` ? TTo : Split<TTo> extends ['..', ...infer ToRest] ? Split<TFrom> extends [...infer FromRest, infer FromTail] ? ToRest extends ['/'] ? Join<[...FromRest, '/']> : ResolveRelativePath<Join<FromRest>, Join<ToRest>> : never : Split<TTo> extends ['.', ...infer ToRest] ? ToRest extends ['/'] ? Join<[TFrom, '/']> : ResolveRelativePath<TFrom, Join<ToRest>> : CleanPath<Join<['/', ...Split<TFrom>, ...Split<TTo>]>> : never : never;
 
 interface Segment {
     type: 'pathname' | 'param' | 'wildcard';
@@ -589,9 +731,9 @@ declare function trimPathRight(path: string): string;
 declare function trimPath(path: string): string;
 declare function resolvePath(basepath: string, base: string, to: string): string;
 declare function parsePathname(pathname?: string): Segment[];
-declare function interpolatePath(path: string | undefined, params: any, leaveWildcard?: boolean): string;
-declare function matchPathname(currentPathname: string, matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>): AnyPathParams | undefined;
-declare function matchByPath(from: string, matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>): Record<string, string> | undefined;
+declare function interpolatePath(path: string | undefined, params: any, leaveWildcards?: boolean): string;
+declare function matchPathname(basepath: string, currentPathname: string, matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>): AnyPathParams | undefined;
+declare function matchByPath(basepath: string, from: string, matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>): Record<string, string> | undefined;
 
 declare function encode(obj: any, pfx?: string): string;
 declare function decode(str: any): {};
@@ -599,6 +741,6 @@ declare function decode(str: any): {};
 declare const defaultParseSearch: (searchStr: string) => AnySearchSchema;
 declare const defaultStringifySearch: (search: Record<string, any>) => string;
 declare function parseSearchWith(parser: (str: string) => any): (searchStr: string) => AnySearchSchema;
-declare function stringifySearchWith(stringify: (search: any) => string): (search: Record<string, any>) => string;
+declare function stringifySearchWith(stringify: (search: any) => string, parser?: (str: string) => any): (search: Record<string, any>) => string;
 
-export { Action, ActionFn, ActionState, AllRouteInfo, AnyAllRouteInfo, AnyLoaderData, AnyPathParams, AnyRoute, AnyRouteConfig, AnyRouteConfigWithChildren, AnyRouteInfo, AnySearchSchema, BuildNextOptions, CheckId, CheckIdError, CheckPath, CheckPathError, CheckRelativePath, DeepAwaited, DefaultAllRouteInfo, DefinedPathParamWarning, Expand, FilterRoutesFn, FrameworkGenerics, FromLocation, GetFrameworkGeneric, IsAny, IsAnyBoolean, IsKnown, LinkInfo, LinkOptions, ListenerFn, Loader, LoaderContext, LoaderFn, LoaderState, Location, LocationState, MatchCacheEntry, MatchLocation, MatchRouteOptions, NavigateOptionsAbsolute, NoInfer, ParentParams, ParsePathParams, ParseRouteConfig, PathParamMask, PendingState, PickAsPartial, PickAsRequired, PickExclude, PickExtra, PickExtract, PickRequired, PickUnsafe, RelativeToPathAutoComplete, ResolveRelativePath, RootRouteId, Route, RouteConfig, RouteConfigRoute, RouteInfo, RouteInfoById, RouteInfoByPath, RouteMatch, RouteMeta, RouteOptions, Router, RouterOptions, RouterState, RoutesById, RoutesInfoInner, SearchFilter, SearchParser, SearchSchemaValidator, SearchSchemaValidatorFn, SearchSchemaValidatorObj, SearchSerializer, Segment, Split, Timeout, ToIdOption, ToOptions, ToPathOption, UnloaderFn, Updater, ValidFromPath, ValueKeys, Values, cleanPath, createRoute, createRouteConfig, createRouteMatch, createRouter, decode, defaultParseSearch, defaultStringifySearch, encode, functionalUpdate, interpolatePath, joinPaths, last, matchByPath, matchPathname, parsePathname, parseSearchWith, pick, replaceEqualDeep, resolvePath, rootRouteId, stringifySearchWith, trimPath, trimPathLeft, trimPathRight, warning };
+export { ActiveOptions, AllParams, AnyContext, AnyPathParams, AnyRedirect, AnyRootRoute, AnyRoute, AnyRouteMatch, AnyRouteProps, AnyRouter, AnySearchSchema, BaseRouteOptions, BuildNextOptions, CheckId, CheckIdError, CheckPath, CheckPathError, CheckRelativePath, CleanPath, ComponentFromRoute, ComponentPropsFromRoute, DeepAwaited, DefinedPathParamWarning, DehydratedRouter, DehydratedRouterState, Expand, FileRoute, FileRoutePath, FileRoutesByPath, FromLocation, FullSearchSchema, GetKeyFn, HydrationCtx, InferFullSearchSchema, IsAny, IsAnyBoolean, IsKnown, Join, Last, LinkInfo, LinkOptions, ListenerFn, LoaderContext, LoaderFn, LocationState, MatchLocation, MatchRouteOptions, MergeParamsFromParent, MergeUnion, MetaOptions, NavigateOptions, NoInfer, ParamsFallback, ParentParams, ParseParamsFn, ParseParamsObj, ParseParamsOption, ParsePathParams, ParseRoute, ParseRouteChildren, ParsedLocation, ParsedPath, PathParamError, PathParamMask, PathParamOptions, PickAsPartial, PickAsRequired, PickExclude, PickExtra, PickExtract, PickRequired, PickUnsafe, PreloadableObj, Redirect, Register, RegisterRouteComponent, RegisterRouteErrorComponent, RegisteredRouteComponent, RegisteredRouteErrorComponent, RegisteredRouter, RelativeToPathAutoComplete, RemoveUnderScores, ResolveFilePath, ResolveFullPath, ResolveFullSearchSchema, ResolveId, ResolveRelativePath, RootRoute, RootRouteId, Route, RouteById, RouteByPath, RouteConstraints, RouteContext, RouteIds, RouteLoaderFromRoute, RouteMatch, RouteMeta, RouteOptions, RoutePathOptions, RoutePathOptionsIntersection, RoutePaths, RouteProps, Router, RouterConstructorOptions, RouterContext, RouterContextOptions, RouterHistory, RouterLocation, RouterOptions, RouterState, RoutesById, RoutesByPath, SearchFilter, SearchParamError, SearchParamOptions, SearchParser, SearchSchemaValidator, SearchSchemaValidatorFn, SearchSchemaValidatorObj, SearchSerializer, Segment, Split, StreamedPromise, Timeout, ToIdOption, ToOptions, ToPathOption, Trim, TrimLeft, TrimPath, TrimPathLeft, TrimPathRight, TrimRight, UnionToIntersection, UnloaderFn, UpdatableRouteOptions, Updater, UseLoaderResult, UseLoaderResultPromise, ValueKeys, Values, cleanPath, componentTypes, createBrowserHistory, createHashHistory, createMemoryHistory, decode, defaultParseSearch, defaultStringifySearch, encode, functionalUpdate, interpolatePath, isPlainObject, isRedirect, joinPaths, last, lazyFn, matchByPath, matchPathname, parsePathname, parseSearchWith, partialDeepEqual, pick, redirect, replaceEqualDeep, resolvePath, rootRouteId, stringifySearchWith, trimPath, trimPathLeft, trimPathRight };