react-router 7.6.1-pre.2 → 7.6.2

package/dist/production/index.d.ts

@@ -1,936 +1,970 @@
-import { R as RouteObject, a as RouterInit, F as FutureConfig$1, H as HydrationState, I as InitialEntry, D as DataStrategyFunction, P as PatchRoutesOnNavigationFunction, b as Router$1, T as To, c as RelativeRoutingType, N as NonIndexRouteObject, L as LazyRouteFunction, d as IndexRouteObject, e as Location, A as Action, f as Navigator, g as RouteMatch, h as RouteManifest, S as ServerRouteModule, M as MiddlewareEnabled, u as unstable_RouterContextProvider, i as AppLoadContext, j as LoaderFunctionArgs, k as ActionFunctionArgs, l as StaticHandlerContext, m as RouteModules, n as DataRouteObject, C as ClientLoaderFunction, o as ParamParseKey, p as Path, q as PathPattern, r as PathMatch, s as NavigateOptions, t as Params, v as Navigation, U as UIMatch, w as SerializeFrom, B as BlockerFunction, x as Blocker, y as HTMLFormMethod, z as FormEncType, E as PageLinkDescriptor, G as History, J as GetScrollRestorationKeyFunction, K as Fetcher, O as StaticHandler, Q as CreateStaticHandlerOptions$1, V as unstable_InitialContext, W as LoaderFunction, X as ActionFunction, Y as MetaFunction, Z as LinksFunction, _ as Pages, $ as Equal, a0 as RouterState } from './register-BkDIKxVz.js';
-export { aA as ClientActionFunction, aB as ClientActionFunctionArgs, aC as ClientLoaderFunctionArgs, ay as DataRouteMatch, a7 as DataStrategyFunctionArgs, a8 as DataStrategyMatch, a9 as DataStrategyResult, ab as ErrorResponse, ac as FormMethod, aJ as Future, a1 as GetScrollPositionFunction, aD as HeadersArgs, aE as HeadersFunction, aH as HtmlLinkDescriptor, ao as IDLE_BLOCKER, an as IDLE_FETCHER, am as IDLE_NAVIGATION, aI as LinkDescriptor, aF as MetaArgs, aG as MetaDescriptor, a2 as NavigationStates, az as PatchRoutesOnNavigationFunctionArgs, ae as PathParam, af as RedirectFunction, aL as Register, a6 as RevalidationState, a5 as RouterFetchOptions, a4 as RouterNavigateOptions, a3 as RouterSubscriber, ah as ShouldRevalidateFunction, ai as ShouldRevalidateFunctionArgs, aQ as UNSAFE_DataRouterContext, aR as UNSAFE_DataRouterStateContext, aa as UNSAFE_DataWithResponseInit, aP as UNSAFE_ErrorResponseImpl, aS as UNSAFE_FetchersContext, aT as UNSAFE_LocationContext, aU as UNSAFE_NavigationContext, aV as UNSAFE_RouteContext, aW as UNSAFE_ViewTransitionContext, aM as UNSAFE_createBrowserHistory, aO as UNSAFE_createRouter, aN as UNSAFE_invariant, ak as createPath, ap as data, aq as generatePath, ar as isRouteErrorResponse, as as matchPath, at as matchRoutes, al as parsePath, au as redirect, av as redirectDocument, aw as replace, ax as resolvePath, ad as unstable_MiddlewareFunction, ag as unstable_RouterContext, aK as unstable_SerializesTo, aj as unstable_createContext } from './register-BkDIKxVz.js';
+import { R as RouteManifest, S as ServerRouteModule, M as MiddlewareEnabled, u as unstable_RouterContextProvider, A as AppLoadContext, L as LoaderFunctionArgs, a as ActionFunctionArgs, b as StaticHandlerContext, c as RouteModules, H as HydrationState, D as DataRouteObject, C as ClientLoaderFunction, d as Router$1, e as DataStrategyFunction, T as To, f as RelativeRoutingType, g as Location, h as Action, P as ParamParseKey, i as Path, j as PathPattern, k as PathMatch, N as NavigateOptions, l as Params, m as RouteObject, n as Navigation, U as UIMatch, o as SerializeFrom, B as BlockerFunction, p as Blocker, q as RouterInit, F as FutureConfig$1, I as InitialEntry, r as PatchRoutesOnNavigationFunction, s as NonIndexRouteObject, t as LazyRouteFunction, v as IndexRouteObject, w as Navigator, x as RouteMatch, y as HTMLFormMethod, z as FormEncType, E as PageLinkDescriptor, G as History, J as GetScrollRestorationKeyFunction, K as Fetcher, O as StaticHandler, Q as CreateStaticHandlerOptions$1, V as unstable_InitialContext, W as LoaderFunction, X as ActionFunction, Y as MetaFunction, Z as LinksFunction, _ as Pages, $ as Equal, a0 as RouterState } from './register-DCE0tH5m.js';
+export { aA as ClientActionFunction, aB as ClientActionFunctionArgs, aC as ClientLoaderFunctionArgs, ay as DataRouteMatch, a7 as DataStrategyFunctionArgs, a8 as DataStrategyMatch, a9 as DataStrategyResult, ab as ErrorResponse, ac as FormMethod, aJ as Future, a1 as GetScrollPositionFunction, aD as HeadersArgs, aE as HeadersFunction, aH as HtmlLinkDescriptor, ao as IDLE_BLOCKER, an as IDLE_FETCHER, am as IDLE_NAVIGATION, aI as LinkDescriptor, aF as MetaArgs, aG as MetaDescriptor, a2 as NavigationStates, az as PatchRoutesOnNavigationFunctionArgs, ae as PathParam, af as RedirectFunction, aL as Register, a6 as RevalidationState, a5 as RouterFetchOptions, a4 as RouterNavigateOptions, a3 as RouterSubscriber, ah as ShouldRevalidateFunction, ai as ShouldRevalidateFunctionArgs, aQ as UNSAFE_DataRouterContext, aR as UNSAFE_DataRouterStateContext, aa as UNSAFE_DataWithResponseInit, aP as UNSAFE_ErrorResponseImpl, aS as UNSAFE_FetchersContext, aT as UNSAFE_LocationContext, aU as UNSAFE_NavigationContext, aV as UNSAFE_RouteContext, aW as UNSAFE_ViewTransitionContext, aM as UNSAFE_createBrowserHistory, aO as UNSAFE_createRouter, aN as UNSAFE_invariant, ak as createPath, ap as data, aq as generatePath, ar as isRouteErrorResponse, as as matchPath, at as matchRoutes, al as parsePath, au as redirect, av as redirectDocument, aw as replace, ax as resolvePath, ad as unstable_MiddlewareFunction, ag as unstable_RouterContext, aK as unstable_SerializesTo, aj as unstable_createContext } from './register-DCE0tH5m.js';
 import * as React from 'react';
 import { ReactElement } from 'react';
 import { ParseOptions, SerializeOptions } from 'cookie';
 export { ParseOptions as CookieParseOptions, SerializeOptions as CookieSerializeOptions } from 'cookie';
 
