react-router 7.7.0 → 7.7.1

package/dist/production/index.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.7.0
+ * react-router v7.7.1
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -31,7 +31,7 @@ import {
   isSession,
   routeRSCServerRequest,
   setDevServerHooks
-} from "./chunk-GNZILI6H.mjs";
+} from "./chunk-K3SBCRK4.mjs";
 import {
   Action,
   Await,
@@ -140,7 +140,7 @@ import {
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-WPPIQDYG.mjs";
+} from "./chunk-IZ57JD2V.mjs";
 export {
   Await,
   BrowserRouter,

package/dist/production/lib/types/internal.d.mts

@@ -1,4 +1,4 @@
-import { n as RouteModule, o as LinkDescriptor, c as Location, p as Pretty, q as MetaDescriptor, G as GetLoaderData, r as ServerDataFunctionArgs, s as unstable_MiddlewareNextFunction, t as ClientDataFunctionArgs, v as ServerDataFrom, w as Normalize, x as GetActionData } from '../../route-data-DjzmHYNR.mjs';
+import { n as RouteModule, o as LinkDescriptor, c as Location, p as Pretty, q as MetaDescriptor, G as GetLoaderData, r as ServerDataFunctionArgs, s as unstable_MiddlewareNextFunction, t as ClientDataFunctionArgs, v as ServerDataFrom, w as Normalize, x as GetActionData } from '../../route-data-CqEmXQub.mjs';
 import { R as RouteFiles, P as Pages } from '../../register-DiOIlEq5.mjs';
 import 'react';
 

package/dist/production/lib/types/internal.d.ts

@@ -1,4 +1,4 @@
-import { R as RouteModule, L as LinkDescriptor, a as Location, P as Pretty, M as MetaDescriptor, G as GetLoaderData, S as ServerDataFunctionArgs, u as unstable_MiddlewareNextFunction, C as ClientDataFunctionArgs, b as ServerDataFrom, N as Normalize, c as GetActionData } from '../../routeModules-g5PTiDfO.js';
+import { R as RouteModule, L as LinkDescriptor, a as Location, P as Pretty, M as MetaDescriptor, G as GetLoaderData, S as ServerDataFunctionArgs, u as unstable_MiddlewareNextFunction, C as ClientDataFunctionArgs, b as ServerDataFrom, N as Normalize, c as GetActionData } from '../../routeModules-BR2FO0ix.js';
 import { R as RouteFiles, P as Pages } from '../../register-DiOIlEq5.js';
 import 'react';
 

package/dist/production/lib/types/internal.js

@@ -1,5 +1,5 @@
 "use strict";/**
- * react-router v7.7.0
+ * react-router v7.7.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/types/internal.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v7.7.0
+ * react-router v7.7.1
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/{development/route-data-DjzmHYNR.d.mts → production/route-data-CqEmXQub.d.mts}

@@ -448,14 +448,56 @@ interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRoute
         handler: Promise<void> | undefined;
         route: Promise<void> | undefined;
     };
+    /**
+     * A boolean value indicating whether this route handler should be called in this pass.
+     *
+     * The `matches` array always includes _all_ matched routes even when only _some_
+     * route handlers need to be called so that things like middleware can be implemented.
+     *
+     * `shouldLoad` is usually only interesting if you are skipping the route handler
+     * entirely and implementing custom handler logic - since it lets you determine
+     * if that custom logic should run for this route or not.
+     *
+     * For example:
+     *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
+     *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
+     *    will have `shouldLoad=true` because the data for `parent` and `child` is
+     *    already loaded
+     *  - If you are on `/parent/child/a` and you submit to `a`'s `action`, then only
+     *    `a` will have `shouldLoad=true` for the action execution of `dataStrategy`
+     *  - After the `action`, `dataStrategy` will be called again for the `loader`
+     *    revalidation, and all matches will have `shouldLoad=true` (assuming no custom
+     *   `shouldRevalidate` implementations)
+     */
     shouldLoad: boolean;
     unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
     unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
+    /**
+     * An async function that will resolve any `route.lazy` implementations and
+     * execute the route's handler (if necessary), returning a `DataStrategyResult`
+     *
+     * - Calling `match.resolve` does not mean you're calling the `loader`/`action`
+     *   (the "handler") - `resolve` will only call the `handler` internally if
+     *   needed _and_ if you don't pass your own `handlerOverride` function parameter
+     * - It is safe to call `match.resolve` for all matches, even if they have
+     *   `shouldLoad=false`, and it will no-op if no loading is required
+     * - You should generally always call `match.resolve()` for `shouldLoad:true`
+     *   routes to ensure that any `route.lazy` implementations are processed
+     * - See the examples below for how to implement custom handler execution via
+     *   `match.resolve`
+     */
     resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
 }
 interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
+    /**
+     * Matches for this route extended with Data strategy APIs
+     */
     matches: DataStrategyMatch[];
     unstable_runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
+    /**
+     * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
+     * for navigational executions
+     */
     fetcherKey: string | null;
 }
 /**
@@ -1092,8 +1134,12 @@ interface GetScrollPositionFunction {
     (): number;
 }
 /**
-  - "route": relative to the route hierarchy so `..` means remove all segments of the current route even if it has many. For example, a `route("posts/:id")` would have both `:id` and `posts` removed from the url.
-  - "path": relative to the pathname so `..` means remove one segment of the pathname. For example, a `route("posts/:id")` would have only `:id` removed from the url.
+ * - "route": relative to the route hierarchy so `..` means remove all segments
+ * of the current route even if it has many. For example, a `route("posts/:id")`
+ * would have both `:id` and `posts` removed from the url.
+ * - "path": relative to the pathname so `..` means remove one segment of the
+ * pathname. For example, a `route("posts/:id")` would have only `:id` removed
+ * from the url.
  */
 type RelativeRoutingType = "route" | "path";
 type BaseNavigateOrFetchOptions = {

package/dist/{development/routeModules-g5PTiDfO.d.ts → production/routeModules-BR2FO0ix.d.ts}

@@ -448,14 +448,56 @@ interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRoute
         handler: Promise<void> | undefined;
         route: Promise<void> | undefined;
     };
