@tanstack/router-core 0.0.1-beta.41 → 0.0.1-beta.49

package/build/types/index.d.ts

@@ -8,15 +8,48 @@
  *
  * @license MIT
  */
-import { BrowserHistory, MemoryHistory, HashHistory } from 'history';
-export { createBrowserHistory, createHashHistory, createMemoryHistory } from 'history';
 export { default as invariant } from 'tiny-invariant';
-import { SetStoreFunction } from '@solidjs/reactivity';
+
+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 {
 }
 type GetFrameworkGeneric<U> = U extends keyof FrameworkGenerics ? FrameworkGenerics[U] : any;
 
+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;
@@ -55,6 +88,7 @@ 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;
@@ -63,7 +97,7 @@ type RegisteredAllRouteInfo = RegisterRouter extends {
 } ? 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;
@@ -82,7 +116,7 @@ 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?: BrowserHistory | MemoryHistory | HashHistory;
+    history?: RouterHistory;
     stringifySearch?: SearchSerializer;
     parseSearch?: SearchParser;
     filterRoutes?: FilterRoutesFn;
@@ -99,31 +133,20 @@ interface RouterOptions<TRouteConfig extends AnyRouteConfig, TRouterContext> {
     routeConfig?: TRouteConfig;
     basepath?: string;
     useServerData?: boolean;
-    createRouter?: (router: Router<any, any, any>) => void;
+    createRouter?: (router: AnyRouter) => void;
     createRoute?: (opts: {
         route: AnyRoute;
-        router: Router<any, any, any>;
+        router: AnyRouter;
     }) => void;
     context?: TRouterContext;
     loadComponent?: (component: GetFrameworkGeneric<'Component'>) => Promise<GetFrameworkGeneric<'Component'>>;
+    onRouteChange?: () => void;
+    fetchServerDataFn?: FetchServerDataFn;
 }
-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;
-}
+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;
@@ -149,13 +172,12 @@ interface LoaderState<TFullSearchSchema extends AnySearchSchema = {}, TAllParams
 }
 interface RouterStore<TSearchObj extends AnySearchSchema = {}, TState extends LocationState = LocationState> {
     status: 'idle' | 'loading';
-    latestLocation: Location<TSearchObj, TState>;
+    latestLocation: ParsedLocation<TSearchObj, TState>;
     currentMatches: RouteMatch[];
-    currentLocation: Location<TSearchObj, TState>;
+    currentLocation: ParsedLocation<TSearchObj, TState>;
     pendingMatches?: RouteMatch[];
-    pendingLocation?: Location<TSearchObj, TState>;
+    pendingLocation?: ParsedLocation<TSearchObj, TState>;
     lastUpdated: number;
-    actions: Record<string, Action>;
     loaders: Record<string, Loader>;
     isFetching: boolean;
     isPreloading: boolean;
@@ -194,44 +216,51 @@ interface DehydratedRouterState extends Pick<RouterStore, 'status' | 'latestLoca
     currentMatches: DehydratedRouteMatch[];
 }
 interface DehydratedRouter<TRouterContext = unknown> {
-    store: DehydratedRouterState;
+    state: DehydratedRouterState;
     context: TRouterContext;
 }
 type MatchCache = Record<string, MatchCacheEntry>;
 interface DehydratedRouteMatch {
     matchId: string;
-    store: Pick<RouteMatchStore<any, any>, 'status' | 'routeLoaderData' | 'isInvalid' | 'invalidAt'>;
+    state: Pick<RouteMatchStore<any, any>, 'status' | 'routeLoaderData' | 'invalid' | 'invalidAt'>;
 }
 interface RouterContext {
 }
-interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>, TRouterContext = unknown> {
+declare const defaultFetchServerDataFn: FetchServerDataFn;
+declare class Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>, TRouterContext = unknown> {
+    #private;
     types: {
         RouteConfig: TRouteConfig;
         AllRouteInfo: TAllRouteInfo;
     };
-    history: BrowserHistory | MemoryHistory | HashHistory;
     options: PickAsRequired<RouterOptions<TRouteConfig, TRouterContext>, 'stringifySearch' | 'parseSearch' | 'context'>;
-    store: RouterStore<TAllRouteInfo['fullSearchSchema']>;
-    setStore: SetStoreFunction<RouterStore<TAllRouteInfo['fullSearchSchema']>>;
+    history: RouterHistory;
     basepath: string;
     routeTree: Route<TAllRouteInfo, RouteInfo>;
     routesById: RoutesById<TAllRouteInfo>;
+    navigateTimeout: undefined | Timeout;
+    nextAction: undefined | 'push' | 'replace';
+    navigationPromise: undefined | Promise<void>;
+    store: Store<RouterStore<TAllRouteInfo['fullSearchSchema']>>;
+    startedLoadingAt: number;
+    resolveNavigation: () => void;
+    constructor(options?: RouterOptions<TRouteConfig, TRouterContext>);
     reset: () => void;
     mount: () => () => void;
-    update: <TRouteConfig extends RouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>, TRouterContext = unknown>(opts?: RouterOptions<TRouteConfig, TRouterContext>) => Router<TRouteConfig, TAllRouteInfo, TRouterContext>;
-    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;
-    load: (next?: Location) => Promise<void>;
+    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?: {
         preload: true;
         maxAge: number;
@@ -242,37 +271,55 @@ interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInf
         gcMaxAge?: never;
     }) => Promise<void>;
     loadMatchData: (routeMatch: RouteMatch<any, any>) => Promise<Record<string, unknown>>;
-    invalidateRoute: (opts: MatchLocation) => void;
-    reload: () => Promise<void>;
+    invalidateRoute: (opts: MatchLocation) => Promise<void>;
+    reload: () => void;
     resolvePath: (from: string, path: string) => string;
-    navigate: <TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'>(opts: NavigateOptions<TAllRouteInfo, TFrom, TTo>) => Promise<void>;
-    matchRoute: <TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'>(matchLocation: ToOptions<TAllRouteInfo, TFrom, TTo>, opts?: MatchRouteOptions) => false | TAllRouteInfo['routeInfoById'][ResolveRelativePath<TFrom, NoInfer<TTo>>]['allParams'];
-    buildLink: <TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'>(opts: LinkOptions<TAllRouteInfo, TFrom, TTo>) => LinkInfo;
+    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>, TRouterContext = unknown>(userOptions?: RouterOptions<TRouteConfig, TRouterContext>): Router<TRouteConfig, TAllRouteInfo, TRouterContext>;
 
 interface RouteMatchStore<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> {
-    parentMatch?: RouteMatch;
     routeSearch: TRouteInfo['searchSchema'];
     search: Expand<TAllRouteInfo['fullSearchSchema'] & TRouteInfo['fullSearchSchema']>;
     status: 'idle' | 'loading' | 'success' | 'error';
     updatedAt?: number;
     error?: unknown;
     invalid: boolean;
-    isInvalid: boolean;
     loaderData: TRouteInfo['loaderData'];
     routeLoaderData: TRouteInfo['routeLoaderData'];
     isFetching: boolean;
     invalidAt: number;
 }
-interface RouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> extends Route<TAllRouteInfo, TRouteInfo> {
-    store: RouteMatchStore<TAllRouteInfo, TRouteInfo>;
-    matchId: string;
+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'];
-    childMatches: RouteMatch[];
+    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?: {
         preload: true;
@@ -282,32 +329,17 @@ 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;
-    __: {
-        setParentMatch: (parentMatch?: RouteMatch) => void;
-        component?: GetFrameworkGeneric<'Component'>;
-        errorComponent?: GetFrameworkGeneric<'ErrorComponent'>;
-        pendingComponent?: GetFrameworkGeneric<'Component'>;
-        loadPromise?: Promise<void>;
-        onExit?: void | ((matchContext: {
-            params: TRouteInfo['allParams'];
-            search: TRouteInfo['fullSearchSchema'];
-        }) => void);
-        abortController: AbortController;
-        validate: () => void;
-    };
+    invalidate: () => Promise<void>;
+    __hasLoaders: () => boolean;
+    getIsInvalid: () => boolean;
+    __setParentMatch: (parentMatch?: RouteMatch) => void;
+    __onLoaderData: (listener: () => void) => void;
+    __validate: () => void;
 }
-declare function createRouteMatch<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo>(router: Router<any, any, any>, route: Route<TAllRouteInfo, TRouteInfo>, opts: {
-    parentMatch?: RouteMatch<any, any>;
-    matchId: string;
-    params: TRouteInfo['allParams'];
-    pathname: string;
-}): RouteMatch<TAllRouteInfo, TRouteInfo>;
 
 declare const rootRouteId: "__root__";
 type RootRouteId = typeof rootRouteId;
@@ -334,9 +366,8 @@ interface LoaderContext<TFullSearchSchema extends AnySearchSchema = {}, TAllPara
     search: TFullSearchSchema;
     signal?: AbortSignal;
 }
-type ActionFn<TActionPayload = unknown, TActionResponse = unknown> = (submission: TActionPayload) => TActionResponse | Promise<TActionResponse>;
 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 = {}, 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 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;
@@ -351,9 +382,8 @@ type RouteOptions<TRouteId extends string = string, TPath extends string = strin
     loader?: LoaderFn<TRouteLoaderData, TFullSearchSchema, TAllParams>;
     loaderMaxAge?: number;
     loaderGcMaxAge?: number;
-    action?: ActionFn<TActionPayload, TActionResponse>;
     beforeLoad?: (opts: {
-        router: Router<any, any, unknown>;
+        router: AnyRouter;
         match: RouteMatch;
     }) => Promise<void> | void;
     onLoadError?: (err: any) => void;
@@ -377,29 +407,29 @@ type RouteOptions<TRouteId extends string = string, TPath extends string = strin
     stringifyParams: (params: TParams) => Record<ParsePathParams<TPath>, string>;
 }) & (PickUnsafe<TParentParams, ParsePathParams<TPath>> extends never ? {} : 'Cannot redefined path params in child routes!');
 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, TActionPayload = unknown, TActionResponse = unknown, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}, TParams extends AnyPathParams = {}, TAllParams extends AnyPathParams = {}, TKnownChildren = unknown> {
+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, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, 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, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, TAllParams, TNewChildren>>;
+    }) => 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>;
 }
