@tanstack/router-core 0.0.1-beta.5 → 0.0.1-beta.50

package/build/types/index.d.ts

@@ -8,57 +8,96 @@
  *
  * @license MIT
  */
-import { BrowserHistory, MemoryHistory, HashHistory, History } from 'history';
-export { createBrowserHistory, createHashHistory, createMemoryHistory } from 'history';
 export { default as invariant } from 'tiny-invariant';
 
+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;
+}
+interface ParsedPath {
+    href: string;
+    pathname: string;
+    search: string;
+    hash: string;
+}
+interface RouterLocation extends ParsedPath {
+    state: any;
+}
+declare function createBrowserHistory(opts?: {
+    getHref?: () => string;
+    createHref?: (path: string) => string;
+}): RouterHistory;
+declare function createHashHistory(): RouterHistory;
+declare function createMemoryHistory(opts?: {
+    initialEntries: string[];
+    initialIndex?: number;
+}): RouterHistory;
+
 interface FrameworkGenerics {
 }
-declare type GetFrameworkGeneric<U> = U extends keyof FrameworkGenerics ? FrameworkGenerics[U] : any;
+type GetFrameworkGeneric<U> = U extends keyof FrameworkGenerics ? FrameworkGenerics[U] : any;
 
-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 Store<TState> = {
+    state: TState;
+    subscribe: (listener: (next: TState, prev: TState) => void) => () => void;
+    setState: (updater: (cb: TState) => void) => void;
+};
+declare function createStore<TState>(initialState: TState, debug?: boolean): Store<TState>;
+declare function batch(cb: () => void): void;
+
+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> = Expand<{
     [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 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];
 };
-/**
- * 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.
- */
-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>;
 
+interface RegisterRouter {
+}
+type AnyRouter = Router<any, any, any>;
+type RegisteredRouter = RegisterRouter extends {
+    router: Router<infer TRouteConfig, infer TAllRouteInfo, infer TRouterContext>;
+} ? Router<TRouteConfig, TAllRouteInfo, TRouterContext> : Router;
+type RegisteredAllRouteInfo = RegisterRouter extends {
+    router: Router<infer TRouteConfig, infer TAllRouteInfo, infer TRouterContext>;
+} ? TAllRouteInfo : AnyAllRouteInfo;
 interface LocationState {
 }