+    /**
+     * A boolean value indicating whether this route handler should be called in this pass.
+     *
+     * The `matches` array always includes _all_ matched routes even when only _some_
+     * route handlers need to be called so that things like middleware can be implemented.
+     *
+     * `shouldLoad` is usually only interesting if you are skipping the route handler
+     * entirely and implementing custom handler logic - since it lets you determine
+     * if that custom logic should run for this route or not.
+     *
+     * For example:
+     *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
+     *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
+     *    will have `shouldLoad=true` because the data for `parent` and `child` is
+     *    already loaded
+     *  - If you are on `/parent/child/a` and you submit to `a`'s `action`, then only
+     *    `a` will have `shouldLoad=true` for the action execution of `dataStrategy`
+     *  - After the `action`, `dataStrategy` will be called again for the `loader`
+     *    revalidation, and all matches will have `shouldLoad=true` (assuming no custom
+     *   `shouldRevalidate` implementations)
+     */
     shouldLoad: boolean;
     unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
     unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
+    /**
+     * An async function that will resolve any `route.lazy` implementations and
+     * execute the route's handler (if necessary), returning a `DataStrategyResult`
+     *
+     * - Calling `match.resolve` does not mean you're calling the `loader`/`action`
+     *   (the "handler") - `resolve` will only call the `handler` internally if
+     *   needed _and_ if you don't pass your own `handlerOverride` function parameter
+     * - It is safe to call `match.resolve` for all matches, even if they have
+     *   `shouldLoad=false`, and it will no-op if no loading is required
+     * - You should generally always call `match.resolve()` for `shouldLoad:true`
+     *   routes to ensure that any `route.lazy` implementations are processed
+     * - See the examples below for how to implement custom handler execution via
+     *   `match.resolve`
+     */
     resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
 }
 interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
+    /**
+     * Matches for this route extended with Data strategy APIs
+     */
     matches: DataStrategyMatch[];
     unstable_runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