-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, TActionPayload = unknown, TActionResponse = unknown, 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>>, TActionPayload, TActionResponse, 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, 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, TParentLoaderData, Expand<TParentLoaderData & 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, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, Expand<TParentLoaderData & 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, TParentLoaderData, Expand<TParentLoaderData & NoInfer<TRouteLoaderData>>, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, Expand<TParentSearchSchema & TSearchSchema>, TParentParams, TParams, Expand<TParentParams & TAllParams>, TKnownChildren>;
+} : 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, any, any> {
+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, any, any, TChildren> {
+interface AnyRouteConfigWithChildren<TChildren> extends RouteConfig<any, any, any, any, any, any, any, any, any, any, any, any, any, any, TChildren> {
 }
 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;
@@ -408,21 +438,19 @@ declare const createRouteConfig: CreateRouteConfigFn<true>;
 
 interface AnyRoute extends Route<any, any, any> {
 }
-interface Route<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo, TRouterContext = unknown> {
+declare class Route<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo, TRouterContext = unknown> {
     routeInfo: TRouteInfo;
-    routeId: TRouteInfo['id'];
-    routeRouteId: TRouteInfo['routeId'];
-    routePath: TRouteInfo['path'];
+    id: TRouteInfo['id'];
+    customId: TRouteInfo['customId'];
+    path: TRouteInfo['path'];
     fullPath: TRouteInfo['fullPath'];
-    parentRoute?: AnyRoute;
+    getParentRoute: () => undefined | AnyRoute;
     childRoutes?: AnyRoute[];
     options: RouteOptions;
     originalIndex: number;
-    router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>;
-    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']>;
+    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>);
 }
-declare function createRoute<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo, TRouterContext = unknown>(routeConfig: RouteConfig, options: TRouteInfo['options'], originalIndex: number, parent: undefined | Route<TAllRouteInfo, any>, router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo, TRouterContext>): Route<TAllRouteInfo, TRouteInfo, TRouterContext>;
 
 interface AnyAllRouteInfo {
     routeConfig: AnyRouteConfig;
@@ -453,8 +481,8 @@ type ParseRouteChildren<TRouteConfig> = TRouteConfig extends AnyRouteConfigWithC
 type ParseRouteChild<TRouteConfig, TId> = TRouteConfig & {
     id: TId;
 } extends AnyRouteConfig ? ParseRouteConfig<TRouteConfig> : never;
-type RouteConfigRoute<TRouteConfig> = TRouteConfig extends RouteConfig<infer TId, infer TRouteId, infer TPath, infer TFullPath, infer TParentRouteLoaderData, infer TRouteLoaderData, infer TParentLoaderData, 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, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, 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, any> = RouteInfo, TRouteInfoById = {
+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;
@@ -472,25 +500,23 @@ interface RoutesInfoInner<TRouteConfig extends AnyRouteConfig, TRouteInfo extend
     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, any, any> {
+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 = '/', TParentRouteLoaderData extends AnyLoaderData = {}, TRouteLoaderData extends AnyLoaderData = {}, TParentLoaderData extends AnyLoaderData = {}, TLoaderData extends AnyLoaderData = {}, TActionPayload = unknown, TActionResponse = unknown, TParentSearchSchema extends {} = {}, TSearchSchema extends AnySearchSchema = {}, TFullSearchSchema extends AnySearchSchema = {}, TParentParams extends AnyPathParams = {}, TParams extends AnyPathParams = {}, TAllParams extends AnyPathParams = {}> {
+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;
-    routeId: TRouteId;
+    customId: TCustomId;
     path: TPath;
     fullPath: TFullPath;
     parentRouteLoaderData: TParentRouteLoaderData;
     routeLoaderData: TRouteLoaderData;
     parentLoaderData: TParentLoaderData;
     loaderData: TLoaderData;
-    actionPayload: TActionPayload;
-    actionResponse: TActionResponse;
     searchSchema: TSearchSchema;
     fullSearchSchema: TFullSearchSchema;
     parentParams: TParentParams;
     params: TParams;
     allParams: TAllParams;
-    options: RouteOptions<TRouteId, TPath, TParentRouteLoaderData, TRouteLoaderData, TParentLoaderData, TLoaderData, TActionPayload, TActionResponse, TParentSearchSchema, TSearchSchema, TFullSearchSchema, TParentParams, TParams, 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]>;
@@ -503,7 +529,7 @@ type LinkInfo = {
     href: string;
 } | {
     type: 'internal';
-    next: Location;
+    next: ParsedLocation;
     handleFocus: (e: any) => void;
     handleClick: (e: any) => void;
     handleEnter: (e: any) => void;
@@ -609,8 +635,45 @@ declare function stringifySearchWith(stringify: (search: any) => string): (searc
 /**
  * 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 sharedClone<T>(prev: any, next: T, touchAll?: boolean): T;
+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, ActionState, ActiveOptions, AllRouteInfo, AnyAllRouteInfo, AnyLoaderData, AnyPathParams, AnyRoute, AnyRouteConfig, AnyRouteConfigWithChildren, AnyRouteInfo, 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, Location, LocationState, MatchCache, MatchCacheEntry, MatchLocation, MatchRouteOptions, NavigateOptions, NoInfer, ParentParams, ParsePathParams, ParseRouteConfig, 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, RouterOptions, RouterStore, RoutesById, RoutesInfoInner, SearchFilter, SearchParamOptions, SearchParser, SearchSchemaValidator, SearchSchemaValidatorFn, SearchSchemaValidatorObj, SearchSerializer, Segment, Split, Timeout, ToIdOption, ToOptions, ToPathOption, UnionToIntersection, UnloaderFn, Updater, ValidFromPath, ValueKeys, Values, cleanPath, createRoute, createRouteConfig, createRouteMatch, createRouter, decode, defaultParseSearch, defaultStringifySearch, encode, functionalUpdate, interpolatePath, joinPaths, last, matchByPath, matchPathname, parsePathname, parseSearchWith, pick, resolvePath, rootRouteId, sharedClone, stringifySearchWith, trimPath, trimPathLeft, trimPathRight, warning };
+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 };