-interface Location<TSearchObj extends AnySearchSchema = {}, TState extends LocationState = LocationState> {
+interface ParsedLocation<TSearchObj extends AnySearchSchema = {}, TState extends LocationState = LocationState> {
     href: string;
     pathname: string;
     search: TSearchObj;
@@ -73,11 +112,11 @@ 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 FilterRoutesFn = <TRoute extends Route<any, RouteInfo>>(routeConfigs: TRoute[]) => TRoute[];
+interface RouterOptions<TRouteConfig extends AnyRouteConfig, TRouterContext> {
+    history?: RouterHistory;
     stringifySearch?: SearchSerializer;
     parseSearch?: SearchParser;
     filterRoutes?: FilterRoutesFn;
@@ -85,38 +124,29 @@ interface RouterOptions<TRouteConfig extends AnyRouteConfig> {
     defaultPreloadMaxAge?: number;
     defaultPreloadGcMaxAge?: number;
     defaultPreloadDelay?: number;
-    useErrorBoundary?: boolean;
-    defaultElement?: GetFrameworkGeneric<'Element'>;
-    defaultErrorElement?: GetFrameworkGeneric<'Element'>;
-    defaultCatchElement?: GetFrameworkGeneric<'Element'>;
-    defaultPendingElement?: GetFrameworkGeneric<'Element'>;
-    defaultPendingMs?: number;
-    defaultPendingMinMs?: number;
+    defaultComponent?: GetFrameworkGeneric<'Component'>;
+    defaultErrorComponent?: GetFrameworkGeneric<'ErrorComponent'>;
+    defaultPendingComponent?: GetFrameworkGeneric<'Component'>;
     defaultLoaderMaxAge?: number;
     defaultLoaderGcMaxAge?: number;
     caseSensitive?: boolean;
     routeConfig?: TRouteConfig;
     basepath?: string;
-    createRouter?: (router: Router<any, any>) => void;
+    useServerData?: boolean;
+    createRouter?: (router: AnyRouter) => void;
     createRoute?: (opts: {
         route: AnyRoute;
-        router: Router<any, any>;
+        router: AnyRouter;
     }) => void;
-    createElement?: (element: GetFrameworkGeneric<'SyncOrAsyncElement'>) => Promise<GetFrameworkGeneric<'Element'>>;
-}
-interface Action<TPayload = unknown, TResponse = unknown> {
-    submit: (submission?: TPayload) => Promise<TResponse>;
-    current?: ActionState<TPayload, TResponse>;
-    latest?: ActionState<TPayload, TResponse>;
-    pending: ActionState<TPayload, TResponse>[];
-}
-interface ActionState<TPayload = unknown, TResponse = unknown> {
-    submittedAt: number;
-    status: 'idle' | 'pending' | 'success' | 'error';
-    submission: TPayload;
-    data?: TResponse;
-    error?: unknown;
+    context?: TRouterContext;
+    loadComponent?: (component: GetFrameworkGeneric<'Component'>) => Promise<GetFrameworkGeneric<'Component'>>;
+    onRouteChange?: () => void;
+    fetchServerDataFn?: FetchServerDataFn;
 }
+type FetchServerDataFn = (ctx: {
+    router: AnyRouter;
+    routeMatch: RouteMatch;
+}) => Promise<any>;
 interface Loader<TFullSearchSchema extends AnySearchSchema = {}, TAllParams extends AnyPathParams = {}, TRouteLoaderData = AnyLoaderData> {
     fetch: keyof PickRequired<TFullSearchSchema> extends never ? keyof TAllParams extends never ? (loaderContext: {
         signal?: AbortSignal;
@@ -136,41 +166,37 @@ interface Loader<TFullSearchSchema extends AnySearchSchema = {}, TAllParams exte
     latest?: LoaderState<TFullSearchSchema, TAllParams>;
     pending: LoaderState<TFullSearchSchema, TAllParams>[];
 }
-interface LoaderState<TFullSearchSchema = unknown, TAllParams = unknown> {
+interface LoaderState<TFullSearchSchema extends AnySearchSchema = {}, TAllParams extends AnyPathParams = {}> {
     loadedAt: number;
     loaderContext: LoaderContext<TFullSearchSchema, TAllParams>;
 }
-interface RouterState {
+interface RouterStore<TSearchObj extends AnySearchSchema = {}, TState extends LocationState = LocationState> {
     status: 'idle' | 'loading';
-    location: Location;
-    matches: RouteMatch[];
+    latestLocation: ParsedLocation<TSearchObj, TState>;
+    currentMatches: RouteMatch[];
+    currentLocation: ParsedLocation<TSearchObj, TState>;
+    pendingMatches?: RouteMatch[];
+    pendingLocation?: ParsedLocation<TSearchObj, TState>;
     lastUpdated: number;
-    currentAction?: ActionState;
-    latestAction?: ActionState;
-    actions: Record<string, Action>;
     loaders: Record<string, Loader>;
-    pending?: PendingState;
     isFetching: boolean;
     isPreloading: boolean;
+    matchCache: Record<string, MatchCacheEntry>;
 }
-interface PendingState {
-    location: Location;
-    matches: RouteMatch[];
-}
-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>[];
 }
-declare type MatchCacheEntry = {
+type MatchCacheEntry = {
     gc: number;
     match: RouteMatch;
 };
@@ -182,50 +208,60 @@ interface MatchLocation {
     fromCurrent?: boolean;
 }
 interface MatchRouteOptions {
-    pending: boolean;
+    pending?: boolean;
     caseSensitive?: boolean;
+    fuzzy?: boolean;
+}
+interface DehydratedRouterState extends Pick<RouterStore, 'status' | 'latestLocation' | 'currentLocation' | 'lastUpdated'> {
+    currentMatches: DehydratedRouteMatch[];
+}
+interface DehydratedRouter<TRouterContext = unknown> {
+    state: DehydratedRouterState;
+    context: TRouterContext;
+}
+type MatchCache = Record<string, MatchCacheEntry>;
+interface DehydratedRouteMatch {
+    matchId: string;
+    state: Pick<RouteMatchStore<any, any>, 'status' | 'routeLoaderData' | 'invalid' | 'invalidAt'>;
+}
+interface RouterContext {
 }
-interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>> {
-    history: BrowserHistory | MemoryHistory | HashHistory;
-    options: PickAsRequired<RouterOptions<TRouteConfig>, 'stringifySearch' | 'parseSearch'>;
+declare const defaultFetchServerDataFn: FetchServerDataFn;
+declare class Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>, TRouterContext = unknown> {
+    #private;
+    types: {
+        RouteConfig: TRouteConfig;
+        AllRouteInfo: TAllRouteInfo;
+    };
+    options: PickAsRequired<RouterOptions<TRouteConfig, TRouterContext>, '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>;
-    removeActionQueue: {
-        action: Action;
-        actionState: ActionState;
-    }[];
+    navigateTimeout: undefined | Timeout;
+    nextAction: undefined | 'push' | 'replace';
+    navigationPromise: undefined | Promise<void>;
+    store: Store<RouterStore<TAllRouteInfo['fullSearchSchema']>>;
     startedLoadingAt: number;
     resolveNavigation: () => void;
-    subscribe: (listener: Listener) => () => void;
-    notify: () => void;
+    constructor(options?: RouterOptions<TRouteConfig, TRouterContext>);
+    reset: () => void;
     mount: () => () => void;
-    onFocus: () => void;
-    update: <TRouteConfig extends RouteConfig = RouteConfig>(opts?: RouterOptions<TRouteConfig>) => Router<TRouteConfig>;
-    buildNext: (opts: BuildNextOptions) => Location;
+    update: <TRouteConfig_1 extends RouteConfig<string, string, string, string, AnyLoaderData, AnyLoaderData, {}, AnyLoaderData, {}, {}, {}, {}, {}, {}, unknown> = RouteConfig<string, string, string, string, AnyLoaderData, AnyLoaderData, {}, AnyLoaderData, {}, {}, {}, {}, {}, {}, unknown>, TAllRouteInfo_1 extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig_1>, TRouterContext_1 = unknown>(opts?: RouterOptions<TRouteConfig_1, TRouterContext_1> | undefined) => Router<TRouteConfig_1, TAllRouteInfo_1, TRouterContext_1>;
+    buildNext: (opts: BuildNextOptions) => ParsedLocation<{}, LocationState>;
     cancelMatches: () => void;
-    loadLocation: (next?: Location) => Promise<void>;
-    matchCache: Record<string, MatchCacheEntry>;
+    load: (next?: ParsedLocation) => Promise<void>;
     cleanMatchCache: () => void;
-    getRoute: <TId extends keyof TAllRouteInfo['routeInfoById']>(id: TId) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]>;
-    loadRoute: (navigateOpts: BuildNextOptions) => Promise<RouteMatch[]>;
-    preloadRoute: (navigateOpts: BuildNextOptions, loaderOpts: {
+    getRoute: <TId extends keyof TAllRouteInfo["routeInfoById"]>(id: TId) => Route<TAllRouteInfo, TAllRouteInfo["routeInfoById"][TId], unknown>;
+    loadRoute: (navigateOpts?: BuildNextOptions) => Promise<RouteMatch[]>;
+    preloadRoute: (navigateOpts: BuildNextOptions | undefined, loaderOpts: {
         maxAge?: number;
         gcMaxAge?: number;
-    }) => Promise<RouteMatch[]>;
+    }) => Promise<RouteMatch<DefaultAllRouteInfo, RouteInfo<string, string, string, "/", {}, {}, {}, {}, {}, {}, {}, {}, {}, {}>>[]>;
     matchRoutes: (pathname: string, opts?: {
         strictParseParams?: boolean;
-    }) => RouteMatch[];
+    }) => RouteMatch<DefaultAllRouteInfo, RouteInfo<string, string, string, "/", {}, {}, {}, {}, {}, {}, {}, {}, {}, {}>>[];
     loadMatches: (resolvedMatches: RouteMatch[], loaderOpts?: {
-        withPending?: boolean;
-    } & ({
         preload: true;
         maxAge: number;
         gcMaxAge: number;
@@ -233,71 +269,59 @@ interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInf
         preload?: false;
         maxAge?: never;
         gcMaxAge?: never;
-    })) => Promise<void>;
-    invalidateRoute: (opts: MatchLocation) => void;
-    reload: () => Promise<void>;
+    }) => Promise<void>;
+    loadMatchData: (routeMatch: RouteMatch<any, any>) => Promise<Record<string, unknown>>;
+    invalidateRoute: (opts: MatchLocation) => Promise<void>;
+    reload: () => 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;
-    __: {
-        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>;
-    };
+    navigate: <TFrom extends ValidFromPath<TAllRouteInfo> = "/", TTo extends string = ".">({ from, to, search, hash, replace, params, }: NavigateOptions<TAllRouteInfo, TFrom, TTo>) => Promise<void>;
+    matchRoute: <TFrom extends ValidFromPath<TAllRouteInfo> = "/", TTo extends string = ".">(location: ToOptions<TAllRouteInfo, TFrom, TTo, ResolveRelativePath<TFrom, NoInfer<TTo>>>, opts?: MatchRouteOptions) => false | TAllRouteInfo["routeInfoById"][ResolveRelativePath<TFrom, NoInfer<TTo>>]["allParams"];
+    buildLink: <TFrom extends ValidFromPath<TAllRouteInfo> = "/", TTo extends string = ".">({ from, to, search, params, hash, target, replace, activeOptions, preload, preloadMaxAge: userPreloadMaxAge, preloadGcMaxAge: userPreloadGcMaxAge, preloadDelay: userPreloadDelay, disabled, }: LinkOptions<TAllRouteInfo, TFrom, TTo>) => LinkInfo;
+    dehydrate: () => DehydratedRouter<TRouterContext>;
+    hydrate: (dehydratedRouter: DehydratedRouter<TRouterContext>) => void;
+    getLoader: <TFrom extends keyof TAllRouteInfo["routeInfoById"] = "/">(opts: {
+        from: TFrom;
+    }) => unknown extends TAllRouteInfo["routeInfoById"][TFrom]["routeLoaderData"] ? Loader<LoaderContext<TAllRouteInfo["routeInfoById"][TFrom]["fullSearchSchema"], TAllRouteInfo["routeInfoById"][TFrom]["allParams"]>, TAllRouteInfo["routeInfoById"][TFrom]["routeLoaderData"], AnyLoaderData> | undefined : Loader<TAllRouteInfo["routeInfoById"][TFrom]["fullSearchSchema"], TAllRouteInfo["routeInfoById"][TFrom]["allParams"], TAllRouteInfo["routeInfoById"][TFrom]["routeLoaderData"]>;
 }
-declare function createRouter<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>>(userOptions?: RouterOptions<TRouteConfig>): Router<TRouteConfig, TAllRouteInfo>;
 
-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[];
+interface RouteMatchStore<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> {
     routeSearch: TRouteInfo['searchSchema'];
-    search: TRouteInfo['fullSearchSchema'];
+    search: Expand<TAllRouteInfo['fullSearchSchema'] & TRouteInfo['fullSearchSchema']>;
     status: 'idle' | 'loading' | 'success' | 'error';
     updatedAt?: number;
     error?: unknown;
-    isInvalid: boolean;
-    getIsInvalid: () => boolean;
+    invalid: boolean;
     loaderData: TRouteInfo['loaderData'];
     routeLoaderData: TRouteInfo['routeLoaderData'];
     isFetching: boolean;
-    isPending: boolean;
     invalidAt: number;
-    __: {
-        element?: GetFrameworkGeneric<'Element'>;
-        errorElement?: GetFrameworkGeneric<'Element'>;
-        catchElement?: GetFrameworkGeneric<'Element'>;
-        pendingElement?: GetFrameworkGeneric<'Element'>;
-        loadPromise?: Promise<void>;
-        loaderPromise?: Promise<void>;
-        elementsPromise?: Promise<void>;
-        dataPromise?: Promise<void>;
-        pendingTimeout?: Timeout;
-        pendingMinTimeout?: Timeout;
-        pendingMinPromise?: Promise<void>;
-        onExit?: void | ((matchContext: {
-            params: TRouteInfo['allParams'];
-            search: TRouteInfo['fullSearchSchema'];
-        }) => void);
-        abortController: AbortController;
-        latestId: string;
-        validate: () => void;
-        startPending: () => void;
-        cancelPending: () => void;
-        notify: () => void;
-        resolve: () => void;
-    };
+}
+declare class RouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> {
+    #private;
+    route: Route<TAllRouteInfo, TRouteInfo>;
+    router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>;
+    store: Store<RouteMatchStore<TAllRouteInfo, TRouteInfo>>;
+    id: string;
+    pathname: string;
+    params: TRouteInfo['allParams'];
+    component: GetFrameworkGeneric<'Component'>;
+    errorComponent: GetFrameworkGeneric<'ErrorComponent'>;
+    pendingComponent: GetFrameworkGeneric<'Component'>;
+    abortController: AbortController;
+    onLoaderDataListeners: Set<() => void>;
+    parentMatch?: RouteMatch;
+    __loadPromise?: Promise<void>;
+    __onExit?: void | ((matchContext: {
+        params: TRouteInfo['allParams'];
+        search: TRouteInfo['fullSearchSchema'];
+    }) => void);
+    constructor(router: AnyRouter, route: Route<TAllRouteInfo, TRouteInfo>, opts: {
+        matchId: string;
+        params: TRouteInfo['allParams'];
+        pathname: string;
+    });
     cancel: () => void;
     load: (loaderOpts?: {
-        withPending?: boolean;
-    } & ({
         preload: true;
         maxAge: number;
         gcMaxAge: number;
@@ -305,129 +329,45 @@ interface RouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo
         preload?: false;
         maxAge?: never;
         gcMaxAge?: never;
-    })) => Promise<TRouteInfo['routeLoaderData']>;
+    }) => Promise<void>;
     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: {
-    matchId: string;
-    params: TRouteInfo['allParams'];
-    pathname: string;
-}): RouteMatch<TAllRouteInfo, TRouteInfo>;
-
-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>;
-declare function cascadeLoaderData(matches: RouteMatch<any, any>[]): void;
-
-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 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, 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> = 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> {
-}
-interface RouteInfo<TId extends string = string, TRouteId extends string = string, TPath extends string = string, TFullPath extends string = string, 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;
-    routeLoaderData: TRouteLoaderData;
-    loaderData: TLoaderData;
-    actionPayload: TActionPayload;
-    actionResponse: TActionResponse;
-    searchSchema: TSearchSchema;
-    fullSearchSchema: TFullSearchSchema;
-    parentParams: TParentParams;
-    params: TParams;
-    allParams: TAllParams;
-    options: RouteOptions<TRouteId, TPath, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams>;
+    invalidate: () => Promise<void>;
+    __hasLoaders: () => boolean;
+    getIsInvalid: () => boolean;
+    __setParentMatch: (parentMatch?: RouteMatch) => void;
+    __onLoaderData: (listener: () => void) => void;
+    __validate: () => void;
 }