+    /**
+     * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
+     * for navigational executions
+     */
     fetcherKey: string | null;
 }
 /**
@@ -1092,8 +1134,12 @@ interface GetScrollPositionFunction {
     (): number;
 }
 /**
-  - "route": relative to the route hierarchy so `..` means remove all segments of the current route even if it has many. For example, a `route("posts/:id")` would have both `:id` and `posts` removed from the url.
-  - "path": relative to the pathname so `..` means remove one segment of the pathname. For example, a `route("posts/:id")` would have only `:id` removed from the url.
+ * - "route": relative to the route hierarchy so `..` means remove all segments
+ * of the current route even if it has many. For example, a `route("posts/:id")`
+ * would have both `:id` and `posts` removed from the url.
+ * - "path": relative to the pathname so `..` means remove one segment of the
+ * pathname. For example, a `route("posts/:id")` would have only `:id` removed
+ * from the url.
  */
 type RelativeRoutingType = "route" | "path";
 type BaseNavigateOrFetchOptions = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-router",
-  "version": "7.7.0",
+  "version": "7.7.1",
   "description": "Declarative routing for React",
   "keywords": [
     "react",

package/dist/development/components-DzqPLVI1.d.mts

@@ -1,464 +0,0 @@
-import { R as Router$1, I as InitialEntry, T as To, a as RelativeRoutingType, N as NonIndexRouteObject, L as LazyRouteFunction, b as IndexRouteObject, c as Location, A as Action, d as Navigator, e as RouterInit, F as FutureConfig, H as HydrationState, D as DataStrategyFunction, P as PatchRoutesOnNavigationFunction, f as RouteObject, g as RouteMatch, h as Params, U as UIMatch } from './route-data-DjzmHYNR.mjs';
-import * as React from 'react';
-
-/**
- * @private
- */
-declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
-    hasErrorBoundary: boolean;
-};
-declare const hydrationRouteProperties: (keyof RouteObject)[];
-interface MemoryRouterOpts {
-    /**
-     * Basename path for the application.
-     */
-    basename?: string;
-    /**
-     * Function to provide the initial context values for all client side navigations/fetches
-     */
-    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 entires 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 data router that manages the application path using an in-memory
- * history stack.  Useful for non-browser environments without a DOM API.
- *
- * @category Data Routers
- */
-declare function createMemoryRouter(
-/**
- * Application routes
- */
-routes: RouteObject[], 
-/**
- * Router options
- */
-opts?: MemoryRouterOpts): Router$1;
-interface RouterProviderProps {
-    router: Router$1;
-    flushSync?: (fn: () => unknown) => undefined;
-}
-/**
- * Given a Remix Router instance, render the appropriate UI
- */
-declare function RouterProvider({ router, flushSync: reactDomFlushSyncImpl, }: RouterProviderProps): React.ReactElement;
-/**
- * @category Types
- */
-interface MemoryRouterProps {
-    basename?: string;
-    children?: React.ReactNode;
-    initialEntries?: InitialEntry[];
-    initialIndex?: number;
-}
-/**
- * A `<Router>` that stores all entries in memory.
- *
- * @category Component Routers
- */
-declare function MemoryRouter({ basename, children, initialEntries, initialIndex, }: MemoryRouterProps): React.ReactElement;
-/**
- * @category Types
- */
-interface NavigateProps {
-    to: To;
-    replace?: boolean;
-    state?: any;
-    relative?: RelativeRoutingType;
-}
-/**
- * A component-based version of {@link useNavigate} to use in a [`React.Component
- * Class`](https://reactjs.org/docs/react-component.html) where hooks are not
- * able to be used.
- *
- * It's recommended to avoid using this component in favor of {@link useNavigate}
- *
- * @category Components
- */
-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.
-
-  ```tsx
-  import { Outlet } from "react-router"
-
-  export default function SomeParent() {
-    return (
-      <div>
-        <h1>Parent Content</h1>
-        <Outlet />
-      </div>
-    );
-  }
-  ```
-
-  @category Components
- */
-declare function Outlet(props: OutletProps): React.ReactElement | null;
-/**
- * @category Types
- */
-interface PathRouteProps {
-    caseSensitive?: NonIndexRouteObject["caseSensitive"];
-    path?: NonIndexRouteObject["path"];
-    id?: NonIndexRouteObject["id"];
-    lazy?: LazyRouteFunction<NonIndexRouteObject>;
-    loader?: NonIndexRouteObject["loader"];
-    action?: NonIndexRouteObject["action"];
-    hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"];
-    shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"];
-    handle?: NonIndexRouteObject["handle"];
-    index?: false;
-    children?: React.ReactNode;
-    element?: React.ReactNode | null;
-    hydrateFallbackElement?: React.ReactNode | null;
-    errorElement?: React.ReactNode | null;
-    Component?: React.ComponentType | null;
-    HydrateFallback?: React.ComponentType | null;
-    ErrorBoundary?: React.ComponentType | null;
-}
-/**
- * @category Types
- */
-interface LayoutRouteProps extends PathRouteProps {
-}
-/**
- * @category Types
- */
-interface IndexRouteProps {
-    caseSensitive?: IndexRouteObject["caseSensitive"];
-    path?: IndexRouteObject["path"];
-    id?: IndexRouteObject["id"];
-    lazy?: LazyRouteFunction<IndexRouteObject>;
-    loader?: IndexRouteObject["loader"];
-    action?: IndexRouteObject["action"];
-    hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"];
-    shouldRevalidate?: IndexRouteObject["shouldRevalidate"];
-    handle?: IndexRouteObject["handle"];
-    index: true;
-    children?: undefined;
-    element?: React.ReactNode | null;
-    hydrateFallbackElement?: React.ReactNode | null;
-    errorElement?: React.ReactNode | null;
-    Component?: React.ComponentType | null;
-    HydrateFallback?: React.ComponentType | null;
-    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.
- *
- * @category Components
- */
-declare function Route(_props: RouteProps): React.ReactElement | null;
-/**
- * @category Types
- */
-interface RouterProps {
-    basename?: string;
-    children?: React.ReactNode;
-    location: Partial<Location> | string;
-    navigationType?: Action;
-    navigator: Navigator;
-    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 `<BrowserRouter>`
- * in web browsers or a `<StaticRouter>` for server rendering.
- *
- * @category Components
- */
-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 location to match against. Defaults to the current location.
-     */
-    location?: Partial<Location> | string;
-}
-/**
- Renders a branch of {@link Route | `<Routes>`} that best matches the current
- location. Note that these routes do not participate in data loading, actions,
- code splitting, or any other route module features.
-
- ```tsx
- import { Routes, Route } from "react-router"
-
-<Routes>
-  <Route index element={<StepOne />} />
-  <Route path="step-2" element={<StepTwo />} />
-  <Route path="step-3" element={<StepThree />}>
-</Routes>
- ```
-
- @category Components
- */
-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 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 {@link NonIndexRouteObject#ErrorBoundary | ErrorBoundary} and be accessible
-    via {@link useRouteError} hook.
-    */
-    errorElement?: React.ReactNode;
-    /**
-    Takes a promise returned from a {@link LoaderFunction | loader} value to be resolved and rendered.
-  
-    ```jsx
-    import { useLoaderData, Await } 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.
-
-```tsx
-import { Await, useLoaderData } from "react-router";
-
-export 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>
-  );
-}
-```
-
-**Note:** `<Await>` expects to be rendered inside of a `<React.Suspense>`
-
-@category Components
-
-*/
-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
- */
-declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[];
-/**
- * Create route objects from JSX elements instead of arrays of objects
- */
-declare let createRoutesFromElements: typeof createRoutesFromChildren;
-/**
- * Renders the result of `matchRoutes()` into a React element.
- *
- * @category Utils
- */
-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>>;
-
-export { type AwaitProps as A, type ErrorBoundaryType as E, type HydrateFallbackType as H, type IndexRouteProps as I, type LayoutRouteProps as L, type MemoryRouterOpts as M, type NavigateProps as N, type OutletProps as O, type PathRouteProps as P, type RouterProviderProps as R, WithComponentProps as W, type RouteComponentType as a, type MemoryRouterProps as b, type RouteProps as c, type RouterProps as d, type RoutesProps as e, Await as f, MemoryRouter as g, Navigate as h, Outlet as i, Route as j, Router as k, RouterProvider as l, Routes as m, createMemoryRouter as n, createRoutesFromChildren as o, createRoutesFromElements as p, hydrationRouteProperties as q, renderMatches as r, mapRouteProperties as s, WithHydrateFallbackProps as t, withHydrateFallbackProps as u, WithErrorBoundaryProps as v, withComponentProps as w, withErrorBoundaryProps as x };