+type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
+interface ServerRoute extends Route$1 {
+    children: ServerRoute[];
+    module: ServerRouteModule;
+}
+
+type OptionalCriticalCss = CriticalCss | undefined;
 /**
- * @private
+ * The output of the compiler for the server build.
  */
-declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
-    hasErrorBoundary: boolean;
-};
-declare const hydrationRouteProperties: (keyof RouteObject)[];
-interface MemoryRouterOpts {
-    /**
-     * Basename path for the application.
-     */
+interface ServerBuild {
+    entry: {
+        module: ServerEntryModule;
+    };
+    routes: ServerRouteManifest;
+    assets: AssetsManifest;
     basename?: string;
+    publicPath: string;
+    assetsBuildDirectory: string;
+    future: FutureConfig;
+    ssr: boolean;
+    unstable_getCriticalCss?: (args: {
+        pathname: string;
+    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
     /**
-     * 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$1>;
-    /**
-     * 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.
+     * @deprecated This is now done via a custom header during prerendering
      */
-    patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
+    isSpaMode: boolean;
+    prerender: string[];
+    routeDiscovery: {
+        mode: "lazy" | "initial";
+        manifestPath: string;
+    };
 }
-/**
- * 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;
+interface HandleDocumentRequestFunction {
+    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext): Promise<Response> | Response;
 }
-/**
- * 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;
+interface HandleDataRequestFunction {
+    (response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
 }
-/**
- * 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;
+interface HandleErrorFunction {
+    (error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
 }
 /**
- * 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
+ * A module that serves as the entry point for a Remix app during server
+ * rendering.
  */
-declare function Navigate({ to, replace, state, relative, }: NavigateProps): null;
+interface ServerEntryModule {
+    default: HandleDocumentRequestFunction;
+    handleDataRequest?: HandleDataRequestFunction;
+    handleError?: HandleErrorFunction;
+    streamTimeout?: number;
+}
+
+type SerializedError = {
+    message: string;
+    stack?: string;
+};
+interface FrameworkContextObject {
+    manifest: AssetsManifest;
+    routeModules: RouteModules;
+    criticalCss?: CriticalCss;
+    serverHandoffString?: string;
+    future: FutureConfig;
+    ssr: boolean;
+    isSpaMode: boolean;
+    routeDiscovery: ServerBuild["routeDiscovery"];
+    serializeError?(error: Error): SerializedError;
+    renderMeta?: {
+        didRenderScripts?: boolean;
+        streamCache?: Record<number, Promise<void> & {
+            result?: {
+                done: boolean;
+                value: string;
+            };
+            error?: unknown;
+        }>;
+    };
+}
+interface EntryContext extends FrameworkContextObject {
+    staticHandlerContext: StaticHandlerContext;
+    serverHandoffStream?: ReadableStream<Uint8Array>;
+}
+interface FutureConfig {
+    unstable_subResourceIntegrity: boolean;
+    unstable_middleware: boolean;
+}
+type CriticalCss = string | {
+    rel: "stylesheet";
+    href: string;
+};
+interface AssetsManifest {
+    entry: {
+        imports: string[];
+        module: string;
+    };
+    routes: RouteManifest<EntryRoute>;
+    url: string;
+    version: string;
+    hmr?: {
+        timestamp?: number;
+        runtime: string;
+    };
+    sri?: Record<string, string> | true;
+}
+
+interface Route$1 {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
+}
+interface EntryRoute extends Route$1 {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasClientMiddleware: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    clientActionModule: string | undefined;
+    clientLoaderModule: string | undefined;
+    clientMiddlewareModule: string | undefined;
+    hydrateFallbackModule: string | undefined;
+    parentId?: string;
+}
+declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
+declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
+declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
+
+declare const SingleFetchRedirectSymbol: unique symbol;
+declare function getTurboStreamSingleFetchDataStrategy(getRouter: () => Router$1, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, basename: string | undefined): DataStrategyFunction;
+declare function decodeViaTurboStream(body: ReadableStream<Uint8Array>, global: Window | typeof globalThis): Promise<{
+    done: Promise<undefined>;
+    value: unknown;
+}>;
+
 /**
- * @category Types
+ * The mode to use when running the server.
  */
-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;
+declare enum ServerMode {
+    Development = "development",
+    Production = "production",
+    Test = "test"
 }
+
 /**
-  Renders the matching child route of a parent route or nothing if no child route matches.
+  Resolves a URL against the current location.
 
   ```tsx
-  import { Outlet } from "react-router"
+  import { useHref } from "react-router"
 
-  export default function SomeParent() {
-    return (
-      <div>
-        <h1>Parent Content</h1>
-        <Outlet />
-      </div>
-    );
+  function SomeComponent() {
+    let href = useHref("some/where");
+    // "/resolved/some/where"
   }
   ```
 
-  @category Components
+  @category Hooks
  */
-declare function Outlet(props: OutletProps): React.ReactElement | null;
+declare function useHref(to: To, { relative }?: {
+    relative?: RelativeRoutingType;
+}): string;
 /**
- * @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;
-}
+ * Returns true if this component is a descendant of a Router, useful to ensure
+ * a component is used within a Router.
+ *
+ * @category Hooks
+ */
+declare function useInRouterContext(): boolean;
 /**
- * @category Types
+  Returns the current {@link Location}. This can be useful if you'd like to perform some side effect whenever it changes.
+
+  ```tsx
+  import * as React from 'react'
+  import { useLocation } from 'react-router'
+
+  function SomeComponent() {
+    let location = useLocation()
+
+    React.useEffect(() => {
+      // Google Analytics
+      ga('send', 'pageview')
+    }, [location]);
+
+    return (
+      // ...
+    );
+  }
+  ```
+
+  @category Hooks
  */
-interface LayoutRouteProps extends PathRouteProps {
-}
+declare function useLocation(): Location;
 /**
- * @category Types
+ * Returns the current navigation action which describes how the router came to
+ * the current location, either by a pop, push, or replace on the history stack.
+ *
+ * @category Hooks
  */
-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;
+declare function useNavigationType(): Action;
 /**
- * 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.
+ * Returns a PathMatch object if the given pattern matches the current URL.
+ * This is useful for components that need to know "active" state, e.g.
+ * `<NavLink>`.
  *
- * @category Components
+ * @category Hooks
  */
-declare function Route$1(_props: RouteProps): React.ReactElement | null;
+declare function useMatch<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null;
 /**
- * @category Types
+ * The interface for the navigate() function returned from useNavigate().
  */
-interface RouterProps {
-    basename?: string;
-    children?: React.ReactNode;
-    location: Partial<Location> | string;
-    navigationType?: Action;
-    navigator: Navigator;
-    static?: boolean;
+interface NavigateFunction {
+    (to: To, options?: NavigateOptions): void | Promise<void>;
+    (delta: number): void | Promise<void>;
 }
 /**
- * Provides location context for the rest of the app.
+  Returns a function that lets you navigate programmatically in the browser in response to user interactions or effects.
+
+  ```tsx
+  import { useNavigate } from "react-router";
+
+  function SomeComponent() {
+    let navigate = useNavigate();
+    return (
+      <button
+        onClick={() => {
+          navigate(-1);
+        }}
+      />
+    );
+  }
+  ```
+
+  It's often better to use {@link redirect} in {@link ActionFunction | actions} and {@link LoaderFunction | loaders} than this hook.
+
+  @category Hooks
+ */
+declare function useNavigate(): NavigateFunction;
+/**
+ * Returns the parent route {@link OutletProps.context | `<Outlet context>`}.
  *
- * 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 Hooks
+ */
+declare function useOutletContext<Context = unknown>(): Context;
+/**
+ * Returns the element for the child route at this level of the route
+ * hierarchy. Used internally by `<Outlet>` to render child routes.
  *
- * @category Components
+ * @category Hooks
  */
-declare function Router({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, }: RouterProps): React.ReactElement | null;
+declare function useOutlet(context?: unknown): React.ReactElement | null;
 /**
- * @category Types
+  Returns an object of key/value pairs of the dynamic params from the current URL that were matched by the routes. Child routes inherit all params from their parent routes.
+
+  ```tsx
+  import { useParams } from "react-router"
+
+  function SomeComponent() {
+    let params = useParams()
+    params.postId
+  }
+  ```
+
+  Assuming a route pattern like `/posts/:postId` is matched by `/posts/123` then `params.postId` will be `"123"`.
+
+  @category Hooks
  */
-interface RoutesProps {
-    /**
-     * Nested {@link Route} elements
-     */
-    children?: React.ReactNode;
-    /**
-     * The location to match against. Defaults to the current location.
-     */
-    location?: Partial<Location> | string;
-}
+declare function useParams<ParamsOrKey extends string | Record<string, string | undefined> = string>(): Readonly<[
+    ParamsOrKey
+] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>>;
 /**
- 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.
+  Resolves the pathname of the given `to` value against the current location. Similar to {@link useHref}, but returns a {@link Path} instead of a string.
 
- ```tsx
- import { Routes, Route } from "react-router"
+  ```tsx
+  import { useResolvedPath } from "react-router"
 
-<Routes>
-  <Route index element={<StepOne />} />
-  <Route path="step-2" element={<StepTwo />} />
-  <Route path="step-3" element={<StepThree />}>
-</Routes>
- ```
+  function SomeComponent() {
+    // if the user is at /dashboard/profile
+    let path = useResolvedPath("../accounts")
+    path.pathname // "/dashboard/accounts"
+    path.search // ""
+    path.hash // ""
+  }
+  ```
 
- @category Components
+  @category Hooks
  */
-declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
-interface AwaitResolveRenderFunction<Resolve = any> {
-    (data: Awaited<Resolve>): React.ReactNode;
-}
+declare function useResolvedPath(to: To, { relative }?: {
+    relative?: RelativeRoutingType;
+}): Path;
 /**
- * @category Types
+  Hook version of {@link Routes | `<Routes>`} that uses objects instead of components. These objects have the same properties as the component props.
+
+  The return value of `useRoutes` is either a valid React element you can use to render the route tree, or `null` if nothing matched.
+
+  ```tsx
+  import * as React from "react";
+  import { useRoutes } from "react-router";
+
+  function App() {
+    let element = useRoutes([
+      {
+        path: "/",
+        element: <Dashboard />,
+        children: [
+          {
+            path: "messages",
+            element: <DashboardMessages />,
+          },
+          { path: "tasks", element: <DashboardTasks /> },
+        ],
+      },
+      { path: "team", element: <AboutPage /> },
+    ]);
+
+    return element;
+  }
+  ```
+
+ @category Hooks
  */
-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;
-}
+declare function useRoutes(routes: RouteObject[], locationArg?: Partial<Location> | string): React.ReactElement | null;
 /**
-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>
-  );
-}
-```
+  Returns the current navigation, defaulting to an "idle" navigation when no navigation is in progress. You can use this to render pending UI (like a global spinner) or read FormData from a form navigation.
 
-**Note:** `<Await>` expects to be rendered inside of a `<React.Suspense>`
+  ```tsx
+  import { useNavigation } from "react-router"
 
-@category Components
+  function SomeComponent() {
+    let navigation = useNavigation();
+    navigation.state
+    navigation.formData
+    // etc.
+  }
+  ```
 
-*/
-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
+  @category Hooks
  */
-declare let createRoutesFromElements: typeof createRoutesFromChildren;
+declare function useNavigation(): Navigation;
 /**
- * Renders the result of `matchRoutes()` into a React element.
- *
- * @category Utils
- */
-declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
+  Revalidate the data on the page for reasons outside of normal data mutations like window focus or polling on an interval.
 
-type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
-interface ServerRoute extends Route {
-    children: ServerRoute[];
-    module: ServerRouteModule;
-}
+  ```tsx
+  import { useRevalidator } from "react-router";
 
-type OptionalCriticalCss = CriticalCss | undefined;
-/**
- * The output of the compiler for the server build.
- */
-interface ServerBuild {
-    entry: {
-        module: ServerEntryModule;
-    };
-    routes: ServerRouteManifest;
-    assets: AssetsManifest;
-    basename?: string;
-    publicPath: string;
-    assetsBuildDirectory: string;
-    future: FutureConfig;
-    ssr: boolean;
-    unstable_getCriticalCss?: (args: {
-        pathname: string;
-    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
-    /**
-     * @deprecated This is now done via a custom header during prerendering
-     */
-    isSpaMode: boolean;
-    prerender: string[];
-    routeDiscovery: {
-        mode: "lazy" | "initial";
-        manifestPath: string;
-    };
-}
-interface HandleDocumentRequestFunction {
-    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext): Promise<Response> | Response;
-}
-interface HandleDataRequestFunction {
-    (response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
-}
-interface HandleErrorFunction {
-    (error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
-}
-/**
- * A module that serves as the entry point for a Remix app during server
- * rendering.
- */
-interface ServerEntryModule {
-    default: HandleDocumentRequestFunction;
-    handleDataRequest?: HandleDataRequestFunction;
-    handleError?: HandleErrorFunction;
-    streamTimeout?: number;
-}
+  function WindowFocusRevalidator() {
+    const revalidator = useRevalidator();
 
-type SerializedError = {
-    message: string;
-    stack?: string;
-};
-interface FrameworkContextObject {
-    manifest: AssetsManifest;
-    routeModules: RouteModules;
-    criticalCss?: CriticalCss;
-    serverHandoffString?: string;
-    future: FutureConfig;
-    ssr: boolean;
-    isSpaMode: boolean;
-    routeDiscovery: ServerBuild["routeDiscovery"];
-    serializeError?(error: Error): SerializedError;
-    renderMeta?: {
-        didRenderScripts?: boolean;
-        streamCache?: Record<number, Promise<void> & {
-            result?: {
-                done: boolean;
-                value: string;
-            };
-            error?: unknown;
-        }>;
-    };
-}
-interface EntryContext extends FrameworkContextObject {
-    staticHandlerContext: StaticHandlerContext;
-    serverHandoffStream?: ReadableStream<Uint8Array>;
-}
-interface FutureConfig {
-    unstable_subResourceIntegrity: boolean;
-    unstable_middleware: boolean;
-}
-type CriticalCss = string | {
-    rel: "stylesheet";
-    href: string;
-};
-interface AssetsManifest {
-    entry: {
-        imports: string[];
-        module: string;
-    };
-    routes: RouteManifest<EntryRoute>;
-    url: string;
-    version: string;
-    hmr?: {
-        timestamp?: number;
-        runtime: string;
-    };
-    sri?: Record<string, string> | true;
-}
+    useFakeWindowFocus(() => {
+      revalidator.revalidate();
+    });
 
-interface Route {
-    index?: boolean;
-    caseSensitive?: boolean;
-    id: string;
-    parentId?: string;
-    path?: string;
-}
-interface EntryRoute extends Route {
-    hasAction: boolean;
-    hasLoader: boolean;
-    hasClientAction: boolean;
-    hasClientLoader: boolean;
-    hasClientMiddleware: boolean;
-    hasErrorBoundary: boolean;
-    imports?: string[];
-    css?: string[];
-    module: string;
-    clientActionModule: string | undefined;
-    clientLoaderModule: string | undefined;
-    clientMiddlewareModule: string | undefined;
-    hydrateFallbackModule: string | undefined;
-    parentId?: string;
-}
-declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
-declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
-declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
+    return (
+      <div hidden={revalidator.state === "idle"}>
+        Revalidating...
+      </div>
+    );
+  }
+  ```
 
-declare const SingleFetchRedirectSymbol: unique symbol;
-declare function getTurboStreamSingleFetchDataStrategy(getRouter: () => Router$1, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, basename: string | undefined): DataStrategyFunction;
-declare function decodeViaTurboStream(body: ReadableStream<Uint8Array>, global: Window | typeof globalThis): Promise<{
-    done: Promise<undefined>;
-    value: unknown;
-}>;
+  Note that page data is already revalidated automatically after actions. If you find yourself using this for normal CRUD operations on your data in response to user interactions, you're probably not taking advantage of the other APIs like {@link useFetcher}, {@link Form}, {@link useSubmit} that do this automatically.
 
+  @category Hooks
+ */
+declare function useRevalidator(): {
+    revalidate: () => Promise<void>;
+    state: Router$1["state"]["revalidation"];
+};
 /**
- * The mode to use when running the server.
+ * Returns the active route matches, useful for accessing loaderData for
+ * parent/child routes or the route "handle" property
+ *
+ * @category Hooks
  */
-declare enum ServerMode {
-    Development = "development",
-    Production = "production",
-    Test = "test"
-}
-
+declare function useMatches(): UIMatch[];
 /**
-  Resolves a URL against the current location.
+  Returns the data from the closest route {@link LoaderFunction | loader} or {@link ClientLoaderFunction | client loader}.
 
   ```tsx
-  import { useHref } from "react-router"
+  import { useLoaderData } from "react-router"
 
-  function SomeComponent() {
-    let href = useHref("some/where");
-    // "/resolved/some/where"
+  export async function loader() {
+    return await fakeDb.invoices.findAll();
+  }
+
+  export default function Invoices() {
+    let invoices = useLoaderData<typeof loader>();
+    // ...
   }
   ```
 
   @category Hooks
  */
-declare function useHref(to: To, { relative }?: {
-    relative?: RelativeRoutingType;
-}): string;
-/**
- * Returns true if this component is a descendant of a Router, useful to ensure
- * a component is used within a Router.
- *
- * @category Hooks
- */
-declare function useInRouterContext(): boolean;
+declare function useLoaderData<T = any>(): SerializeFrom<T>;
 /**
-  Returns the current {@link Location}. This can be useful if you'd like to perform some side effect whenever it changes.
+  Returns the loader data for a given route by route ID.
 
   ```tsx
-  import * as React from 'react'
-  import { useLocation } from 'react-router'
+  import { useRouteLoaderData } from "react-router";
 
   function SomeComponent() {
-    let location = useLocation()
+    const { user } = useRouteLoaderData("root");
+  }
+  ```
 
-    React.useEffect(() => {
-      // Google Analytics
-      ga('send', 'pageview')
-    }, [location]);
+  Route IDs are created automatically. They are simply the path of the route file relative to the app folder without the extension.
 
-    return (
-      // ...
-    );
-  }
+  | Route Filename             | Route ID             |
+  | -------------------------- | -------------------- |
+  | `app/root.tsx`             | `"root"`             |
+  | `app/routes/teams.tsx`     | `"routes/teams"`     |
+  | `app/whatever/teams.$id.tsx` | `"whatever/teams.$id"` |
+
+  If you created an ID manually, you can use that instead:
+
+  ```tsx
+  route("/", "containers/app.tsx", { id: "app" }})
   ```
 
   @category Hooks
  */
-declare function useLocation(): Location;
+declare function useRouteLoaderData<T = any>(routeId: string): SerializeFrom<T> | undefined;
 /**
- * Returns the current navigation action which describes how the router came to
- * the current location, either by a pop, push, or replace on the history stack.
- *
- * @category Hooks
+  Returns the action data from the most recent POST navigation form submission or `undefined` if there hasn't been one.
+
+  ```tsx
+  import { Form, useActionData } from "react-router"
+
+  export async function action({ request }) {
+    const body = await request.formData()
+    const name = body.get("visitorsName")
+    return { message: `Hello, ${name}` }
+  }
+
+  export default function Invoices() {
+    const data = useActionData()
+    return (
+      <Form method="post">
+        <input type="text" name="visitorsName" />
+        {data ? data.message : "Waiting..."}
+      </Form>
+    )
+  }
+  ```
+
+  @category Hooks
  */
-declare function useNavigationType(): Action;
+declare function useActionData<T = any>(): SerializeFrom<T> | undefined;
 /**
- * Returns a PathMatch object if the given pattern matches the current URL.
- * This is useful for components that need to know "active" state, e.g.
- * `<NavLink>`.
- *
- * @category Hooks
+  Accesses the error thrown during an {@link ActionFunction | action}, {@link LoaderFunction | loader}, or component render to be used in a route module Error Boundary.
+
+  ```tsx
+  export function ErrorBoundary() {
+    const error = useRouteError();
+    return <div>{error.message}</div>;
+  }
+  ```
+
+  @category Hooks
  */
-declare function useMatch<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null;
+declare function useRouteError(): unknown;
 /**
- * The interface for the navigate() function returned from useNavigate().
+  Returns the resolved promise value from the closest {@link Await | `<Await>`}.
+
+  ```tsx
+  function SomeDescendant() {
+    const value = useAsyncValue();
+    // ...
+  }
+
+  // somewhere in your app
+  <Await resolve={somePromise}>
+    <SomeDescendant />
+  </Await>
+  ```
+
+  @category Hooks
  */
-interface NavigateFunction {
-    (to: To, options?: NavigateOptions): void | Promise<void>;
-    (delta: number): void | Promise<void>;
-}
+declare function useAsyncValue(): unknown;
 /**
-  Returns a function that lets you navigate programmatically in the browser in response to user interactions or effects.
+  Returns the rejection value from the closest {@link Await | `<Await>`}.
 
   ```tsx
-  import { useNavigate } from "react-router";
+  import { Await, useAsyncError } from "react-router"
 
-  function SomeComponent() {
-    let navigate = useNavigate();
+  function ErrorElement() {
+    const error = useAsyncError();
     return (
-      <button
-        onClick={() => {
-          navigate(-1);
-        }}
-      />
+      <p>Uh Oh, something went wrong! {error.message}</p>
     );
   }
-  ```
 
-  It's often better to use {@link redirect} in {@link ActionFunction | actions} and {@link LoaderFunction | loaders} than this hook.
+  // somewhere in your app
+  <Await
+    resolve={promiseThatRejects}
+    errorElement={<ErrorElement />}
+  />
+  ```
 
   @category Hooks
  */
-declare function useNavigate(): NavigateFunction;
+declare function useAsyncError(): unknown;
 /**
- * Returns the parent route {@link OutletProps.context | `<Outlet context>`}.
+ * Allow the application to block navigations within the SPA and present the
+ * user a confirmation dialog to confirm the navigation.  Mostly used to avoid
+ * using half-filled form data.  This does not handle hard-reloads or
+ * cross-origin navigations.
  *
  * @category Hooks
  */
-declare function useOutletContext<Context = unknown>(): Context;
+declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
+
+/**
+ * @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$1>;
+    /**
+     * 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;
+}
 /**
- * Returns the element for the child route at this level of the route
- * hierarchy. Used internally by `<Outlet>` to render child routes.
+ * A `<Router>` that stores all entries in memory.
  *
- * @category Hooks
- */
-declare function useOutlet(context?: unknown): React.ReactElement | null;
-/**
-  Returns an object of key/value pairs of the dynamic params from the current URL that were matched by the routes. Child routes inherit all params from their parent routes.
-
-  ```tsx
-  import { useParams } from "react-router"
-
-  function SomeComponent() {
-    let params = useParams()
-    params.postId
-  }
-  ```
-
-  Assuming a route pattern like `/posts/:postId` is matched by `/posts/123` then `params.postId` will be `"123"`.
-
-  @category Hooks
+ * @category Component Routers
  */
-declare function useParams<ParamsOrKey extends string | Record<string, string | undefined> = string>(): Readonly<[
-    ParamsOrKey
-] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>>;
+declare function MemoryRouter({ basename, children, initialEntries, initialIndex, }: MemoryRouterProps): React.ReactElement;
 /**
-  Resolves the pathname of the given `to` value against the current location. Similar to {@link useHref}, but returns a {@link Path} instead of a string.
-
-  ```tsx
-  import { useResolvedPath } from "react-router"
-
-  function SomeComponent() {
-    // if the user is at /dashboard/profile
-    let path = useResolvedPath("../accounts")
-    path.pathname // "/dashboard/accounts"
-    path.search // ""
-    path.hash // ""
-  }
-  ```
-
-  @category Hooks
+ * @category Types
  */
-declare function useResolvedPath(to: To, { relative }?: {
+interface NavigateProps {
+    to: To;
+    replace?: boolean;
+    state?: any;
     relative?: RelativeRoutingType;
-}): Path;
+}
 /**
-  Hook version of {@link Routes | `<Routes>`} that uses objects instead of components. These objects have the same properties as the component props.
-
-  The return value of `useRoutes` is either a valid React element you can use to render the route tree, or `null` if nothing matched.
-
-  ```tsx
-  import * as React from "react";
-  import { useRoutes } from "react-router";
-
-  function App() {
-    let element = useRoutes([
-      {
-        path: "/",
-        element: <Dashboard />,
-        children: [
-          {
-            path: "messages",
-            element: <DashboardMessages />,
-          },
-          { path: "tasks", element: <DashboardTasks /> },
-        ],
-      },
-      { path: "team", element: <AboutPage /> },
-    ]);
-
-    return element;
-  }
-  ```
-
- @category Hooks
+ * 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 useRoutes(routes: RouteObject[], locationArg?: Partial<Location> | string): React.ReactElement | null;
+declare function Navigate({ to, replace, state, relative, }: NavigateProps): null;
 /**
-  Returns the current navigation, defaulting to an "idle" navigation when no navigation is in progress. You can use this to render pending UI (like a global spinner) or read FormData from a form navigation.
-
-  ```tsx
-  import { useNavigation } from "react-router"
-
-  function SomeComponent() {
-    let navigation = useNavigation();
-    navigation.state
-    navigation.formData
-    // etc.
-  }
-  ```
-
-  @category Hooks
+ * @category Types
  */
-declare function useNavigation(): Navigation;
+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;
+}
 /**
-  Revalidate the data on the page for reasons outside of normal data mutations like window focus or polling on an interval.
+  Renders the matching child route of a parent route or nothing if no child route matches.
 
   ```tsx
-  import { useRevalidator } from "react-router";
-
-  function WindowFocusRevalidator() {
-    const revalidator = useRevalidator();
-
-    useFakeWindowFocus(() => {
-      revalidator.revalidate();
-    });
+  import { Outlet } from "react-router"
 
+  export default function SomeParent() {
     return (
-      <div hidden={revalidator.state === "idle"}>
-        Revalidating...
+      <div>
+        <h1>Parent Content</h1>
+        <Outlet />
       </div>
     );
   }
   ```
 
-  Note that page data is already revalidated automatically after actions. If you find yourself using this for normal CRUD operations on your data in response to user interactions, you're probably not taking advantage of the other APIs like {@link useFetcher}, {@link Form}, {@link useSubmit} that do this automatically.
-
-  @category Hooks
+  @category Components
  */
-declare function useRevalidator(): {
-    revalidate: () => Promise<void>;
-    state: Router$1["state"]["revalidation"];
-};
+declare function Outlet(props: OutletProps): React.ReactElement | null;
 /**
- * Returns the active route matches, useful for accessing loaderData for
- * parent/child routes or the route "handle" property
+ * @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 Hooks
+ * @category Components
  */
-declare function useMatches(): UIMatch[];
+declare function Route(_props: RouteProps): React.ReactElement | null;
 /**
-  Returns the data from the closest route {@link LoaderFunction | loader} or {@link ClientLoaderFunction | client loader}.
-
-  ```tsx
-  import { useLoaderData } from "react-router"
-
-  export async function loader() {
-    return await fakeDb.invoices.findAll();
-  }
-
-  export default function Invoices() {
-    let invoices = useLoaderData<typeof loader>();
-    // ...
-  }
-  ```
-
-  @category Hooks
+ * @category Types
  */
-declare function useLoaderData<T = any>(): SerializeFrom<T>;
+interface RouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    location: Partial<Location> | string;
+    navigationType?: Action;
+    navigator: Navigator;
+    static?: boolean;
+}
 /**
-  Returns the loader data for a given route by route ID.
-
-  ```tsx
-  import { useRouteLoaderData } from "react-router";
-
-  function SomeComponent() {
-    const { user } = useRouteLoaderData("root");
-  }
-  ```
-
-  Route IDs are created automatically. They are simply the path of the route file relative to the app folder without the extension.
-
-  | Route Filename             | Route ID             |
-  | -------------------------- | -------------------- |
-  | `app/root.tsx`             | `"root"`             |
-  | `app/routes/teams.tsx`     | `"routes/teams"`     |
-  | `app/whatever/teams.$id.tsx` | `"whatever/teams.$id"` |
-
-  If you created an ID manually, you can use that instead:
-
-  ```tsx
-  route("/", "containers/app.tsx", { id: "app" }})
-  ```
-
-  @category Hooks
+ * 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 useRouteLoaderData<T = any>(routeId: string): SerializeFrom<T> | undefined;
+declare function Router({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, }: RouterProps): React.ReactElement | null;
 /**
-  Returns the action data from the most recent POST navigation form submission or `undefined` if there hasn't been one.
-
-  ```tsx
-  import { Form, useActionData } from "react-router"
+ * @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.
 
-  export async function action({ request }) {
-    const body = await request.formData()
-    const name = body.get("visitorsName")
-    return { message: `Hello, ${name}` }
-  }
+ ```tsx
+ import { Routes, Route } from "react-router"
 
-  export default function Invoices() {
-    const data = useActionData()
-    return (
-      <Form method="post">
-        <input type="text" name="visitorsName" />
-        {data ? data.message : "Waiting..."}
-      </Form>
-    )
-  }
-  ```
+<Routes>
+  <Route index element={<StepOne />} />
+  <Route path="step-2" element={<StepTwo />} />
+  <Route path="step-3" element={<StepThree />}>
+</Routes>
+ ```
 
-  @category Hooks
+ @category Components
  */
-declare function useActionData<T = any>(): SerializeFrom<T> | undefined;
+declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
+interface AwaitResolveRenderFunction<Resolve = any> {
+    (data: Awaited<Resolve>): React.ReactNode;
+}
 /**
-  Accesses the error thrown during an {@link ActionFunction | action}, {@link LoaderFunction | loader}, or component render to be used in a route module Error Boundary.
-
-  ```tsx
-  export function ErrorBoundary() {
-    const error = useRouteError();
-    return <div>{error.message}</div>;
-  }
-  ```
-
-  @category Hooks
+ * @category Types
  */
-declare function useRouteError(): unknown;
+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;
+}
 /**
-  Returns the resolved promise value from the closest {@link Await | `<Await>`}.
-
-  ```tsx
-  function SomeDescendant() {
-    const value = useAsyncValue();
-    // ...
-  }
+Used to render promise values with automatic error handling.
 
-  // somewhere in your app
-  <Await resolve={somePromise}>
-    <SomeDescendant />
-  </Await>
-  ```
+```tsx
+import { Await, useLoaderData } from "react-router";
 
-  @category Hooks
- */
-declare function useAsyncValue(): unknown;
-/**
-  Returns the rejection value from the closest {@link Await | `<Await>`}.
+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 }
+}
 
-  ```tsx
-  import { Await, useAsyncError } from "react-router"
+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>
+  );
+}
+```
 
-  function ErrorElement() {
-    const error = useAsyncError();
-    return (
-      <p>Uh Oh, something went wrong! {error.message}</p>
-    );
-  }
+**Note:** `<Await>` expects to be rendered inside of a `<React.Suspense>`
 
-  // somewhere in your app
-  <Await
-    resolve={promiseThatRejects}
-    errorElement={<ErrorElement />}
-  />
-  ```
+@category Components
 
-  @category Hooks
+*/
+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 useAsyncError(): unknown;
+declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[];
 /**
- * Allow the application to block navigations within the SPA and present the
- * user a confirmation dialog to confirm the navigation.  Mostly used to avoid
- * using half-filled form data.  This does not handle hard-reloads or
- * cross-origin navigations.
+ * 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 Hooks
+ * @category Utils
  */
-declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
+declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
+type RouteComponentType = React.ComponentType<{
+    params: ReturnType<typeof useParams>;
+    loaderData: ReturnType<typeof useLoaderData>;
+    actionData: ReturnType<typeof useActionData>;
+    matches: ReturnType<typeof useMatches>;
+}>;
+declare function withComponentProps(Component: RouteComponentType): () => React.ReactElement<{
+    params: Readonly<Partial<string | Record<string, string | undefined>>>;
+    loaderData: unknown;
+    actionData: unknown;
+    matches: UIMatch<unknown, unknown>[];
+}, string | React.JSXElementConstructor<any>>;
+type HydrateFallbackType = React.ComponentType<{
+    params: ReturnType<typeof useParams>;
+    loaderData: ReturnType<typeof useLoaderData>;
+    actionData: ReturnType<typeof useActionData>;
+}>;
+declare function withHydrateFallbackProps(HydrateFallback: HydrateFallbackType): () => React.ReactElement<{
+    params: Readonly<Partial<string | Record<string, string | undefined>>>;
+    loaderData: unknown;
+    actionData: unknown;
+}, string | React.JSXElementConstructor<any>>;
+type ErrorBoundaryType = React.ComponentType<{
+    params: ReturnType<typeof useParams>;
+    loaderData: ReturnType<typeof useLoaderData>;
+    actionData: ReturnType<typeof useActionData>;
+    error: ReturnType<typeof useRouteError>;
+}>;
+declare function withErrorBoundaryProps(ErrorBoundary: ErrorBoundaryType): () => React.ReactElement<{
+    params: Readonly<Partial<string | Record<string, string | undefined>>>;
+    loaderData: unknown;
+    actionData: unknown;
+    error: unknown;
+}, string | React.JSXElementConstructor<any>>;
 
 type ParamKeyValuePair = [string, string];
 type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
