react-router 7.8.1 → 7.8.2-pre.1

package/dist/production/{routeModules-C3oqzPpI.d.ts → routeModules-rOzWJJ9x.d.ts}

@@ -1038,7 +1038,7 @@ declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 /**
  * A Router instance manages all navigation and data loading/mutations
  */
-interface Router {
+interface Router$1 {
     /**
      * @private
      * PRIVATE - DO NOT USE
@@ -1082,7 +1082,7 @@ interface Router {
      * initial data fetches.  Returns a function to cleanup listeners and abort
      * any in-progress loads
      */
-    initialize(): Router;
+    initialize(): Router$1;
     /**
      * @private
      * PRIVATE - DO NOT USE
@@ -1300,7 +1300,6 @@ type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "e
  * Future flags to toggle new feature behavior
  */
 interface FutureConfig {
-    unstable_middleware: boolean;
 }
 /**
  * Initialization options for createRouter
@@ -1322,7 +1321,7 @@ interface RouterInit {
  * State returned from a server-side query() call
  */
 interface StaticHandlerContext {
-    basename: Router["basename"];
+    basename: Router$1["basename"];
     location: RouterState["location"];
     matches: RouterState["matches"];
     loaderData: RouterState["loaderData"];
@@ -1344,7 +1343,9 @@ interface StaticHandler {
         skipLoaderErrorBubbling?: boolean;
         skipRevalidation?: boolean;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_generateMiddlewareResponse?: (query: (r: Request) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
+        unstable_generateMiddlewareResponse?: (query: (r: Request, args?: {
+            filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
+        }) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
     }): Promise<StaticHandlerContext | Response>;
     queryRoute(request: Request, opts?: {
         routeId?: string;
@@ -1577,7 +1578,7 @@ declare const IDLE_BLOCKER: BlockerUnblocked;
 /**
  * Create a router and listen to history POP navigations
  */
-declare function createRouter(init: RouterInit): Router;
+declare function createRouter(init: RouterInit): Router$1;
 interface CreateStaticHandlerOptions {
     basename?: string;
     mapRouteProperties?: MapRoutePropertiesFunction;
@@ -1636,8 +1637,9 @@ interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
 type PatchRoutesOnNavigationFunctionArgs = AgnosticPatchRoutesOnNavigationFunctionArgs<RouteObject, RouteMatch>;
 type PatchRoutesOnNavigationFunction = AgnosticPatchRoutesOnNavigationFunction<RouteObject, RouteMatch>;
 interface DataRouterContextObject extends Omit<NavigationContextObject, "future"> {
-    router: Router;
+    router: Router$1;
     staticContext?: StaticHandlerContext;
+    unstable_onError?: unstable_ClientOnErrorFunction;
 }
 declare const DataRouterContext: React.Context<DataRouterContextObject | null>;
 declare const DataRouterStateContext: React.Context<RouterState | null>;
@@ -1701,6 +1703,842 @@ interface RouteContextObject {
 }
 declare const RouteContext: React.Context<RouteContextObject>;
 
+declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
+    hasErrorBoundary: boolean;
+};
+declare const hydrationRouteProperties: (keyof RouteObject)[];
+/**
+ * @category Data Routers
+ */
+interface MemoryRouterOpts {
+    /**
+     * Basename path for the application.
+     */
+    basename?: string;
+    /**
+     * A function that returns an {@link unstable_RouterContextProvider} instance
+     * which is provided as the `context` argument to client [`action`](../../start/data/route-object#action)s,
+     * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
+     * This function is called to generate a fresh `context` instance on each
+     * navigation or fetcher call.
+     */
+    unstable_getContext?: RouterInit["unstable_getContext"];
+    /**
+     * Future flags to enable for the router.
+     */
+    future?: Partial<FutureConfig>;
+    /**
+     * Hydration data to initialize the router with if you have already performed
+     * data loading on the server.
+     */
+    hydrationData?: HydrationState;
+    /**
+     * Initial entries in the in-memory history stack
+     */
+    initialEntries?: InitialEntry[];
+    /**
+     * Index of `initialEntries` the application should initialize to
+     */
+    initialIndex?: number;
+    /**
+     * Override the default data strategy of loading in parallel.
+     * Only intended for advanced usage.
+     */
+    dataStrategy?: DataStrategyFunction;
+    /**
+     * Lazily define portions of the route tree on navigations.
+     */
+    patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
+}
+/**
+ * Create a new {@link DataRouter} that manages the application path using an
+ * in-memory [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
+ * stack. Useful for non-browser environments without a DOM API.
+ *
+ * @public
+ * @category Data Routers
+ * @mode data
+ * @param routes Application routes
+ * @param opts Options
+ * @param {MemoryRouterOpts.basename} opts.basename n/a
+ * @param {MemoryRouterOpts.dataStrategy} opts.dataStrategy n/a
+ * @param {MemoryRouterOpts.future} opts.future n/a
+ * @param {MemoryRouterOpts.unstable_getContext} opts.unstable_getContext n/a
+ * @param {MemoryRouterOpts.hydrationData} opts.hydrationData n/a
+ * @param {MemoryRouterOpts.initialEntries} opts.initialEntries n/a
+ * @param {MemoryRouterOpts.initialIndex} opts.initialIndex n/a
+ * @param {MemoryRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
+ * @returns An initialized {@link DataRouter} to pass to {@link RouterProvider | `<RouterProvider>`}
+ */
+declare function createMemoryRouter(routes: RouteObject[], opts?: MemoryRouterOpts): Router$1;
+/**
+ * Function signature for client side error handling for loader/actions errors
+ * and rendering errors via `componentDidCatch`
+ */
+interface unstable_ClientOnErrorFunction {
+    (error: unknown, errorInfo?: React.ErrorInfo): void;
+}
+/**
+ * @category Types
+ */
+interface RouterProviderProps {
+    /**
+     * The {@link DataRouter} instance to use for navigation and data fetching.
+     */
+    router: Router$1;
+    /**
+     * The [`ReactDOM.flushSync`](https://react.dev/reference/react-dom/flushSync)
+     * implementation to use for flushing updates.
+     *
+     * You usually don't have to worry about this:
+     * - The `RouterProvider` exported from `react-router/dom` handles this internally for you
+     * - If you are rendering in a non-DOM environment, you can import
+     *   `RouterProvider` from `react-router` and ignore this prop
+     */
+    flushSync?: (fn: () => unknown) => undefined;
+    /**
+     * An error handler function that will be called for any loader/action/render
+     * errors that are encountered in your application.  This is useful for
+     * logging or reporting errors instead of the `ErrorBoundary` because it's not
+     * subject to re-rendering and will only run one time per error.
+     *
+     * The `errorInfo` parameter is passed along from
+     * [`componentDidCatch`](https://react.dev/reference/react/Component#componentdidcatch)
+     * and is only present for render errors.
+     *
+     * ```tsx
+     * <RouterProvider unstable_onError=(error, errorInfo) => {
+     *   console.error(error, errorInfo);
+     *   reportToErrorService(error, errorInfo);
+     * }} />
+     * ```
+     */
+    unstable_onError?: unstable_ClientOnErrorFunction;
+}
+/**
+ * Render the UI for the given {@link DataRouter}. This component should
+ * typically be at the top of an app's element tree.
+ *
+ * ```tsx
+ * import { createBrowserRouter } from "react-router";
+ * import { RouterProvider } from "react-router/dom";
+ * import { createRoot } from "react-dom/client";
+ *
+ * const router = createBrowserRouter(routes);
+ * createRoot(document.getElementById("root")).render(
+ *   <RouterProvider router={router} />
+ * );
+ * ```
+ *
+ * <docs-info>Please note that this component is exported both from
+ * `react-router` and `react-router/dom` with the only difference being that the
+ * latter automatically wires up `react-dom`'s [`flushSync`](https://react.dev/reference/react-dom/flushSync)
+ * implementation. You _almost always_ want to use the version from
+ * `react-router/dom` unless you're running in a non-DOM environment.</docs-info>
+ *
+ *
+ * @public
+ * @category Data Routers
+ * @mode data
+ * @param props Props
+ * @param {RouterProviderProps.flushSync} props.flushSync n/a
+ * @param {RouterProviderProps.unstable_onError} props.unstable_onError n/a
+ * @param {RouterProviderProps.router} props.router n/a
+ * @returns React element for the rendered router
+ */
+declare function RouterProvider({ router, flushSync: reactDomFlushSyncImpl, unstable_onError, }: RouterProviderProps): React.ReactElement;
+/**
+ * @category Types
+ */
+interface MemoryRouterProps {
+    /**
+     * Application basename
+     */
+    basename?: string;
+    /**
+     * Nested {@link Route} elements describing the route tree
+     */
+    children?: React.ReactNode;
+    /**
+     * Initial entries in the in-memory history stack
+     */
+    initialEntries?: InitialEntry[];
+    /**
+     * Index of `initialEntries` the application should initialize to
+     */
+    initialIndex?: number;
+}
+/**
+ * A declarative {@link Router | `<Router>`} that stores all entries in memory.
+ *
+ * @public
+ * @category Declarative Routers
+ * @mode declarative
+ * @param props Props
+ * @param {MemoryRouterProps.basename} props.basename n/a
+ * @param {MemoryRouterProps.children} props.children n/a
+ * @param {MemoryRouterProps.initialEntries} props.initialEntries n/a
+ * @param {MemoryRouterProps.initialIndex} props.initialIndex n/a
+ * @returns A declarative in-memory {@link Router | `<Router>`} for client-side
+ * routing.
+ */
+declare function MemoryRouter({ basename, children, initialEntries, initialIndex, }: MemoryRouterProps): React.ReactElement;
+/**
+ * @category Types
+ */
+interface NavigateProps {
+    /**
+     * The path to navigate to. This can be a string or a {@link Path} object
+     */
+    to: To;
+    /**
+     * Whether to replace the current entry in the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
+     * stack
+     */
+    replace?: boolean;
+    /**
+     * State to pass to the new {@link Location} to store in [`history.state`](https://developer.mozilla.org/en-US/docs/Web/API/History/state).
+     */
+    state?: any;
+    /**
+     * How to interpret relative routing in the `to` prop.
+     * See {@link RelativeRoutingType}.
+     */
+    relative?: RelativeRoutingType;
+}
+/**
+ * A component-based version of {@link useNavigate} to use in a
+ * [`React.Component` class](https://react.dev/reference/react/Component) where
+ * hooks cannot be used.
+ *
+ * It's recommended to avoid using this component in favor of {@link useNavigate}.
+ *
+ * @example
+ * <Navigate to="/tasks" />
+ *
+ * @public
+ * @category Components
+ * @param props Props
+ * @param {NavigateProps.relative} props.relative n/a
+ * @param {NavigateProps.replace} props.replace n/a
+ * @param {NavigateProps.state} props.state n/a
+ * @param {NavigateProps.to} props.to n/a
+ * @returns {void}
+ *
+ */
+declare function Navigate({ to, replace, state, relative, }: NavigateProps): null;
+/**
+ * @category Types
+ */
+interface OutletProps {
+    /**
+     * Provides a context value to the element tree below the outlet. Use when
+     * the parent route needs to provide values to child routes.
+     *
+     * ```tsx
+     * <Outlet context={myContextValue} />
+     * ```
+     *
+     * Access the context with {@link useOutletContext}.
+     */
+    context?: unknown;
+}
+/**
+ * Renders the matching child route of a parent route or nothing if no child
+ * route matches.
+ *
+ * @example
+ * import { Outlet } from "react-router";
+ *
+ * export default function SomeParent() {
+ *   return (
+ *     <div>
+ *       <h1>Parent Content</h1>
+ *       <Outlet />
+ *     </div>
+ *   );
+ * }
+ *
+ * @public
+ * @category Components
+ * @param props Props
+ * @param {OutletProps.context} props.context n/a
+ * @returns React element for the rendered outlet or `null` if no child route matches.
+ */
+declare function Outlet(props: OutletProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface PathRouteProps {
+    /**
+     * Whether the path should be case-sensitive. Defaults to `false`.
+     */
+    caseSensitive?: NonIndexRouteObject["caseSensitive"];
+    /**
+     * The path pattern to match. If unspecified or empty, then this becomes a
+     * layout route.
+     */
+    path?: NonIndexRouteObject["path"];
+    /**
+     * The unique identifier for this route (for use with {@link DataRouter}s)
+     */
+    id?: NonIndexRouteObject["id"];
+    /**
+     * A function that returns a promise that resolves to the route object.
+     * Used for code-splitting routes.
+     * See [`lazy`](../../start/data/route-object#lazy).
+     */
+    lazy?: LazyRouteFunction<NonIndexRouteObject>;
+    /**
+     * The route loader.
+     * See [`loader`](../../start/data/route-object#loader).
+     */
+    loader?: NonIndexRouteObject["loader"];
+    /**
+     * The route action.
+     * See [`action`](../../start/data/route-object#action).
+     */
+    action?: NonIndexRouteObject["action"];
+    hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"];
+    /**
+     * The route shouldRevalidate function.
+     * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
+     */
+    shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"];
+    /**
+     * The route handle.
+     */
+    handle?: NonIndexRouteObject["handle"];
+    /**
+     * Whether this is an index route.
+     */
+    index?: false;
+    /**
+     * Child Route components
+     */
+    children?: React.ReactNode;
+    /**
+     * The React element to render when this Route matches.
+     * Mutually exclusive with `Component`.
+     */
+    element?: React.ReactNode | null;
+    /**
+     * The React element to render while this router is loading data.
+     * Mutually exclusive with `HydrateFallback`.
+     */
+    hydrateFallbackElement?: React.ReactNode | null;
+    /**
+     * The React element to render at this route if an error occurs.
+     * Mutually exclusive with `ErrorBoundary`.
+     */
+    errorElement?: React.ReactNode | null;
+    /**
+     * The React Component to render when this route matches.
+     * Mutually exclusive with `element`.
+     */
+    Component?: React.ComponentType | null;
+    /**
+     * The React Component to render while this router is loading data.
+     * Mutually exclusive with `hydrateFallbackElement`.
+     */
+    HydrateFallback?: React.ComponentType | null;
+    /**
+     * The React Component to render at this route if an error occurs.
+     * Mutually exclusive with `errorElement`.
+     */
+    ErrorBoundary?: React.ComponentType | null;
+}
+/**
+ * @category Types
+ */
+interface LayoutRouteProps extends PathRouteProps {
+}
+/**
+ * @category Types
+ */
+interface IndexRouteProps {
+    /**
+     * Whether the path should be case-sensitive. Defaults to `false`.
+     */
+    caseSensitive?: IndexRouteObject["caseSensitive"];
+    /**
+     * The path pattern to match. If unspecified or empty, then this becomes a
+     * layout route.
+     */
+    path?: IndexRouteObject["path"];
+    /**
+     * The unique identifier for this route (for use with {@link DataRouter}s)
+     */
+    id?: IndexRouteObject["id"];
+    /**
+     * A function that returns a promise that resolves to the route object.
+     * Used for code-splitting routes.
+     * See [`lazy`](../../start/data/route-object#lazy).
+     */
+    lazy?: LazyRouteFunction<IndexRouteObject>;
+    /**
+     * The route loader.
+     * See [`loader`](../../start/data/route-object#loader).
+     */
+    loader?: IndexRouteObject["loader"];
+    /**
+     * The route action.
+     * See [`action`](../../start/data/route-object#action).
+     */
+    action?: IndexRouteObject["action"];
+    hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"];
+    /**
+     * The route shouldRevalidate function.
+     * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
+     */
+    shouldRevalidate?: IndexRouteObject["shouldRevalidate"];
+    /**
+     * The route handle.
+     */
+    handle?: IndexRouteObject["handle"];
+    /**
+     * Whether this is an index route.
+     */
+    index: true;
+    /**
+     * Child Route components
+     */
+    children?: undefined;
+    /**
+     * The React element to render when this Route matches.
+     * Mutually exclusive with `Component`.
+     */
+    element?: React.ReactNode | null;
+    /**
+     * The React element to render while this router is loading data.
+     * Mutually exclusive with `HydrateFallback`.
+     */
+    hydrateFallbackElement?: React.ReactNode | null;
+    /**
+     * The React element to render at this route if an error occurs.
+     * Mutually exclusive with `ErrorBoundary`.
+     */
+    errorElement?: React.ReactNode | null;
+    /**
+     * The React Component to render when this route matches.
+     * Mutually exclusive with `element`.
+     */
+    Component?: React.ComponentType | null;
+    /**
+     * The React Component to render while this router is loading data.
+     * Mutually exclusive with `hydrateFallbackElement`.
+     */
+    HydrateFallback?: React.ComponentType | null;
+    /**
+     * The React Component to render at this route if an error occurs.
+     * Mutually exclusive with `errorElement`.
+     */
+    ErrorBoundary?: React.ComponentType | null;
+}
+type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;
+/**
+ * Configures an element to render when a pattern matches the current location.
+ * It must be rendered within a {@link Routes} element. Note that these routes
+ * do not participate in data loading, actions, code splitting, or any other
+ * route module features.
+ *
+ * @example
+ * // Usually used in a declarative router
+ * function App() {
+ *   return (
+ *     <BrowserRouter>
+ *       <Routes>
+ *         <Route index element={<StepOne />} />
+ *         <Route path="step-2" element={<StepTwo />} />
+ *         <Route path="step-3" element={<StepThree />} />
+ *       </Routes>
+ *    </BrowserRouter>
+ *   );
+ * }
+ *
+ * // But can be used with a data router as well if you prefer the JSX notation
+ * const routes = createRoutesFromElements(
+ *   <>
+ *     <Route index loader={step1Loader} Component={StepOne} />
+ *     <Route path="step-2" loader={step2Loader} Component={StepTwo} />
+ *     <Route path="step-3" loader={step3Loader} Component={StepThree} />
+ *   </>
+ * );
+ *
+ * const router = createBrowserRouter(routes);
+ *
+ * function App() {
+ *   return <RouterProvider router={router} />;
+ * }
+ *
+ * @public
+ * @category Components
+ * @param props Props
+ * @param {PathRouteProps.action} props.action n/a
+ * @param {PathRouteProps.caseSensitive} props.caseSensitive n/a
+ * @param {PathRouteProps.Component} props.Component n/a
+ * @param {PathRouteProps.children} props.children n/a
+ * @param {PathRouteProps.element} props.element n/a
+ * @param {PathRouteProps.ErrorBoundary} props.ErrorBoundary n/a
+ * @param {PathRouteProps.errorElement} props.errorElement n/a
+ * @param {PathRouteProps.handle} props.handle n/a
+ * @param {PathRouteProps.HydrateFallback} props.HydrateFallback n/a
+ * @param {PathRouteProps.hydrateFallbackElement} props.hydrateFallbackElement n/a
+ * @param {PathRouteProps.id} props.id n/a
+ * @param {PathRouteProps.index} props.index n/a
+ * @param {PathRouteProps.lazy} props.lazy n/a
+ * @param {PathRouteProps.loader} props.loader n/a
+ * @param {PathRouteProps.path} props.path n/a
+ * @param {PathRouteProps.shouldRevalidate} props.shouldRevalidate n/a
+ * @returns {void}
+ */
+declare function Route(props: RouteProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface RouterProps {
+    /**
+     * The base path for the application. This is prepended to all locations
+     */
+    basename?: string;
+    /**
+     * Nested {@link Route} elements describing the route tree
+     */
+    children?: React.ReactNode;
+    /**
+     * The location to match against. Defaults to the current location.
+     * This can be a string or a {@link Location} object.
+     */
+    location: Partial<Location> | string;
+    /**
+     * The type of navigation that triggered this `location` change.
+     * Defaults to {@link NavigationType.Pop}.
+     */
+    navigationType?: Action;
+    /**
+     * The navigator to use for navigation. This is usually a history object
+     * or a custom navigator that implements the {@link Navigator} interface.
+     */
+    navigator: Navigator;
+    /**
+     * Whether this router is static or not (used for SSR). If `true`, the router
+     * will not be reactive to location changes.
+     */
+    static?: boolean;
+}
+/**
+ * Provides location context for the rest of the app.
+ *
+ * Note: You usually won't render a `<Router>` directly. Instead, you'll render a
+ * router that is more specific to your environment such as a {@link BrowserRouter}
+ * in web browsers or a {@link ServerRouter} for server rendering.
+ *
+ * @public
+ * @category Declarative Routers
+ * @mode declarative
+ * @param props Props
+ * @param {RouterProps.basename} props.basename n/a
+ * @param {RouterProps.children} props.children n/a
+ * @param {RouterProps.location} props.location n/a
+ * @param {RouterProps.navigationType} props.navigationType n/a
+ * @param {RouterProps.navigator} props.navigator n/a
+ * @param {RouterProps.static} props.static n/a
+ * @returns React element for the rendered router or `null` if the location does
+ * not match the {@link props.basename}
+ */
+declare function Router({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, }: RouterProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface RoutesProps {
+    /**
+     * Nested {@link Route} elements
+     */
+    children?: React.ReactNode;
+    /**
+     * The {@link Location} to match against. Defaults to the current location.
+     */
+    location?: Partial<Location> | string;
+}
+/**
+ * Renders a branch of {@link Route | `<Route>`s} that best matches the current
+ * location. Note that these routes do not participate in [data loading](../../start/framework/route-module#loader),
+ * [`action`](../../start/framework/route-module#action), code splitting, or
+ * any other [route module](../../start/framework/route-module) features.
+ *
+ * @example
+ * import { Route, Routes } from "react-router";
+ *
+ * <Routes>
+ *   <Route index element={<StepOne />} />
+ *   <Route path="step-2" element={<StepTwo />} />
+ *   <Route path="step-3" element={<StepThree />}>
+ * </Routes>
+ *
+ * @public
+ * @category Components
+ * @param props Props
+ * @param {RoutesProps.children} props.children n/a
+ * @param {RoutesProps.location} props.location n/a
+ * @returns React element for the rendered routes or `null` if no route matches
+ */
+declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
+interface AwaitResolveRenderFunction<Resolve = any> {
+    (data: Awaited<Resolve>): React.ReactNode;
+}
+/**
+ * @category Types
+ */
+interface AwaitProps<Resolve> {
+    /**
+     * When using a function, the resolved value is provided as the parameter.
+     *
+     * ```tsx [2]
+     * <Await resolve={reviewsPromise}>
+     *   {(resolvedReviews) => <Reviews items={resolvedReviews} />}
+     * </Await>
+     * ```
+     *
+     * When using React elements, {@link useAsyncValue} will provide the
+     * resolved value:
+     *
+     * ```tsx [2]
+     * <Await resolve={reviewsPromise}>
+     *   <Reviews />
+     * </Await>
+     *
+     * function Reviews() {
+     *   const resolvedReviews = useAsyncValue();
+     *   return <div>...</div>;
+     * }
+     * ```
+     */
+    children: React.ReactNode | AwaitResolveRenderFunction<Resolve>;
+    /**
+     * The error element renders instead of the `children` when the [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+     * rejects.
+     *
+     * ```tsx
+     * <Await
+     *   errorElement={<div>Oops</div>}
+     *   resolve={reviewsPromise}
+     * >
+     *   <Reviews />
+     * </Await>
+     * ```
+     *
+     * To provide a more contextual error, you can use the {@link useAsyncError} in a
+     * child component
+     *
+     * ```tsx
+     * <Await
+     *   errorElement={<ReviewsError />}
+     *   resolve={reviewsPromise}
+     * >
+     *   <Reviews />
+     * </Await>
+     *
+     * function ReviewsError() {
+     *   const error = useAsyncError();
+     *   return <div>Error loading reviews: {error.message}</div>;
+     * }
+     * ```
+     *
+     * If you do not provide an `errorElement`, the rejected value will bubble up
+     * to the nearest route-level [`ErrorBoundary`](../../start/framework/route-module#errorboundary)
+     * and be accessible via the {@link useRouteError} hook.
+     */
+    errorElement?: React.ReactNode;
+    /**
+     * Takes a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+     * returned from a [`loader`](../../start/framework/route-module#loader) to be
+     * resolved and rendered.
+     *
+     * ```tsx
+     * import { Await, useLoaderData } from "react-router";
+     *
+     * export async function loader() {
+     *   let reviews = getReviews(); // not awaited
+     *   let book = await getBook();
+     *   return {
+     *     book,
+     *     reviews, // this is a promise
+     *   };
+     * }
+     *
+     * export default function Book() {
+     *   const {
+     *     book,
+     *     reviews, // this is the same promise
+     *   } = useLoaderData();
+     *
+     *   return (
+     *     <div>
+     *       <h1>{book.title}</h1>
+     *       <p>{book.description}</p>
+     *       <React.Suspense fallback={<ReviewsSkeleton />}>
+     *         <Await
+     *           // and is the promise we pass to Await
+     *           resolve={reviews}
+     *         >
+     *           <Reviews />
+     *         </Await>
+     *       </React.Suspense>
+     *     </div>
+     *   );
+     * }
+     * ```
+     */
+    resolve: Resolve;
+}
+/**
+ * Used to render promise values with automatic error handling.
+ *
+ * **Note:** `<Await>` expects to be rendered inside a [`<React.Suspense>`](https://react.dev/reference/react/Suspense)
+ *
+ * @example
+ * import { Await, useLoaderData } from "react-router";
+ *
+ * export async function loader() {
+ *   // not awaited
+ *   const reviews = getReviews();
+ *   // awaited (blocks the transition)
+ *   const book = await fetch("/api/book").then((res) => res.json());
+ *   return { book, reviews };
+ * }
+ *
+ * function Book() {
+ *   const { book, reviews } = useLoaderData();
+ *   return (
+ *     <div>
+ *       <h1>{book.title}</h1>
+ *       <p>{book.description}</p>
+ *       <React.Suspense fallback={<ReviewsSkeleton />}>
+ *         <Await
+ *           resolve={reviews}
+ *           errorElement={
+ *             <div>Could not load reviews 😬</div>
+ *           }
+ *           children={(resolvedReviews) => (
+ *             <Reviews items={resolvedReviews} />
+ *           )}
+ *         />
+ *       </React.Suspense>
+ *     </div>
+ *   );
+ * }
+ *
+ * @public
+ * @category Components
+ * @mode framework
+ * @mode data
+ * @param props Props
+ * @param {AwaitProps.children} props.children n/a
+ * @param {AwaitProps.errorElement} props.errorElement n/a
+ * @param {AwaitProps.resolve} props.resolve n/a
+ * @returns React element for the rendered awaited value
+ */
+declare function Await<Resolve>({ children, errorElement, resolve, }: AwaitProps<Resolve>): React.JSX.Element;
+/**
+ * Creates a route config from a React "children" object, which is usually
+ * either a `<Route>` element or an array of them. Used internally by
+ * `<Routes>` to create a route config from its children.
+ *
+ * @category Utils
+ * @mode data
+ * @param children The React children to convert into a route config
+ * @param parentPath The path of the parent route, used to generate unique IDs.
+ * @returns An array of {@link RouteObject}s that can be used with a {@link DataRouter}
+ */
+declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[];
+/**
+ * Create route objects from JSX elements instead of arrays of objects.
+ *
+ * @example
+ * const routes = createRoutesFromElements(
+ *   <>
+ *     <Route index loader={step1Loader} Component={StepOne} />
+ *     <Route path="step-2" loader={step2Loader} Component={StepTwo} />
+ *     <Route path="step-3" loader={step3Loader} Component={StepThree} />
+ *   </>
+ * );
+ *
+ * const router = createBrowserRouter(routes);
+ *
+ * function App() {
+ *   return <RouterProvider router={router} />;
+ * }
+ *
+ * @name createRoutesFromElements
+ * @public
+ * @category Utils
+ * @mode data
+ * @param children The React children to convert into a route config
+ * @param parentPath The path of the parent route, used to generate unique IDs.
+ * This is used for internal recursion and is not intended to be used by the
+ * application developer.
+ * @returns An array of {@link RouteObject}s that can be used with a {@link DataRouter}
+ */
+declare const createRoutesFromElements: typeof createRoutesFromChildren;
+/**
+ * Renders the result of {@link matchRoutes} into a React element.
+ *
+ * @public
+ * @category Utils
+ * @param matches The array of {@link RouteMatch | route matches} to render
+ * @returns A React element that renders the matched routes or `null` if no matches
+ */
+declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
+declare function useRouteComponentProps(): {
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+    matches: UIMatch<unknown, unknown>[];
+};
+type RouteComponentProps = ReturnType<typeof useRouteComponentProps>;
+type RouteComponentType = React.ComponentType<RouteComponentProps>;
+declare function WithComponentProps({ children, }: {
+    children: React.ReactElement;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare function withComponentProps(Component: RouteComponentType): () => React.ReactElement<{
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+    matches: UIMatch<unknown, unknown>[];
+}, string | React.JSXElementConstructor<any>>;
+declare function useHydrateFallbackProps(): {
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+};
+type HydrateFallbackProps = ReturnType<typeof useHydrateFallbackProps>;
+type HydrateFallbackType = React.ComponentType<HydrateFallbackProps>;
+declare function WithHydrateFallbackProps({ children, }: {
+    children: React.ReactElement;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare function withHydrateFallbackProps(HydrateFallback: HydrateFallbackType): () => React.ReactElement<{
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+}, string | React.JSXElementConstructor<any>>;
+declare function useErrorBoundaryProps(): {
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+    error: unknown;
+};
+type ErrorBoundaryProps = ReturnType<typeof useErrorBoundaryProps>;
+type ErrorBoundaryType = React.ComponentType<ErrorBoundaryProps>;
+declare function WithErrorBoundaryProps({ children, }: {
+    children: React.ReactElement;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare function withErrorBoundaryProps(ErrorBoundary: ErrorBoundaryType): () => React.ReactElement<{
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+    error: unknown;
+}, string | React.JSXElementConstructor<any>>;
+
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
 interface HtmlLinkProps {
@@ -1865,7 +2703,7 @@ type unstable_SerializesTo<T> = {
     unstable__ReactRouter_SerializesTo: [T];
 };
 
-type Serialize<T> = T extends unstable_SerializesTo<infer To> ? To : T extends Serializable ? T : T extends (...args: any[]) => unknown ? undefined : T extends Promise<infer U> ? Promise<Serialize<U>> : T extends Map<infer K, infer V> ? Map<Serialize<K>, Serialize<V>> : T extends Set<infer U> ? Set<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? {
+type Serialize<T> = T extends unstable_SerializesTo<infer To> ? To : T extends Serializable ? T : T extends (...args: any[]) => unknown ? undefined : T extends Promise<infer U> ? Promise<Serialize<U>> : T extends Map<infer K, infer V> ? Map<Serialize<K>, Serialize<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Serialize<K>, Serialize<V>> : T extends Set<infer U> ? Set<Serialize<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? {
     [K in keyof T]: Serialize<T[K]>;
 } : undefined;
 type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
@@ -1972,7 +2810,7 @@ interface RouteModules {
 interface RouteModule {
     clientAction?: ClientActionFunction;
     clientLoader?: ClientLoaderFunction;
-    unstable_clientMiddleware?: unstable_MiddlewareFunction<undefined>[];
+    unstable_clientMiddleware?: unstable_MiddlewareFunction<Record<string, DataStrategyResult>>[];
     ErrorBoundary?: ErrorBoundaryComponent;
     HydrateFallback?: HydrateFallbackComponent;
     Layout?: LayoutComponent;
@@ -2170,4 +3008,4 @@ type RouteComponent = ComponentType<{}>;
  */
 type RouteHandle = unknown;
 
-export { type GetScrollRestorationKeyFunction as $, Action as A, type BlockerFunction as B, type ClientDataFunctionArgs as C, type DataStrategyFunction as D, type Equal as E, type Func as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type ClientActionFunction as J, type ClientLoaderFunction as K, type LinkDescriptor as L, type MetaDescriptor as M, type Normalize as N, type HeadersFunction as O, type Pretty as P, type ShouldRevalidateFunction as Q, type RouteModule$1 as R, type ServerDataFunctionArgs as S, type To as T, type UIMatch as U, type RouterInit as V, type RouterState as W, type PatchRoutesOnNavigationFunction as X, type DataRouteObject as Y, type StaticHandler as Z, type GetScrollPositionFunction as _, type Location as a, type ServerRouteModule as a$, type StaticHandlerContext as a0, type Fetcher as a1, type NavigationStates as a2, type RouterSubscriber as a3, type RouterNavigateOptions as a4, type RouterFetchOptions as a5, type RevalidationState as a6, type ActionFunctionArgs as a7, type DataStrategyFunctionArgs as a8, type DataStrategyMatch as a9, replace as aA, resolvePath as aB, type DataRouteMatch as aC, type Navigator as aD, type PatchRoutesOnNavigationFunctionArgs as aE, type RouteMatch as aF, type ClientActionFunctionArgs as aG, type ClientLoaderFunctionArgs as aH, type HeadersArgs as aI, type MetaArgs as aJ, type PageLinkDescriptor as aK, type HtmlLinkDescriptor as aL, type Future as aM, type unstable_SerializesTo as aN, createBrowserHistory as aO, invariant as aP, createRouter as aQ, ErrorResponseImpl as aR, DataRouterContext as aS, DataRouterStateContext as aT, FetchersContext as aU, LocationContext as aV, NavigationContext as aW, RouteContext as aX, ViewTransitionContext as aY, type FutureConfig as aZ, type RouteManifest as a_, type DataStrategyResult as aa, DataWithResponseInit as ab, type ErrorResponse as ac, type FormEncType as ad, type FormMethod as ae, type HTMLFormMethod as af, type LazyRouteFunction as ag, type LoaderFunctionArgs as ah, type unstable_MiddlewareFunction as ai, type PathParam as aj, type RedirectFunction as ak, type unstable_RouterContext as al, type ShouldRevalidateFunctionArgs as am, unstable_createContext as an, createPath as ao, parsePath as ap, IDLE_NAVIGATION as aq, IDLE_FETCHER as ar, IDLE_BLOCKER as as, data as at, generatePath as au, isRouteErrorResponse as av, matchPath as aw, matchRoutes as ax, redirect as ay, redirectDocument as az, type ServerDataFrom as b, type History as b0, type CreateStaticHandlerOptions as b1, type GetActionData as c, type Router as d, type RouteModules as e, type NavigateOptions as f, type Blocker as g, type SerializeFrom as h, type RelativeRoutingType as i, type ParamParseKey as j, type Path as k, type PathPattern as l, type PathMatch as m, type Navigation as n, type Params as o, type RouteObject as p, type IndexRouteObject as q, type LoaderFunction as r, type ActionFunction as s, type MetaFunction as t, type unstable_MiddlewareNextFunction as u, type LinksFunction as v, type NonIndexRouteObject as w, type AppLoadContext as x, unstable_RouterContextProvider as y, type MiddlewareEnabled as z };
+export { type PatchRoutesOnNavigationFunction as $, Action as A, type BlockerFunction as B, type ClientDataFunctionArgs as C, type DataStrategyResult as D, type ErrorBoundaryType as E, type Func as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type AppLoadContext as J, unstable_RouterContextProvider as K, type LinkDescriptor as L, type MetaDescriptor as M, type Normalize as N, type MiddlewareEnabled as O, type Pretty as P, type Equal as Q, type RouteModule$1 as R, type ServerDataFunctionArgs as S, type To as T, type UIMatch as U, type ClientActionFunction as V, type ClientLoaderFunction as W, type HeadersFunction as X, type ShouldRevalidateFunction as Y, type RouterInit as Z, type RouterState as _, type Location as a, Router as a$, type DataRouteObject as a0, type StaticHandler as a1, type GetScrollPositionFunction as a2, type GetScrollRestorationKeyFunction as a3, type StaticHandlerContext as a4, type Fetcher as a5, type NavigationStates as a6, type RouterSubscriber as a7, type RouterNavigateOptions as a8, type RouterFetchOptions as a9, matchRoutes as aA, redirect as aB, redirectDocument as aC, replace as aD, resolvePath as aE, type DataRouteMatch as aF, type Navigator as aG, type PatchRoutesOnNavigationFunctionArgs as aH, type RouteMatch as aI, type AwaitProps as aJ, type IndexRouteProps as aK, type unstable_ClientOnErrorFunction as aL, type LayoutRouteProps as aM, type MemoryRouterOpts as aN, type MemoryRouterProps as aO, type NavigateProps as aP, type OutletProps as aQ, type PathRouteProps as aR, type RouteProps as aS, type RouterProps as aT, type RouterProviderProps as aU, type RoutesProps as aV, Await as aW, MemoryRouter as aX, Navigate as aY, Outlet as aZ, Route as a_, type RevalidationState as aa, type ActionFunctionArgs as ab, type DataStrategyFunctionArgs as ac, type DataStrategyMatch as ad, DataWithResponseInit as ae, type ErrorResponse as af, type FormEncType as ag, type FormMethod as ah, type HTMLFormMethod as ai, type LazyRouteFunction as aj, type LoaderFunctionArgs as ak, type unstable_MiddlewareFunction as al, type PathParam as am, type RedirectFunction as an, type unstable_RouterContext as ao, type ShouldRevalidateFunctionArgs as ap, unstable_createContext as aq, createPath as ar, parsePath as as, IDLE_NAVIGATION as at, IDLE_FETCHER as au, IDLE_BLOCKER as av, data as aw, generatePath as ax, isRouteErrorResponse as ay, matchPath as az, type ServerDataFrom as b, RouterProvider as b0, Routes as b1, createMemoryRouter as b2, createRoutesFromChildren as b3, createRoutesFromElements as b4, renderMatches as b5, type ClientActionFunctionArgs as b6, type ClientLoaderFunctionArgs as b7, type HeadersArgs as b8, type MetaArgs as b9, type FutureConfig as bA, type CreateStaticHandlerOptions as bB, type PageLinkDescriptor as ba, type HtmlLinkDescriptor as bb, type Future as bc, type unstable_SerializesTo as bd, createBrowserHistory as be, invariant as bf, createRouter as bg, ErrorResponseImpl as bh, DataRouterContext as bi, DataRouterStateContext as bj, FetchersContext as bk, LocationContext as bl, NavigationContext as bm, RouteContext as bn, ViewTransitionContext as bo, hydrationRouteProperties as bp, mapRouteProperties as bq, WithComponentProps as br, withComponentProps as bs, WithHydrateFallbackProps as bt, withHydrateFallbackProps as bu, WithErrorBoundaryProps as bv, withErrorBoundaryProps as bw, type RouteManifest as bx, type ServerRouteModule as by, type History as bz, type GetActionData as c, type Router$1 as d, type RouteModules as e, type DataStrategyFunction as f, type NavigateOptions as g, type Blocker as h, type SerializeFrom as i, type RelativeRoutingType as j, type ParamParseKey as k, type Path as l, type PathPattern as m, type PathMatch as n, type Navigation as o, type Params as p, type RouteObject as q, type IndexRouteObject as r, type RouteComponentType as s, type HydrateFallbackType as t, type unstable_MiddlewareNextFunction as u, type LoaderFunction as v, type ActionFunction as w, type MetaFunction as x, type LinksFunction as y, type NonIndexRouteObject as z };