-declare type RoutesById<TAllRouteInfo extends AnyAllRouteInfo> = {
-    [K in keyof TAllRouteInfo['routeInfoById']]: Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][K]>;
-};
-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 const rootRouteId: "__root__";
-declare type RootRouteId = typeof rootRouteId;
-declare type AnyLoaderData = {};
-declare type AnyPathParams = {};
-declare type AnySearchSchema = {};
+type RootRouteId = typeof rootRouteId;
+type AnyLoaderData = {};
+type AnyPathParams = {};
+type AnySearchSchema = {};
 interface RouteMeta {
 }
-declare type SearchSchemaValidator<TReturn, TParentSchema> = SearchSchemaValidatorObj<TReturn, TParentSchema> | SearchSchemaValidatorFn<TReturn, TParentSchema>;
-declare type SearchSchemaValidatorObj<TReturn, TParentSchema> = {
+type SearchSchemaValidator<TReturn, TParentSchema> = SearchSchemaValidatorObj<TReturn, TParentSchema> | SearchSchemaValidatorFn<TReturn, TParentSchema>;
+type SearchSchemaValidatorObj<TReturn, TParentSchema> = {
     parse?: SearchSchemaValidatorFn<TReturn, TParentSchema>;
 };
-declare type SearchSchemaValidatorFn<TReturn, TParentSchema> = (searchObj: Record<string, unknown>) => {} extends TParentSchema ? TReturn : keyof TReturn extends keyof TParentSchema ? {
+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 ? {} : {
+type DefinedPathParamWarning = 'Path params cannot be redefined by child routes!';
+type ParentParams<TParentParams> = AnyPathParams extends TParentParams ? {} : {
     [Key in keyof TParentParams]?: DefinedPathParamWarning;
 };
-declare type LoaderFn<TRouteLoaderData extends AnyLoaderData, TFullSearchSchema extends AnySearchSchema = {}, TAllParams extends AnyPathParams = {}> = (loaderContext: LoaderContext<TFullSearchSchema, TAllParams>) => Promise<TRouteLoaderData>;
+type LoaderFn<TRouteLoaderData extends AnyLoaderData = {}, TFullSearchSchema extends AnySearchSchema = {}, TAllParams extends AnyPathParams = {}> = (loaderContext: LoaderContext<TFullSearchSchema, TAllParams>) => TRouteLoaderData | Promise<TRouteLoaderData>;
 interface LoaderContext<TFullSearchSchema extends AnySearchSchema = {}, TAllParams extends AnyPathParams = {}> {
     params: TAllParams;
     search: TFullSearchSchema;
     signal?: AbortSignal;
 }
-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, 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 = {}> = ({
+type UnloaderFn<TPath extends string> = (routeMatch: RouteMatch<any, RouteInfo<string, TPath>>) => void;
+type RouteOptions<TRouteId extends string = string, TPath extends string = string, TParentRouteLoaderData extends AnyLoaderData = {}, TRouteLoaderData extends AnyLoaderData = {}, TParentLoaderData extends AnyLoaderData = {}, TLoaderData extends AnyLoaderData = {}, 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;
@@ -436,18 +376,18 @@ declare type RouteOptions<TRouteId extends string = string, TPath extends string
     validateSearch?: SearchSchemaValidator<TSearchSchema, TParentSearchSchema>;
     preSearchFilters?: SearchFilter<TFullSearchSchema>[];
     postSearchFilters?: SearchFilter<TFullSearchSchema>[];
-    pendingMs?: number;
-    pendingMinMs?: number;
-    element?: GetFrameworkGeneric<'SyncOrAsyncElement'>;
-    errorElement?: GetFrameworkGeneric<'SyncOrAsyncElement'>;
-    catchElement?: GetFrameworkGeneric<'SyncOrAsyncElement'>;
-    pendingElement?: GetFrameworkGeneric<'SyncOrAsyncElement'>;
+    component?: GetFrameworkGeneric<'Component'>;
+    errorComponent?: GetFrameworkGeneric<'ErrorComponent'>;
+    pendingComponent?: GetFrameworkGeneric<'Component'>;
     loader?: LoaderFn<TRouteLoaderData, TFullSearchSchema, TAllParams>;
     loaderMaxAge?: number;
     loaderGcMaxAge?: number;
-    action?: ActionFn<TActionPayload, TActionResponse>;
-    useErrorBoundary?: boolean;
-    onMatch?: (matchContext: {
+    beforeLoad?: (opts: {
+        router: AnyRouter;
+        match: RouteMatch;
+    }) => Promise<void> | void;
+    onLoadError?: (err: any) => void;
+    onLoaded?: (matchContext: {
         params: TAllParams;
         search: TFullSearchSchema;
     }) => void | undefined | ((match: {
@@ -466,44 +406,130 @@ declare type RouteOptions<TRouteId extends string = string, TPath extends string
     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, 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 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, TParentLoaderData extends AnyLoaderData = {}, TLoaderData extends AnyLoaderData = AnyLoaderData, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}, TParams extends AnyPathParams = {}, TAllParams extends AnyPathParams = {}, TKnownChildren = unknown> {
     id: TId;
     routeId: TRouteId;
     path: NoInfer<TPath>;
     fullPath: TFullPath;
-    options: RouteOptions<TRouteId, TPath, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams>;
+    options: RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, 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, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams, TNewChildren>>;
-    createChildren: IsAny<TId, any, <TNewChildren extends any>(cb: (createChildRoute: CreateRouteConfigFn<false, TId, TFullPath, TLoaderData, TFullSearchSchema, TAllParams>) => TNewChildren extends AnyRouteConfig[] ? TNewChildren : {
-        error: 'Invalid route detected';
-        route: TNewChildren;
-    }) => RouteConfig<TId, TRouteId, TPath, TFullPath, TRouteLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams, TNewChildren>>;
-    createRoute: CreateRouteConfigFn<false, TId, TFullPath, TLoaderData, TFullSearchSchema, TAllParams>;
+    }) => RouteConfig<TId, TRouteId, TPath, TFullPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams, TNewChildren>>;
+    createRoute: CreateRouteConfigFn<false, TId, TFullPath, TRouteLoaderData, TLoaderData, TFullSearchSchema, TAllParams>;
+    generate: GenerateFn<TRouteId, TPath, TParentRouteLoaderData, TParentLoaderData, TParentSearchSchema, TParentParams>;
 }
-declare type CreateRouteConfigFn<TIsRoot extends boolean = false, TParentId extends string = string, TParentPath extends string = string, TParentAllLoaderData 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, TRouteLoaderData, Expand<TParentAllLoaderData & DeepAwaited<NoInfer<TRouteLoaderData>>>, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, Expand<TParentSearchSchema & TSearchSchema>, TParentParams, TParams, Expand<TParentParams & TAllParams>>, 'path'> & {
+type GenerateFn<TRouteId extends string = string, TPath extends string = string, TParentRouteLoaderData extends AnyLoaderData = AnyLoaderData, TParentLoaderData extends AnyLoaderData = {}, TParentSearchSchema extends {} = {}, TParentParams extends AnyPathParams = {}> = <TRouteLoaderData extends AnyLoaderData = AnyLoaderData, TSearchSchema extends 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>>(options: Omit<RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>, TParentSearchSchema, TSearchSchema, Expand<TParentSearchSchema & TSearchSchema>, TParentParams, TParams, Expand<TParentParams & TAllParams>>, 'path'>) => void;
+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, 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, TParentLoaderData, Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>, TParentSearchSchema, TSearchSchema, Expand<TParentSearchSchema & TSearchSchema>, TParentParams, TParams, Expand<TParentParams & TAllParams>>, 'path'> & {
     path?: never;
-} : RouteOptions<TRouteId, TPath, TRouteLoaderData, Expand<TParentAllLoaderData & 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>>, TRouteLoaderData, Expand<TParentAllLoaderData & 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;
+} : RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>, 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, TParentLoaderData, Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>, TParentSearchSchema, TSearchSchema, Expand<TParentSearchSchema & TSearchSchema>, TParentParams, TParams, Expand<TParentParams & TAllParams>, TKnownChildren>;
+type RoutePath<T extends string> = T extends RootRouteId ? '/' : TrimPathRight<`${T}`>;
+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> {
 }
 interface AnyRouteConfigWithChildren<TChildren> extends RouteConfig<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;
+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;
 declare const createRouteConfig: CreateRouteConfigFn<true>;
 
-declare type LinkInfo = {
+interface AnyRoute extends Route<any, any, any> {
+}
+declare class Route<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo, TRouterContext = unknown> {
+    routeInfo: TRouteInfo;
+    id: TRouteInfo['id'];
+    customId: TRouteInfo['customId'];
+    path: TRouteInfo['path'];
+    fullPath: TRouteInfo['fullPath'];
+    getParentRoute: () => undefined | AnyRoute;
+    childRoutes?: AnyRoute[];
+    options: RouteOptions;
+    originalIndex: number;
+    getRouter: () => Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>;
+    constructor(routeConfig: RouteConfig, options: TRouteInfo['options'], originalIndex: number, parent: undefined | Route<TAllRouteInfo, any>, router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>);
+}
+
+interface AnyAllRouteInfo {
+    routeConfig: AnyRouteConfig;
+    routeInfo: AnyRouteInfo;
+    routeInfoById: Record<string, AnyRouteInfo>;
+    routeInfoByFullPath: Record<string, AnyRouteInfo>;
+    routeIds: any;
+    routePaths: any;
+    fullSearchSchema: Record<string, any>;
+    allParams: Record<string, any>;
+}
+interface DefaultAllRouteInfo {
+    routeConfig: RouteConfig;
+    routeInfo: RouteInfo;
+    routeInfoById: Record<string, RouteInfo>;
+    routeInfoByFullPath: Record<string, RouteInfo>;
+    routeIds: string;
+    routePaths: string;
+    fullSearchSchema: AnySearchSchema;
+    allParams: AnyPathParams;
+}
+interface AllRouteInfo<TRouteConfig extends AnyRouteConfig = RouteConfig> extends RoutesInfoInner<TRouteConfig, ParseRouteConfig<TRouteConfig>> {
+}
+type ParseRouteConfig<TRouteConfig = AnyRouteConfig> = TRouteConfig extends AnyRouteConfig ? RouteConfigRoute<TRouteConfig> | ParseRouteChildren<TRouteConfig> : never;
+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;
+type ParseRouteChild<TRouteConfig, TId> = TRouteConfig & {
+    id: TId;
+} extends AnyRouteConfig ? ParseRouteConfig<TRouteConfig> : never;
+type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<infer TId, infer TCustomId, infer TPath, infer TFullPath, infer TParentRouteLoaderData, infer TRouteLoaderData, infer TParentLoaderData, infer TLoaderData, infer TParentSearchSchema, infer TSearchSchema, infer TFullSearchSchema, infer TParentParams, infer TParams, infer TAllParams, any> ? string extends TCustomId ? never : RouteInfo<TId, TCustomId, TPath, TFullPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, 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> = RouteInfo, TRouteInfoById = {
+    '/': TRouteInfo;
+} & {
+    [TInfo in TRouteInfo as TInfo['id']]: TInfo;
+}, TRouteInfoByFullPath = {
+    '/': TRouteInfo;
+} & {
+    [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;
+    fullSearchSchema: Partial<UnionToIntersection<TRouteInfo['fullSearchSchema']>>;
+    allParams: Partial<UnionToIntersection<TRouteInfo['allParams']>>;
+}
+interface AnyRouteInfo extends RouteInfo<any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
+}
+interface RouteInfo<TId extends string = string, TCustomId extends string = string, TPath extends string = string, TFullPath extends string = '/', TParentRouteLoaderData extends AnyLoaderData = {}, TRouteLoaderData extends AnyLoaderData = {}, TParentLoaderData extends AnyLoaderData = {}, TLoaderData extends AnyLoaderData = {}, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}, TParams extends AnyPathParams = {}, TAllParams extends AnyPathParams = {}> {
+    id: TId;
+    customId: TCustomId;
+    path: TPath;
+    fullPath: TFullPath;
+    parentRouteLoaderData: TParentRouteLoaderData;
+    routeLoaderData: TRouteLoaderData;
+    parentLoaderData: TParentLoaderData;
+    loaderData: TLoaderData;
+    searchSchema: TSearchSchema;
+    fullSearchSchema: TFullSearchSchema;
+    parentParams: TParentParams;
+    params: TParams;
+    allParams: TAllParams;
+    options: RouteOptions<TCustomId, TPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams>;
+}
+type RoutesById<TAllRouteInfo extends AnyAllRouteInfo> = {
+    [K in keyof TAllRouteInfo['routeInfoById']]: Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][K]>;
+};
+type RouteInfoById<TAllRouteInfo extends AnyAllRouteInfo, TId> = TId extends keyof TAllRouteInfo['routeInfoById'] ? IsAny<TAllRouteInfo['routeInfoById'][TId]['id'], RouteInfo, TAllRouteInfo['routeInfoById'][TId]> : never;
+type RouteInfoByPath<TAllRouteInfo extends AnyAllRouteInfo, TPath> = TPath extends keyof TAllRouteInfo['routeInfoByFullPath'] ? IsAny<TAllRouteInfo['routeInfoByFullPath'][TPath]['id'], RouteInfo, TAllRouteInfo['routeInfoByFullPath'][TPath]> : never;
+
+type LinkInfo = {
     type: 'external';
     href: string;
 } | {
     type: 'internal';
-    next: Location;
+    next: ParsedLocation;
     handleFocus: (e: any) => void;
     handleClick: (e: any) => void;
     handleEnter: (e: any) => void;
@@ -511,12 +537,11 @@ declare type LinkInfo = {
     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> = Split<T>[number] extends infer U ? U extends `$${infer V}` ? V : never : never;
+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;
+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<[
@@ -526,40 +551,39 @@ 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<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends TAllRouteInfo['routePaths'] = '/', TTo extends string = '.'> = ToOptions<TAllRouteInfo, TFrom, TTo> & {
     replace?: boolean;
 };
-declare type ToOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.', TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
+type ToOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends TAllRouteInfo['routePaths'] = '/', TTo extends string = '.', TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>> = {
     to?: ToPathOption<TAllRouteInfo, 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>;
+type SearchParamOptions<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo, TFromSchema = Expand<UnionToIntersection<TAllRouteInfo['fullSearchSchema'] & RouteInfoByPath<TAllRouteInfo, TFrom> extends never ? {} : RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']>>, TToSchema = Partial<RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']> & Omit<RouteInfoByPath<TAllRouteInfo, TTo>['fullSearchSchema'], keyof PickRequired<RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema']>>, TFromFullSchema = Expand<UnionToIntersection<TAllRouteInfo['fullSearchSchema'] & TFromSchema>>, TToFullSchema = Expand<UnionToIntersection<TAllRouteInfo['fullSearchSchema'] & 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<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo, TFromSchema = Expand<UnionToIntersection<RouteInfoByPath<TAllRouteInfo, TFrom> extends never ? {} : RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']>>, TToSchema = Partial<RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']> & Omit<RouteInfoByPath<TAllRouteInfo, TTo>['allParams'], keyof PickRequired<RouteInfoByPath<TAllRouteInfo, TFrom>['allParams']>>, TFromFullParams = Expand<UnionToIntersection<TAllRouteInfo['allParams'] & TFromSchema>>, TToFullParams = Expand<UnionToIntersection<TAllRouteInfo['allParams'] & 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<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends TAllRouteInfo['routePaths'] = '/', TTo extends string = '.'> = TTo | RelativeToPathAutoComplete<TAllRouteInfo['routePaths'], NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
+type ToIdOption<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends TAllRouteInfo['routePaths'] = '/', TTo extends string = '.'> = TTo | RelativeToPathAutoComplete<TAllRouteInfo['routeIds'], NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>;
 interface ActiveOptions {
     exact?: boolean;
     includeHash?: boolean;
 }
-declare type LinkOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'> = NavigateOptionsAbsolute<TAllRouteInfo, TFrom, TTo> & {
+type LinkOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends TAllRouteInfo['routePaths'] = '/', TTo extends string = '.'> = NavigateOptions<TAllRouteInfo, TFrom, TTo> & {
     target?: HTMLAnchorElement['target'];
     activeOptions?: ActiveOptions;
     preload?: false | 'intent';
@@ -568,22 +592,22 @@ declare type LinkOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRoute
     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<TAllRouteInfo extends AnyAllRouteInfo, TFrom, TTo> = TTo extends string ? TFrom extends string ? ResolveRelativePath<TFrom, TTo> extends TAllRouteInfo['routePaths'] ? {} : {
     Error: `${TFrom} + ${TTo} resolves to ${ResolveRelativePath<TFrom, TTo>}, which is not a valid route path.`;
     'Valid Route Paths': TAllRouteInfo['routePaths'];
 } : {} : {};
-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<{
+type CheckPath<TAllRouteInfo extends AnyAllRouteInfo, TPath, TPass> = Exclude<TPath, TAllRouteInfo['routePaths']> extends never ? TPass : CheckPathError<TAllRouteInfo, Exclude<TPath, TAllRouteInfo['routePaths']>>;
+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 CheckId<TAllRouteInfo extends AnyAllRouteInfo, TPath, TPass> = Exclude<TPath, TAllRouteInfo['routeIds']> extends never ? TPass : CheckIdError<TAllRouteInfo, Exclude<TPath, TAllRouteInfo['routeIds']>>;
+type CheckIdError<TAllRouteInfo extends AnyAllRouteInfo, TInvalids> = Expand<{
     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']);
+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;
+type ValidFromPath<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo> = undefined | (string extends TAllRouteInfo['routePaths'] ? string : TAllRouteInfo['routePaths']);
 
 interface Segment {
     type: 'pathname' | 'param' | 'wildcard';
@@ -597,8 +621,8 @@ 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 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): {};
@@ -608,4 +632,48 @@ 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;
 
-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, cascadeLoaderData, cleanPath, createRoute, createRouteConfig, createRouteMatch, createRouter, decode, defaultParseSearch, defaultStringifySearch, encode, functionalUpdate, interpolatePath, joinPaths, last, matchByPath, matchPathname, parsePathname, parseSearchWith, replaceEqualDeep, resolvePath, rootRouteId, stringifySearchWith, trimPath, trimPathLeft, trimPathRight, warning };
+/**
+ * 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 immutable JSON values for example.
+ * Do not use this with signals
+ */
+declare function replaceEqualDeep<T>(prev: any, _next: T): T;
+declare function trackDeep<T>(obj: T): T;
+
+interface ActionOptions<TKey extends string = string, TPayload = unknown, TResponse = unknown, TError = Error> {
+    key?: TKey;
+    action: (payload: TPayload) => TResponse | Promise<TResponse>;
+    onLatestSuccess?: ActionCallback<TPayload, TResponse, TError>;
+    onEachSuccess?: ActionCallback<TPayload, TResponse, TError>;
+    onLatestError?: ActionCallback<TPayload, TResponse, TError>;
+    onEachError?: ActionCallback<TPayload, TResponse, TError>;
+    onLatestSettled?: ActionCallback<TPayload, TResponse, TError>;
+    onEachSettled?: ActionCallback<TPayload, TResponse, TError>;
+    maxSubmissions?: number;
+    debug?: boolean;
+}
+type ActionCallback<TPayload, TResponse, TError> = (submission: ActionSubmission<TPayload, TResponse, TError>) => void | Promise<void>;
+interface Action<TKey extends string = string, TPayload = unknown, TResponse = unknown, TError = Error> {
+    options: ActionOptions<TKey, TPayload, TResponse, TError>;
+    submit: (payload?: TPayload) => Promise<TResponse>;
+    reset: () => void;
+    store: Store<ActionStore<TPayload, TResponse, TError>>;
+}
+interface ActionStore<TPayload = unknown, TResponse = unknown, TError = Error> {
+    submissions: ActionSubmission<TPayload, TResponse, TError>[];
+}
+type ActionFn<TActionPayload = unknown, TActionResponse = unknown> = (submission: TActionPayload) => TActionResponse | Promise<TActionResponse>;
+interface ActionSubmission<TPayload = unknown, TResponse = unknown, TError = Error> {
+    submittedAt: number;
+    status: 'idle' | 'pending' | 'success' | 'error';
+    payload: TPayload;
+    response?: TResponse;
+    error?: TError;
+    isInvalid?: boolean;
+    invalidate: () => void;
+    getIsLatest: () => boolean;
+}
+declare function createAction<TKey extends string, TPayload, TResponse, TError>(options: ActionOptions<TKey, TPayload, TResponse, TError>): Action<TKey, TPayload, TResponse, TError>;
+
+export { Action, ActionFn, ActionOptions, ActionStore, ActionSubmission, ActiveOptions, AllRouteInfo, AnyAllRouteInfo, AnyLoaderData, AnyPathParams, AnyRoute, AnyRouteConfig, AnyRouteConfigWithChildren, AnyRouteInfo, AnyRouter, AnySearchSchema, BuildNextOptions, CheckId, CheckIdError, CheckPath, CheckPathError, CheckRelativePath, DeepAwaited, DefaultAllRouteInfo, DefinedPathParamWarning, DehydratedRouter, DehydratedRouterState, Expand, FilterRoutesFn, FrameworkGenerics, FromLocation, GetFrameworkGeneric, IsAny, IsAnyBoolean, IsKnown, LinkInfo, LinkOptions, ListenerFn, Loader, LoaderContext, LoaderFn, LoaderState, LocationState, MatchCache, MatchCacheEntry, MatchLocation, MatchRouteOptions, NavigateOptions, NoInfer, ParentParams, ParsePathParams, ParseRouteConfig, ParsedLocation, ParsedPath, PathParamMask, PathParamOptions, PickAsPartial, PickAsRequired, PickExclude, PickExtra, PickExtract, PickRequired, PickUnsafe, RegisterRouter, RegisteredAllRouteInfo, RegisteredRouter, RelativeToPathAutoComplete, ResolveRelativePath, RootRouteId, Route, RouteConfig, RouteConfigRoute, RouteInfo, RouteInfoById, RouteInfoByPath, RouteMatch, RouteMatchStore, RouteMeta, RouteOptions, Router, RouterContext, RouterHistory, RouterLocation, RouterOptions, RouterStore, RoutesById, RoutesInfoInner, SearchFilter, SearchParamOptions, SearchParser, SearchSchemaValidator, SearchSchemaValidatorFn, SearchSchemaValidatorObj, SearchSerializer, Segment, Split, Store, Timeout, ToIdOption, ToOptions, ToPathOption, UnionToIntersection, UnloaderFn, Updater, ValidFromPath, ValueKeys, Values, batch, cleanPath, createAction, createBrowserHistory, createHashHistory, createMemoryHistory, createRouteConfig, createStore, decode, defaultFetchServerDataFn, defaultParseSearch, defaultStringifySearch, encode, functionalUpdate, interpolatePath, joinPaths, last, matchByPath, matchPathname, parsePathname, parseSearchWith, pick, replaceEqualDeep, resolvePath, rootRouteId, stringifySearchWith, trackDeep, trimPath, trimPathLeft, trimPathRight, warning };