@@ -2172,23 +2206,9 @@ interface ServerRouterProps {
 declare function ServerRouter({ context, url, nonce, }: ServerRouterProps): ReactElement;
 
 interface StubRouteExtensions {
-    Component?: React.ComponentType<{
-        params: ReturnType<typeof useParams>;
-        loaderData: ReturnType<typeof useLoaderData>;
-        actionData: ReturnType<typeof useActionData>;
-        matches: ReturnType<typeof useMatches>;
-    }>;
-    HydrateFallback?: React.ComponentType<{
-        params: ReturnType<typeof useParams>;
-        loaderData: ReturnType<typeof useLoaderData>;
-        actionData: ReturnType<typeof useActionData>;
-    }>;
-    ErrorBoundary?: React.ComponentType<{
-        params: ReturnType<typeof useParams>;
-        loaderData: ReturnType<typeof useLoaderData>;
-        actionData: ReturnType<typeof useActionData>;
-        error: ReturnType<typeof useRouteError>;
-    }>;
+    Component?: RouteComponentType;
+    HydrateFallback?: HydrateFallbackType;
+    ErrorBoundary?: ErrorBoundaryType;
     loader?: LoaderFunction;
     action?: ActionFunction;
     children?: StubRouteObject[];
@@ -2528,4 +2548,4 @@ declare function getHydrationData(state: {
     hasHydrateFallback: boolean;
 }, location: Path, basename: string | undefined, isSpaMode: boolean): HydrationState;
 
-export { ActionFunction, ActionFunctionArgs, AppLoadContext, Await, type AwaitProps, Blocker, BlockerFunction, BrowserRouter, type BrowserRouterProps, ClientLoaderFunction, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, type DOMRouterOpts, DataRouteObject, Router$1 as DataRouter, DataStrategyFunction, type EntryContext, Fetcher, type FetcherFormProps, type FetcherSubmitFunction, type FetcherSubmitOptions, type FetcherWithComponents, type FlashSessionData, Form, FormEncType, type FormProps, GetScrollRestorationKeyFunction, HTMLFormMethod, type HandleDataRequestFunction, type HandleDocumentRequestFunction, type HandleErrorFunction, HashRouter, type HashRouterProps, type HistoryRouterProps, HydrationState, IndexRouteObject, type IndexRouteProps, InitialEntry, type IsCookieFunction, type IsSessionFunction, type LayoutRouteProps, LazyRouteFunction, Link, type LinkProps, Links, LinksFunction, LoaderFunction, LoaderFunctionArgs, Location, MemoryRouter, type MemoryRouterOpts, type MemoryRouterProps, Meta, MetaFunction, NavLink, type NavLinkProps, type NavLinkRenderProps, Navigate, type NavigateFunction, NavigateOptions, type NavigateProps, Navigation, Action as NavigationType, Navigator, NonIndexRouteObject, Outlet, type OutletProps, PageLinkDescriptor, type ParamKeyValuePair, ParamParseKey, Params, PatchRoutesOnNavigationFunction, Path, PathMatch, PathPattern, type PathRouteProps, PrefetchPageLinks, RelativeRoutingType, type RequestHandler, Route$1 as Route, RouteMatch, RouteObject, type RouteProps, Router, RouterInit, type RouterProps, RouterProvider, type RouterProviderProps, RouterState, Routes, type RoutesProps, type RoutesTestStubProps, Scripts, type ScriptsProps, ScrollRestoration, type ScrollRestorationProps, type ServerBuild, type ServerEntryModule, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, type SetURLSearchParams, StaticHandler, StaticHandlerContext, StaticRouter, type StaticRouterProps, StaticRouterProvider, type StaticRouterProviderProps, type SubmitFunction, type SubmitOptions, type SubmitTarget, To, UIMatch, type AssetsManifest as UNSAFE_AssetsManifest, FrameworkContext as UNSAFE_FrameworkContext, MiddlewareEnabled as UNSAFE_MiddlewareEnabled, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, createClientRoutes as UNSAFE_createClientRoutes, createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getHydrationData as UNSAFE_getHydrationData, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy, hydrationRouteProperties as UNSAFE_hydrationRouteProperties, mapRouteProperties as UNSAFE_mapRouteProperties, shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, useScrollRestoration as UNSAFE_useScrollRestoration, type URLSearchParamsInit, createBrowserRouter, createCookie, createCookieSessionStorage, createHashRouter, createMemoryRouter, createMemorySessionStorage, createRequestHandler, createRoutesFromChildren, createRoutesFromElements, createRoutesStub, createSearchParams, createSession, createSessionStorage, createStaticHandler, createStaticRouter, href, isCookie, isSession, renderMatches, HistoryRouter as unstable_HistoryRouter, unstable_InitialContext, unstable_RouterContextProvider, setDevServerHooks as unstable_setDevServerHooks, usePrompt as unstable_usePrompt, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, useViewTransitionState };
+export { ActionFunction, ActionFunctionArgs, AppLoadContext, Await, type AwaitProps, Blocker, BlockerFunction, BrowserRouter, type BrowserRouterProps, ClientLoaderFunction, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, type DOMRouterOpts, DataRouteObject, Router$1 as DataRouter, DataStrategyFunction, type EntryContext, Fetcher, type FetcherFormProps, type FetcherSubmitFunction, type FetcherSubmitOptions, type FetcherWithComponents, type FlashSessionData, Form, FormEncType, type FormProps, GetScrollRestorationKeyFunction, HTMLFormMethod, type HandleDataRequestFunction, type HandleDocumentRequestFunction, type HandleErrorFunction, HashRouter, type HashRouterProps, type HistoryRouterProps, HydrationState, IndexRouteObject, type IndexRouteProps, InitialEntry, type IsCookieFunction, type IsSessionFunction, type LayoutRouteProps, LazyRouteFunction, Link, type LinkProps, Links, LinksFunction, LoaderFunction, LoaderFunctionArgs, Location, MemoryRouter, type MemoryRouterOpts, type MemoryRouterProps, Meta, MetaFunction, NavLink, type NavLinkProps, type NavLinkRenderProps, Navigate, type NavigateFunction, NavigateOptions, type NavigateProps, Navigation, Action as NavigationType, Navigator, NonIndexRouteObject, Outlet, type OutletProps, PageLinkDescriptor, type ParamKeyValuePair, ParamParseKey, Params, PatchRoutesOnNavigationFunction, Path, PathMatch, PathPattern, type PathRouteProps, PrefetchPageLinks, RelativeRoutingType, type RequestHandler, Route, RouteMatch, RouteObject, type RouteProps, Router, RouterInit, type RouterProps, RouterProvider, type RouterProviderProps, RouterState, Routes, type RoutesProps, type RoutesTestStubProps, Scripts, type ScriptsProps, ScrollRestoration, type ScrollRestorationProps, type ServerBuild, type ServerEntryModule, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, type SetURLSearchParams, StaticHandler, StaticHandlerContext, StaticRouter, type StaticRouterProps, StaticRouterProvider, type StaticRouterProviderProps, type SubmitFunction, type SubmitOptions, type SubmitTarget, To, UIMatch, type AssetsManifest as UNSAFE_AssetsManifest, FrameworkContext as UNSAFE_FrameworkContext, MiddlewareEnabled as UNSAFE_MiddlewareEnabled, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, createClientRoutes as UNSAFE_createClientRoutes, createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getHydrationData as UNSAFE_getHydrationData, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy, hydrationRouteProperties as UNSAFE_hydrationRouteProperties, mapRouteProperties as UNSAFE_mapRouteProperties, shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, useScrollRestoration as UNSAFE_useScrollRestoration, withComponentProps as UNSAFE_withComponentProps, withErrorBoundaryProps as UNSAFE_withErrorBoundaryProps, withHydrateFallbackProps as UNSAFE_withHydrateFallbackProps, type URLSearchParamsInit, createBrowserRouter, createCookie, createCookieSessionStorage, createHashRouter, createMemoryRouter, createMemorySessionStorage, createRequestHandler, createRoutesFromChildren, createRoutesFromElements, createRoutesStub, createSearchParams, createSession, createSessionStorage, createStaticHandler, createStaticRouter, href, isCookie, isSession, renderMatches, HistoryRouter as unstable_HistoryRouter, unstable_InitialContext, unstable_RouterContextProvider, setDevServerHooks as unstable_setDevServerHooks, usePrompt as unstable_usePrompt, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, useViewTransitionState };