@tanstack/react-router 0.0.1-beta.16 → 0.0.1-beta.160

package/build/stats-react.json

@@ -7,19 +7,40 @@
         "name": "index.production.js",
         "children": [
           {
-            "uid": "36b9-68",
+            "uid": "284f-167",
             "name": "\u0000rollupPluginBabelHelpers.js"
           },
           {
             "name": "packages",
             "children": [
+              {
+                "name": "store/build/esm/index.js",
+                "uid": "284f-169"
+              },
+              {
+                "name": "react-store/build/esm/index.js",
+                "uid": "284f-171"
+              },
               {
                 "name": "router-core/build/esm/index.js",
-                "uid": "36b9-70"
+                "uid": "284f-177"
               },
               {
                 "name": "react-router/src/index.tsx",
-                "uid": "36b9-72"
+                "uid": "284f-179"
+              }
+            ]
+          },
+          {
+            "name": "node_modules/.pnpm",
+            "children": [
+              {
+                "name": "tiny-invariant@1.3.1/node_modules/tiny-invariant/dist/esm/tiny-invariant.js",
+                "uid": "284f-173"
+              },
+              {
+                "name": "tiny-warning@1.0.3/node_modules/tiny-warning/dist/tiny-warning.esm.js",
+                "uid": "284f-175"
               }
             ]
           }
@@ -29,111 +50,201 @@
     "isRoot": true
   },
   "nodeParts": {
-    "36b9-68": {
-      "renderedLength": 798,
-      "gzipLength": 366,
+    "284f-167": {
+      "renderedLength": 429,
+      "gzipLength": 238,
+      "brotliLength": 0,
+      "mainUid": "284f-166"
+    },
+    "284f-169": {
+      "renderedLength": 1843,
+      "gzipLength": 644,
+      "brotliLength": 0,
+      "mainUid": "284f-168"
+    },
+    "284f-171": {
+      "renderedLength": 1006,
+      "gzipLength": 479,
       "brotliLength": 0,
-      "mainUid": "36b9-67"
+      "mainUid": "284f-170"
     },
-    "36b9-70": {
-      "renderedLength": 74402,
-      "gzipLength": 15504,
+    "284f-173": {
+      "renderedLength": 181,
+      "gzipLength": 129,
       "brotliLength": 0,
-      "mainUid": "36b9-69"
+      "mainUid": "284f-172"
     },
-    "36b9-72": {
-      "renderedLength": 11304,
-      "gzipLength": 2961,
+    "284f-175": {
+      "renderedLength": 44,
+      "gzipLength": 62,
       "brotliLength": 0,
-      "mainUid": "36b9-71"
+      "mainUid": "284f-174"
+    },
+    "284f-177": {
+      "renderedLength": 56742,
+      "gzipLength": 13356,
+      "brotliLength": 0,
+      "mainUid": "284f-176"
+    },
+    "284f-179": {
+      "renderedLength": 17095,
+      "gzipLength": 3814,
+      "brotliLength": 0,
+      "mainUid": "284f-178"
     }
   },
   "nodeMetas": {
-    "36b9-67": {
+    "284f-166": {
       "id": "\u0000rollupPluginBabelHelpers.js",
       "moduleParts": {
-        "index.production.js": "36b9-68"
+        "index.production.js": "284f-167"
       },
       "imported": [],
       "importedBy": [
         {
-          "uid": "36b9-71"
+          "uid": "284f-178"
         }
       ]
     },
-    "36b9-69": {
-      "id": "/packages/router-core/build/esm/index.js",
+    "284f-168": {
+      "id": "/packages/store/build/esm/index.js",
       "moduleParts": {
-        "index.production.js": "36b9-70"
+        "index.production.js": "284f-169"
       },
       "imported": [],
       "importedBy": [
         {
-          "uid": "36b9-71"
+          "uid": "284f-170"
         }
       ]
     },
-    "36b9-71": {
-      "id": "/packages/react-router/src/index.tsx",
+    "284f-170": {
+      "id": "/packages/react-store/build/esm/index.js",
       "moduleParts": {
-        "index.production.js": "36b9-72"
+        "index.production.js": "284f-171"
       },
       "imported": [
         {
-          "uid": "36b9-67"
+          "uid": "284f-181"
         },
         {
-          "uid": "36b9-73"
-        },
+          "uid": "284f-168"
+        }
+      ],
+      "importedBy": [
         {
-          "uid": "36b9-74"
+          "uid": "284f-178"
         },
         {
-          "uid": "36b9-69"
+          "uid": "284f-176"
+        }
+      ]
+    },
+    "284f-172": {
+      "id": "/node_modules/.pnpm/tiny-invariant@1.3.1/node_modules/tiny-invariant/dist/esm/tiny-invariant.js",
+      "moduleParts": {
+        "index.production.js": "284f-173"
+      },
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "284f-178"
         },
         {
-          "uid": "36b9-75"
+          "uid": "284f-176"
         }
-      ],
-      "importedBy": [],
-      "isEntry": true
+      ]
     },
-    "36b9-73": {
-      "id": "react",
-      "moduleParts": {},
+    "284f-174": {
+      "id": "/node_modules/.pnpm/tiny-warning@1.0.3/node_modules/tiny-warning/dist/tiny-warning.esm.js",
+      "moduleParts": {
+        "index.production.js": "284f-175"
+      },
       "imported": [],
       "importedBy": [
         {
-          "uid": "36b9-71"
+          "uid": "284f-178"
+        },
+        {
+          "uid": "284f-176"
+        }
+      ]
+    },
+    "284f-176": {
+      "id": "/packages/router-core/build/esm/index.js",
+      "moduleParts": {
+        "index.production.js": "284f-177"
+      },
+      "imported": [
+        {
+          "uid": "284f-172"
+        },
+        {
+          "uid": "284f-174"
+        },
+        {
+          "uid": "284f-170"
         }
       ],
-      "isExternal": true
+      "importedBy": [
+        {
+          "uid": "284f-178"
+        }
+      ]
     },
-    "36b9-74": {
-      "id": "use-sync-external-store/shim",
+    "284f-178": {
+      "id": "/packages/react-router/src/index.tsx",
+      "moduleParts": {
+        "index.production.js": "284f-179"
+      },
+      "imported": [
+        {
+          "uid": "284f-166"
+        },
+        {
+          "uid": "284f-180"
+        },
+        {
+          "uid": "284f-170"
+        },
+        {
+          "uid": "284f-172"
+        },
+        {
+          "uid": "284f-174"
+        },
+        {
+          "uid": "284f-176"
+        }
+      ],
+      "importedBy": [],
+      "isEntry": true
+    },
+    "284f-180": {
+      "id": "react",
       "moduleParts": {},
       "imported": [],
       "importedBy": [
         {
-          "uid": "36b9-71"
+          "uid": "284f-178"
         }
       ],
       "isExternal": true
     },
-    "36b9-75": {
-      "id": "react-lazy-with-preload/lib/index",
+    "284f-181": {
+      "id": "use-sync-external-store/shim/with-selector",
       "moduleParts": {},
       "imported": [],
       "importedBy": [
         {
-          "uid": "36b9-71"
+          "uid": "284f-170"
         }
       ],
       "isExternal": true
     }
   },
   "env": {
-    "rollup": "2.77.2"
+    "rollup": "2.79.1"
   },
   "options": {
     "gzip": true,

package/build/types/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * react-router
+ * @tanstack/react-router/src/index.tsx
  *
  * Copyright (c) TanStack
  *
@@ -8,80 +8,146 @@
  *
  * @license MIT
  */
-import * as React from 'react';
-import { AnyRouteConfig, RouteConfig, AnyAllRouteInfo, AllRouteInfo, RouterState, RouteMatch, ToOptions, MatchRouteOptions, RouteInfoByPath, ResolveRelativePath, NoInfer, DefaultAllRouteInfo, AnyRouteInfo, RouteInfo, CheckId, ToIdOption, ValidFromPath, LinkOptions, RouterOptions, Router } from '@tanstack/router-core';
+import * as _tanstack_router_core from '@tanstack/router-core';
+import { RouteConstraints, AnyRoute, ResolveFullPath, ResolveId, ResolveFullSearchSchema, ParsePathParams, MergeParamsFromParent, RouteContext, AnyContext, UseLoaderResult, AnyRouteProps, RoutePaths, RegisteredRouter, LinkOptions, ToOptions, MatchRouteOptions, RouteByPath, ResolveRelativePath, NavigateOptions, RouterOptions, Router, RouteMatch, RouteIds, RouteById, ParseRoute, RoutesById, AllParams } from '@tanstack/router-core';
 export * from '@tanstack/router-core';
-export { lazyWithPreload as lazy } from 'react-lazy-with-preload/lib/index';
-export { PreloadableComponent as LazyComponent } from 'react-lazy-with-preload';
+import * as React from 'react';
+import { NoInfer } from '@tanstack/react-store';
+export { useStore } from '@tanstack/react-store';
 
-declare type SyncRouteComponent = (props?: {}) => React.ReactNode;
-declare type RouteComponent = SyncRouteComponent & {
-    preload?: () => Promise<{
-        default: SyncRouteComponent;
-    }>;
-};
 declare module '@tanstack/router-core' {
-    interface FrameworkGenerics {
-        Component: RouteComponent;
+    interface RegisterRouteComponent<TProps extends Record<string, any>> {
+        RouteComponent: RouteComponent<TProps>;
     }
-    interface Router<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = AllRouteInfo<TRouteConfig>> {
-        useState: () => RouterState;
-        useRoute: <TId extends keyof TAllRouteInfo['routeInfoById']>(routeId: TId) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]>;
-        useMatch: <TId extends keyof TAllRouteInfo['routeInfoById'], TStrict extends true | false = true>(routeId: TId, opts?: {
-            strict?: TStrict;
-        }) => TStrict extends true ? RouteMatch<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]> : RouteMatch<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TId]> | undefined;
-        linkProps: <TTo extends string = '.'>(props: LinkPropsOptions<TAllRouteInfo, '/', TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>) => React.AnchorHTMLAttributes<HTMLAnchorElement>;
-        Link: <TTo extends string = '.'>(props: LinkPropsOptions<TAllRouteInfo, '/', TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement> & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
-            children?: React.ReactNode | ((state: {
-                isActive: boolean;
-            }) => React.ReactNode);
-        }) => JSX.Element;
-        MatchRoute: <TTo extends string = '.'>(props: ToOptions<TAllRouteInfo, '/', TTo> & MatchRouteOptions & {
-            children?: React.ReactNode | ((params: RouteInfoByPath<TAllRouteInfo, ResolveRelativePath<'/', NoInfer<TTo>>>['allParams']) => React.ReactNode);
-        }) => JSX.Element;
+    interface RegisterRouteErrorComponent<TProps extends Record<string, any>> {
+        RouteErrorComponent: RouteComponent<TProps>;
     }
-    interface Route<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TRouteInfo extends AnyRouteInfo = RouteInfo> {
-        useRoute: <TTo extends string = '.', TResolved extends string = ResolveRelativePath<TRouteInfo['id'], NoInfer<TTo>>>(routeId: CheckId<TAllRouteInfo, TResolved, ToIdOption<TAllRouteInfo, TRouteInfo['id'], TTo>>, opts?: {
-            strict?: boolean;
-        }) => Route<TAllRouteInfo, TAllRouteInfo['routeInfoById'][TResolved]>;
-        linkProps: <TTo extends string = '.'>(props: LinkPropsOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>) => React.AnchorHTMLAttributes<HTMLAnchorElement>;
-        Link: <TTo extends string = '.'>(props: LinkPropsOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement> & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
-            children?: React.ReactNode | ((state: {
-                isActive: boolean;
-            }) => React.ReactNode);
-        }) => JSX.Element;
-        MatchRoute: <TTo extends string = '.'>(props: ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo> & MatchRouteOptions & {
-            children?: React.ReactNode | ((params: RouteInfoByPath<TAllRouteInfo, ResolveRelativePath<TRouteInfo['fullPath'], NoInfer<TTo>>>['allParams']) => React.ReactNode);
-        }) => JSX.Element;
+    interface Route<TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, TPath extends RouteConstraints['TPath'] = '/', TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints['TCustomId'] = string, TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, TLoader = unknown, TSearchSchema extends RouteConstraints['TSearchSchema'] = {}, TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends RouteConstraints['TParams'] = Record<ParsePathParams<TPath>, string>, TAllParams extends RouteConstraints['TAllParams'] = MergeParamsFromParent<TParentRoute['__types']['allParams'], TParams>, TParentContext extends RouteConstraints['TParentContext'] = TParentRoute['__types']['routeContext'], TAllParentContext extends RouteConstraints['TAllParentContext'] = TParentRoute['__types']['context'], TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends RouteConstraints['TAllContext'] = MergeParamsFromParent<TParentRoute['__types']['context'], TRouteContext>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
+        useMatch: <TStrict extends boolean = true, TSelected = TAllContext>(opts?: {
+            strict?: TStrict;
+            select?: (search: TAllContext) => TSelected;
+        }) => TStrict extends true ? TSelected : TSelected | undefined;
+        useLoader: <TStrict extends boolean = true, TSelected = TLoader>(opts?: {
+            strict?: TStrict;
+            select?: (search: TLoader) => TSelected;
+        }) => TStrict extends true ? UseLoaderResult<TSelected> : UseLoaderResult<TSelected> | undefined;
+        useContext: <TStrict extends boolean = true, TSelected = TAllContext>(opts?: {
+            strict?: TStrict;
+            select?: (search: TAllContext) => TSelected;
+        }) => TStrict extends true ? TSelected : TSelected | undefined;
+        useRouteContext: <TStrict extends boolean = true, TSelected = TRouteContext>(opts?: {
+            strict?: TStrict;
+            select?: (search: TRouteContext) => TSelected;
+        }) => TStrict extends true ? TSelected : TSelected | undefined;
+        useSearch: <TStrict extends boolean = true, TSelected = TFullSearchSchema>(opts?: {
+            strict?: TStrict;
+            select?: (search: TFullSearchSchema) => TSelected;
+        }) => TStrict extends true ? TSelected : TSelected | undefined;
+        useParams: <TStrict extends boolean = true, TSelected = TAllParams>(opts?: {
+            strict?: TStrict;
+            select?: (search: TAllParams) => TSelected;
+        }) => TStrict extends true ? TSelected : TSelected | undefined;
     }
 }
-declare type LinkPropsOptions<TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo, TFrom extends ValidFromPath<TAllRouteInfo> = '/', TTo extends string = '.'> = LinkOptions<TAllRouteInfo, TFrom, TTo> & {
+type ReactNode = any;
+type SyncRouteComponent<TProps> = ((props: TProps) => ReactNode) | React.LazyExoticComponent<(props: TProps) => ReactNode>;
+type AsyncRouteComponent<TProps> = SyncRouteComponent<TProps> & {
+    preload?: () => Promise<void>;
+};
+type RouteErrorComponent = AsyncRouteComponent<RouteErrorComponentProps>;
+type RouteErrorComponentProps = {
+    error: Error;
+    info: {
+        componentStack: string;
+    };
+};
+type AnyRouteComponent = RouteComponent<AnyRouteProps>;
+type RouteComponent<TProps> = AsyncRouteComponent<TProps>;
+declare function lazyRouteComponent<T extends Record<string, any>, TKey extends keyof T = 'default'>(importer: () => Promise<T>, exportName?: TKey): T[TKey] extends (props: infer TProps) => any ? AsyncRouteComponent<TProps> : never;
+type LinkPropsOptions<TFrom extends RoutePaths<RegisteredRouter['routeTree']> = '/', TTo extends string = ''> = LinkOptions<RegisteredRouter['routeTree'], TFrom, TTo> & {
     activeProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
     inactiveProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
+    startTransition?: boolean;
 };
-declare type PromptProps = {
-    message: string;
-    when?: boolean | any;
-    children?: React.ReactNode;
+type MakeUseMatchRouteOptions<TFrom extends RoutePaths<RegisteredRouter['routeTree']> = '/', TTo extends string = ''> = ToOptions<RegisteredRouter['routeTree'], TFrom, TTo> & MatchRouteOptions;
+type MakeMatchRouteOptions<TFrom extends RoutePaths<RegisteredRouter['routeTree']> = '/', TTo extends string = ''> = ToOptions<RegisteredRouter['routeTree'], TFrom, TTo> & MatchRouteOptions & {
+    children?: ((params?: RouteByPath<RegisteredRouter['routeTree'], ResolveRelativePath<TFrom, NoInfer<TTo>>>['__types']['allParams']) => ReactNode) | React.ReactNode;
+};
+type MakeLinkPropsOptions<TFrom extends string = '/', TTo extends string = ''> = LinkPropsOptions<TFrom, TTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+type MakeLinkOptions<TFrom extends RoutePaths<RegisteredRouter['routeTree']> = '/', TTo extends string = ''> = LinkPropsOptions<TFrom, TTo> & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
+    children?: React.ReactNode | ((state: {
+        isActive: boolean;
+    }) => React.ReactNode);
 };
-declare type MatchesProviderProps = {
-    value: RouteMatch[];
-    children: React.ReactNode;
+type PromptProps = {
+    message: string;
+    condition?: boolean | any;
+    children?: ReactNode;
 };
-declare function MatchesProvider(props: MatchesProviderProps): JSX.Element;
-declare function createReactRouter<TRouteConfig extends AnyRouteConfig = RouteConfig>(opts: RouterOptions<TRouteConfig>): Router<TRouteConfig>;
-declare type RouterProps<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo> = RouterOptions<TRouteConfig> & {
-    router: Router<TRouteConfig, TAllRouteInfo>;
-    children?: React.ReactNode;
+declare function useLinkProps<TFrom extends string = '/', TTo extends string = ''>(options: MakeLinkPropsOptions<TFrom, TTo>): React.AnchorHTMLAttributes<HTMLAnchorElement>;
+interface LinkComponent<TProps extends Record<string, any> = {}> {
+    <TFrom extends RoutePaths<RegisteredRouter['routeTree']> = '/', TTo extends string = ''>(props: MakeLinkOptions<TFrom, TTo> & TProps & React.RefAttributes<HTMLAnchorElement>): ReactNode;
+}
+declare const Link: LinkComponent;
+declare function Navigate<TFrom extends RoutePaths<RegisteredRouter['routeTree']> = '/', TTo extends string = ''>(props: NavigateOptions<RegisteredRouter['routeTree'], TFrom, TTo>): null;
+declare const matchIdsContext: React.Context<string[]>;
+declare const routerContext: React.Context<_tanstack_router_core.AnyRouter>;
+type RouterProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>> = Omit<RouterOptions<TRouteTree, TDehydrated>, 'context'> & {
+    router: Router<TRouteTree>;
+    context?: Partial<RouterOptions<TRouteTree, TDehydrated>['context']>;
 };
-declare function RouterProvider<TRouteConfig extends AnyRouteConfig = RouteConfig, TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo>({ children, router, ...rest }: RouterProps<TRouteConfig, TAllRouteInfo>): JSX.Element;
-declare function useRouter(): Router;
-declare function useMatches(): RouteMatch[];
+declare function useRouterState<TSelected = RegisteredRouter['state']>(opts?: {
+    select: (state: RegisteredRouter['state']) => TSelected;
+}): TSelected;
+declare function RouterProvider<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>>({ router, ...rest }: RouterProps<TRouteTree, TDehydrated>): JSX.Element;
+declare function useRouter(): RegisteredRouter;
+declare function useMatches<T = RouteMatch[]>(opts?: {
+    select?: (matches: RouteMatch[]) => T;
+}): T;
+declare function useMatch<TFrom extends RouteIds<RegisteredRouter['routeTree']>, TStrict extends boolean = true, TRouteMatchState = RouteMatch<RegisteredRouter['routeTree'], RouteById<RegisteredRouter['routeTree'], TFrom>>, TSelected = TRouteMatchState>(opts?: {
+    from: TFrom;
+    strict?: TStrict;
+    select?: (match: TRouteMatchState) => TSelected;
+}): TStrict extends true ? TRouteMatchState : TRouteMatchState | undefined;
+type RouteFromIdOrRoute<T> = T extends ParseRoute<RegisteredRouter['routeTree']> ? T : T extends RouteIds<RegisteredRouter['routeTree']> ? RoutesById<RegisteredRouter['routeTree']>[T] : T extends string ? RouteIds<RegisteredRouter['routeTree']> : never;
+declare function useLoader<TFrom extends RouteIds<RegisteredRouter['routeTree']>, TStrict extends boolean = true, TLoader = RouteById<RegisteredRouter['routeTree'], TFrom>['__types']['loader'], TSelected = TLoader>(opts?: {
+    from: TFrom;
+    strict?: TStrict;
+    select?: (search: TLoader) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+declare function useRouterContext<TFrom extends RouteIds<RegisteredRouter['routeTree']>, TStrict extends boolean = true, TContext = RouteById<RegisteredRouter['routeTree'], TFrom>['__types']['context'], TSelected = TContext>(opts?: {
+    from: TFrom;
+    strict?: TStrict;
+    select?: (search: TContext) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+declare function useRouteContext<TFrom extends RouteIds<RegisteredRouter['routeTree']>, TStrict extends boolean = true, TRouteContext = RouteById<RegisteredRouter['routeTree'], TFrom>['__types']['routeContext'], TSelected = TRouteContext>(opts?: {
+    from: TFrom;
+    strict?: TStrict;
+    select?: (search: TRouteContext) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+declare function useSearch<TFrom extends RouteIds<RegisteredRouter['routeTree']>, TStrict extends boolean = true, TSearch = RouteById<RegisteredRouter['routeTree'], TFrom>['__types']['fullSearchSchema'], TSelected = TSearch>(opts?: {
+    from: TFrom;
+    strict?: TStrict;
+    select?: (search: TSearch) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+declare function useParams<TFrom extends RouteIds<RegisteredRouter['routeTree']> = '/', TDefaultSelected = AllParams<RegisteredRouter['routeTree']> & RouteById<RegisteredRouter['routeTree'], TFrom>['__types']['allParams'], TSelected = TDefaultSelected>(opts?: {
+    from: TFrom;
+    select?: (search: TDefaultSelected) => TSelected;
+}): TSelected;
+declare function useNavigate<TDefaultFrom extends RoutePaths<RegisteredRouter['routeTree']> = '/'>(defaultOpts?: {
+    from?: TDefaultFrom;
+}): <TFrom extends unknown = TDefaultFrom, TTo extends string = "">(opts?: NavigateOptions<any, TFrom, TTo> | undefined) => Promise<void>;
+declare function useMatchRoute(): <TFrom extends string = "/", TTo extends string = "">(opts: MakeUseMatchRouteOptions<TFrom, TTo>) => any;
+declare function MatchRoute<TFrom extends string = '/', TTo extends string = ''>(props: MakeMatchRouteOptions<TFrom, TTo>): any;
 declare function Outlet(): JSX.Element | null;
-declare function DefaultErrorBoundary({ error }: {
+declare function useInjectHtml(): (html: string | (() => Promise<string> | string)) => void;
+declare function useDehydrate(): <T>(key: any, data: T | (() => T | Promise<T>)) => () => T | undefined;
+declare function useHydrate(): <T = unknown>(key: any) => T;
+declare function ErrorComponent({ error }: {
     error: any;
 }): JSX.Element;
-declare function usePrompt(message: string, when: boolean | any): void;
-declare function Prompt({ message, when, children }: PromptProps): React.ReactNode;
+declare function useBlocker(message: string, condition?: boolean | any): void;
+declare function Block({ message, condition, children }: PromptProps): any;
+declare function shallow<T>(objA: T, objB: T): boolean;
 
-export { DefaultErrorBoundary, MatchesProvider, MatchesProviderProps, Outlet, Prompt, PromptProps, RouteComponent, RouterProps, RouterProvider, createReactRouter, useMatches, usePrompt, useRouter };
+export { AnyRouteComponent, AsyncRouteComponent, Block, ErrorComponent, Link, LinkComponent, LinkPropsOptions, MakeLinkOptions, MakeLinkPropsOptions, MakeMatchRouteOptions, MakeUseMatchRouteOptions, MatchRoute, Navigate, Outlet, PromptProps, RouteComponent, RouteErrorComponent, RouteErrorComponentProps, RouteFromIdOrRoute, RouterProps, RouterProvider, SyncRouteComponent, lazyRouteComponent, matchIdsContext, routerContext, shallow, useBlocker, useDehydrate, useHydrate, useInjectHtml, useLinkProps, useLoader, useMatch, useMatchRoute, useMatches, useNavigate, useParams, useRouteContext, useRouter, useRouterContext, useRouterState, useSearch };