react-router 7.7.0 → 7.7.1

package/dist/development/index.d.ts

@@ -1,7 +1,7 @@
-import { d as Router, e as RouteModules, D as DataStrategyFunction, T as To, f as NavigateOptions, B as BlockerFunction, g as Blocker, h as SerializeFrom, i as RelativeRoutingType, a as Location, j as ParamParseKey, k as Path, l as PathPattern, m as PathMatch, U as UIMatch, n as Navigation, A as Action, o as Params, p as RouteObject, I as InitialEntry, H as HydrationState, q as IndexRouteObject, r as LoaderFunction, s as ActionFunction, t as MetaFunction, v as LinksFunction, w as NonIndexRouteObject, x as AppLoadContext, y as unstable_RouterContextProvider, z as MiddlewareEnabled, E as unstable_InitialContext, F as Equal, J as ClientActionFunction, K as ClientLoaderFunction, O as HeadersFunction, Q as ShouldRevalidateFunction, V as RouterInit, W as RouterState, X as PatchRoutesOnNavigationFunction, Y as DataRouteObject } from './routeModules-g5PTiDfO.js';
-export { a7 as ActionFunctionArgs, aG as ClientActionFunctionArgs, aH as ClientLoaderFunctionArgs, aC as DataRouteMatch, a8 as DataStrategyFunctionArgs, a9 as DataStrategyMatch, aa as DataStrategyResult, ac as ErrorResponse, a1 as Fetcher, ad as FormEncType, ae as FormMethod, aM as Future, _ as GetScrollPositionFunction, $ as GetScrollRestorationKeyFunction, af as HTMLFormMethod, aI as HeadersArgs, aL as HtmlLinkDescriptor, as as IDLE_BLOCKER, ar as IDLE_FETCHER, aq as IDLE_NAVIGATION, ag as LazyRouteFunction, L as LinkDescriptor, ah as LoaderFunctionArgs, aJ as MetaArgs, M as MetaDescriptor, a2 as NavigationStates, aD as Navigator, aK as PageLinkDescriptor, aE as PatchRoutesOnNavigationFunctionArgs, aj as PathParam, ak as RedirectFunction, a6 as RevalidationState, aF as RouteMatch, a5 as RouterFetchOptions, a4 as RouterNavigateOptions, a3 as RouterSubscriber, am as ShouldRevalidateFunctionArgs, Z as StaticHandler, a0 as StaticHandlerContext, aS as UNSAFE_DataRouterContext, aT as UNSAFE_DataRouterStateContext, ab as UNSAFE_DataWithResponseInit, aR as UNSAFE_ErrorResponseImpl, aU as UNSAFE_FetchersContext, aV as UNSAFE_LocationContext, aW as UNSAFE_NavigationContext, aX as UNSAFE_RouteContext, aY as UNSAFE_ViewTransitionContext, aO as UNSAFE_createBrowserHistory, aQ as UNSAFE_createRouter, aP as UNSAFE_invariant, ao as createPath, at as data, au as generatePath, av as isRouteErrorResponse, aw as matchPath, ax as matchRoutes, ap as parsePath, ay as redirect, az as redirectDocument, aA as replace, aB as resolvePath, ai as unstable_MiddlewareFunction, al as unstable_RouterContext, aN as unstable_SerializesTo, an as unstable_createContext } from './routeModules-g5PTiDfO.js';
-import { A as AssetsManifest, E as EntryContext, F as FutureConfig, R as RouteComponentType, H as HydrateFallbackType, a as ErrorBoundaryType, S as ServerBuild } from './index-react-server-client-kY8DvDF3.js';
-export { h as Await, b as AwaitProps, V as BrowserRouter, B as BrowserRouterProps, D as DOMRouterOpts, y as FetcherFormProps, K as FetcherSubmitFunction, a9 as FetcherSubmitOptions, Q as FetcherWithComponents, _ as Form, z as FormProps, aq as HandleDataRequestFunction, ar as HandleDocumentRequestFunction, as as HandleErrorFunction, W as HashRouter, t as HashRouterProps, u as HistoryRouterProps, I as IndexRouteProps, L as LayoutRouteProps, X as Link, v as LinkProps, am as Links, i as MemoryRouter, M as MemoryRouterOpts, c as MemoryRouterProps, al as Meta, Z as NavLink, w as NavLinkProps, x as NavLinkRenderProps, j as Navigate, N as NavigateProps, k as Outlet, O as OutletProps, aa as ParamKeyValuePair, P as PathRouteProps, ao as PrefetchPageLinks, l as Route, d as RouteProps, m as Router, e as RouterProps, n as RouterProvider, f as RouterProviderProps, o as Routes, g as RoutesProps, an as Scripts, ap as ScriptsProps, $ as ScrollRestoration, C as ScrollRestorationProps, at as ServerEntryModule, G as SetURLSearchParams, aj as StaticRouter, af as StaticRouterProps, ak as StaticRouterProvider, ag as StaticRouterProviderProps, J as SubmitFunction, ab as SubmitOptions, ad as SubmitTarget, aC as UNSAFE_FrameworkContext, aw as UNSAFE_WithComponentProps, aA as UNSAFE_WithErrorBoundaryProps, ay as UNSAFE_WithHydrateFallbackProps, aD as UNSAFE_createClientRoutes, aE as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, au as UNSAFE_hydrationRouteProperties, av as UNSAFE_mapRouteProperties, aF as UNSAFE_shouldHydrateRouteLoader, aG as UNSAFE_useScrollRestoration, ax as UNSAFE_withComponentProps, aB as UNSAFE_withErrorBoundaryProps, az as UNSAFE_withHydrateFallbackProps, ac as URLSearchParamsInit, T as createBrowserRouter, U as createHashRouter, p as createMemoryRouter, q as createRoutesFromChildren, r as createRoutesFromElements, ae as createSearchParams, ah as createStaticHandler, ai as createStaticRouter, s as renderMatches, Y as unstable_HistoryRouter, a7 as unstable_usePrompt, a6 as useBeforeUnload, a4 as useFetcher, a5 as useFetchers, a3 as useFormAction, a0 as useLinkClickHandler, a1 as useSearchParams, a2 as useSubmit, a8 as useViewTransitionState } from './index-react-server-client-kY8DvDF3.js';
+import { d as Router, e as RouteModules, D as DataStrategyFunction, T as To, f as NavigateOptions, B as BlockerFunction, g as Blocker, h as SerializeFrom, i as RelativeRoutingType, a as Location, j as ParamParseKey, k as Path, l as PathPattern, m as PathMatch, U as UIMatch, n as Navigation, A as Action, o as Params, p as RouteObject, I as InitialEntry, H as HydrationState, q as IndexRouteObject, r as LoaderFunction, s as ActionFunction, t as MetaFunction, v as LinksFunction, w as NonIndexRouteObject, x as AppLoadContext, y as unstable_RouterContextProvider, z as MiddlewareEnabled, E as unstable_InitialContext, F as Equal, J as ClientActionFunction, K as ClientLoaderFunction, O as HeadersFunction, Q as ShouldRevalidateFunction, V as RouterInit, W as RouterState, X as PatchRoutesOnNavigationFunction, Y as DataRouteObject } from './routeModules-BR2FO0ix.js';
+export { a7 as ActionFunctionArgs, aG as ClientActionFunctionArgs, aH as ClientLoaderFunctionArgs, aC as DataRouteMatch, a8 as DataStrategyFunctionArgs, a9 as DataStrategyMatch, aa as DataStrategyResult, ac as ErrorResponse, a1 as Fetcher, ad as FormEncType, ae as FormMethod, aM as Future, _ as GetScrollPositionFunction, $ as GetScrollRestorationKeyFunction, af as HTMLFormMethod, aI as HeadersArgs, aL as HtmlLinkDescriptor, as as IDLE_BLOCKER, ar as IDLE_FETCHER, aq as IDLE_NAVIGATION, ag as LazyRouteFunction, L as LinkDescriptor, ah as LoaderFunctionArgs, aJ as MetaArgs, M as MetaDescriptor, a2 as NavigationStates, aD as Navigator, aK as PageLinkDescriptor, aE as PatchRoutesOnNavigationFunctionArgs, aj as PathParam, ak as RedirectFunction, a6 as RevalidationState, aF as RouteMatch, a5 as RouterFetchOptions, a4 as RouterNavigateOptions, a3 as RouterSubscriber, am as ShouldRevalidateFunctionArgs, Z as StaticHandler, a0 as StaticHandlerContext, aS as UNSAFE_DataRouterContext, aT as UNSAFE_DataRouterStateContext, ab as UNSAFE_DataWithResponseInit, aR as UNSAFE_ErrorResponseImpl, aU as UNSAFE_FetchersContext, aV as UNSAFE_LocationContext, aW as UNSAFE_NavigationContext, aX as UNSAFE_RouteContext, aY as UNSAFE_ViewTransitionContext, aO as UNSAFE_createBrowserHistory, aQ as UNSAFE_createRouter, aP as UNSAFE_invariant, ao as createPath, at as data, au as generatePath, av as isRouteErrorResponse, aw as matchPath, ax as matchRoutes, ap as parsePath, ay as redirect, az as redirectDocument, aA as replace, aB as resolvePath, ai as unstable_MiddlewareFunction, al as unstable_RouterContext, aN as unstable_SerializesTo, an as unstable_createContext } from './routeModules-BR2FO0ix.js';
+import { A as AssetsManifest, E as EntryContext, F as FutureConfig, R as RouteComponentType, H as HydrateFallbackType, a as ErrorBoundaryType, S as ServerBuild } from './index-react-server-client-Bi_fx8qz.js';
+export { h as Await, b as AwaitProps, V as BrowserRouter, B as BrowserRouterProps, D as DOMRouterOpts, ar as DiscoverBehavior, y as FetcherFormProps, K as FetcherSubmitFunction, a9 as FetcherSubmitOptions, Q as FetcherWithComponents, _ as Form, z as FormProps, as as HandleDataRequestFunction, at as HandleDocumentRequestFunction, au as HandleErrorFunction, W as HashRouter, t as HashRouterProps, u as HistoryRouterProps, I as IndexRouteProps, L as LayoutRouteProps, X as Link, v as LinkProps, am as Links, i as MemoryRouter, M as MemoryRouterOpts, c as MemoryRouterProps, al as Meta, Z as NavLink, w as NavLinkProps, x as NavLinkRenderProps, j as Navigate, N as NavigateProps, k as Outlet, O as OutletProps, aa as ParamKeyValuePair, P as PathRouteProps, aq as PrefetchBehavior, ao as PrefetchPageLinks, l as Route, d as RouteProps, m as Router, e as RouterProps, n as RouterProvider, f as RouterProviderProps, o as Routes, g as RoutesProps, an as Scripts, ap as ScriptsProps, $ as ScrollRestoration, C as ScrollRestorationProps, av as ServerEntryModule, G as SetURLSearchParams, aj as StaticRouter, af as StaticRouterProps, ak as StaticRouterProvider, ag as StaticRouterProviderProps, J as SubmitFunction, ab as SubmitOptions, ad as SubmitTarget, aE as UNSAFE_FrameworkContext, ay as UNSAFE_WithComponentProps, aC as UNSAFE_WithErrorBoundaryProps, aA as UNSAFE_WithHydrateFallbackProps, aF as UNSAFE_createClientRoutes, aG as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, aw as UNSAFE_hydrationRouteProperties, ax as UNSAFE_mapRouteProperties, aH as UNSAFE_shouldHydrateRouteLoader, aI as UNSAFE_useScrollRestoration, az as UNSAFE_withComponentProps, aD as UNSAFE_withErrorBoundaryProps, aB as UNSAFE_withHydrateFallbackProps, ac as URLSearchParamsInit, T as createBrowserRouter, U as createHashRouter, p as createMemoryRouter, q as createRoutesFromChildren, r as createRoutesFromElements, ae as createSearchParams, ah as createStaticHandler, ai as createStaticRouter, s as renderMatches, Y as unstable_HistoryRouter, a7 as unstable_usePrompt, a6 as useBeforeUnload, a4 as useFetcher, a5 as useFetchers, a3 as useFormAction, a0 as useLinkClickHandler, a1 as useSearchParams, a2 as useSubmit, a8 as useViewTransitionState } from './index-react-server-client-Bi_fx8qz.js';
 import * as React from 'react';
 import React__default, { ReactElement } from 'react';
 import { ParseOptions, SerializeOptions } from 'cookie';
@@ -27,369 +27,795 @@ declare enum ServerMode {
 }
 
 /**
-  Resolves a URL against the current location.
-
-  ```tsx
-  import { useHref } from "react-router"
-
-  function SomeComponent() {
-    let href = useHref("some/where");
-    // "/resolved/some/where"
-  }
-  ```
-
-  @category Hooks
+ * Resolves a URL against the current {@link Location}.
+ *
+ * @example
+ * import { useHref } from "react-router";
+ *
+ * function SomeComponent() {
+ *   let href = useHref("some/where");
+ *   // "/resolved/some/where"
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @param to The path to resolve
+ * @param options Options
+ * @param options.relative Defaults to `"route"` so routing is relative to the
+ * route tree.
+ * Set to `"path"` to make relative routing operate against path segments.
+ * @returns The resolved href string
  */
 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.
+ * Returns `true` if this component is a descendant of a {@link Router}, useful
+ * to ensure a component is used within a {@link Router}.
  *
+ * @public
  * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns Whether the component is within a {@link Router} context
  */
 declare function useInRouterContext(): boolean;
 /**
-  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
+ * Returns the current {@link Location}. This can be useful if you'd like to
+ * perform some side effect whenever it changes.
+ *
+ * @example
+ * import * as React from 'react'
+ * import { useLocation } from 'react-router'
+ *
+ * function SomeComponent() {
+ *   let location = useLocation()
+ *
+ *   React.useEffect(() => {
+ *     // Google Analytics
+ *     ga('send', 'pageview')
+ *   }, [location]);
+ *
+ *   return (
+ *     // ...
+ *   );
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @returns The current {@link Location} object
  */
 declare function useLocation(): Location;
 /**
- * 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.
+ * Returns the current {@link Navigation} action which describes how the router
+ * came to the current {@link Location}, either by a pop, push, or replace on
+ * the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History) stack.
  *
+ * @public
  * @category Hooks
+ * @returns The current {@link NavigationType} type (`"PUSH"`, `"REPLACE"`, or `"POP"`)
  */
 declare function useNavigationType(): Action;
 /**
- * Returns a PathMatch object if the given pattern matches the current URL.
+ * Returns a {@link PathMatch} object if the given pattern matches the current URL.
  * This is useful for components that need to know "active" state, e.g.
- * `<NavLink>`.
+ * {@link NavLink | `<NavLink>`}.
  *
+ * @public
  * @category Hooks
+ * @param pattern The pattern to match against the current {@link Location}
+ * @returns The path match object if the pattern matches, `null` otherwise
  */
 declare function useMatch<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null;
 /**
- * The interface for the navigate() function returned from useNavigate().
+ * The interface for the `navigate` function returned from {@link useNavigate}.
  */
 interface NavigateFunction {
     (to: To, options?: NavigateOptions): void | Promise<void>;
     (delta: number): void | Promise<void>;
 }
 /**
-  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
+ * Returns a function that lets you navigate programmatically in the browser in
+ * response to user interactions or effects.
+ *
+ * It's often better to use {@link redirect} in [`action`](../../start/framework/route-module#action)/[`loader`](../../start/framework/route-module#loader)
+ * functions than this hook.
+ *
+ * The returned function signature is `navigate(to, options?)`/`navigate(delta)` where:
+ *
+ * * `to` can be a string path, a {@link To} object, or a number (delta)
+ * * `options` contains options for modifying the navigation
+ *   * `flushSync`: Wrap the DOM updates in [`ReactDom.flushSync`](https://react.dev/reference/react-dom/flushSync)
+ *   * `preventScrollReset`: Do not scroll back to the top of the page after navigation
+ *   * `relative`: `"route"` or `"path"` to control relative routing logic
+ *   * `replace`: Replace the current entry in the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History) stack
+ *   * `state`: Optional [`history.state`](https://developer.mozilla.org/en-US/docs/Web/API/History/state) to include with the new {@link Location}
+ *   * `viewTransition`: Enable [`document.startViewTransition`](https://developer.mozilla.org/en-US/docs/Web/API/Document/startViewTransition) for this navigation
+ *
+ * @example
+ * import { useNavigate } from "react-router";
+ *
+ * function SomeComponent() {
+ *   let navigate = useNavigate();
+ *   return (
+ *     <button onClick={() => navigate(-1)}>
+ *       Go Back
+ *     </button>
+ *   );
+ * }
+ *
+ * @additionalExamples
+ * ### Navigate to another path
+ *
+ * ```tsx
+ * navigate("/some/route");
+ * navigate("/some/route?search=param");
+ * ```
+ *
+ * ### Navigate with a {@link To} object
+ *
+ * All properties are optional.
+ *
+ * ```tsx
+ * navigate({
+ *   pathname: "/some/route",
+ *   search: "?search=param",
+ *   hash: "#hash",
+ *   state: { some: "state" },
+ * });
+ * ```
+ *
+ * If you use `state`, that will be available on the {@link Location} object on
+ * the next page. Access it with `useLocation().state` (see {@link useLocation}).
+ *
+ * ### Navigate back or forward in the history stack
+ *
+ * ```tsx
+ * // back
+ * // often used to close modals
+ * navigate(-1);
+ *
+ * // forward
+ * // often used in a multistep wizard workflows
+ * navigate(1);
+ * ```
+ *
+ * Be cautious with `navigate(number)`. If your application can load up to a
+ * route that has a button that tries to navigate forward/back, there may not be
+ * a `[`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
+ * entry to go back or forward to, or it can go somewhere you don't expect
+ * (like a different domain).
+ *
+ * Only use this if you're sure they will have an entry in the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
+ * stack to navigate to.
+ *
+ * ### Replace the current entry in the history stack
+ *
+ * This will remove the current entry in the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
+ * stack, replacing it with a new one, similar to a server side redirect.
+ *
+ * ```tsx
+ * navigate("/some/route", { replace: true });
+ * ```
+ *
+ * ### Prevent Scroll Reset
+ *
+ * [MODES: framework, data]
+ *
+ * <br/>
+ * <br/>
+ *
+ * To prevent {@link ScrollRestoration | `<ScrollRestoration>`} from resetting
+ * the scroll position, use the `preventScrollReset` option.
+ *
+ * ```tsx
+ * navigate("?some-tab=1", { preventScrollReset: true });
+ * ```
+ *
+ * For example, if you have a tab interface connected to search params in the
+ * middle of a page, and you don't want it to scroll to the top when a tab is
+ * clicked.
+ *
+ * @public
+ * @category Hooks
+ * @returns A navigate function for programmatic navigation
  */
 declare function useNavigate(): NavigateFunction;
 /**
- * Returns the parent route {@link OutletProps.context | `<Outlet context>`}.
+ * Returns the parent route {@link Outlet | `<Outlet context>`}.
+ *
+ * Often parent routes manage state or other values you want shared with child
+ * routes. You can create your own [context provider](https://react.dev/learn/passing-data-deeply-with-context)
+ * if you like, but this is such a common situation that it's built-into
+ * `<Outlet />`.
+ *
+ * ```tsx
+ * // Parent route
+ * function Parent() {
+ *   const [count, setCount] = React.useState(0);
+ *   return <Outlet context={[count, setCount]} />;
+ * }
+ * ```
+ *
+ * ```tsx
+ * // Child route
+ * import { useOutletContext } from "react-router-dom";
+ *
+ * function Child() {
+ *   const [count, setCount] = useOutletContext();
+ *   const increment = () => setCount((c) => c + 1);
+ *   return <button onClick={increment}>{count}</button>;
+ * }
+ * ```
+ *
+ * If you're using TypeScript, we recommend the parent component provide a custom
+ * hook for accessing the context value. This makes it easier for consumers to
+ * get nice typings, control consumers, and know who's consuming the context value.
+ *
+ * Here's a more realistic example:
  *
+ * ```tsx filename=src/routes/dashboard.tsx lines=[13,19]
+ * import * as React from "react";
+ * import type { User } from "./types";
+ * import { Outlet, useOutletContext } from "react-router-dom";
+ *
+ * type ContextType = { user: User | null };
+ *
+ * export default function Dashboard() {
+ *   const [user, setUser] = React.useState<User | null>(null);
+ *
+ *   return (
+ *     <div>
+ *       <h1>Dashboard</h1>
+ *       <Outlet context={{ user } satisfies ContextType} />
+ *     </div>
+ *   );
+ * }
+ *
+ * export function useUser() {
+ *   return useOutletContext<ContextType>();
+ * }
+ * ```
+ *
+ * ```tsx filename=src/routes/dashboard/messages.tsx lines=[1,4]
+ * import { useUser } from "../dashboard";
+ *
+ * export default function DashboardMessages() {
+ *   const { user } = useUser();
+ *   return (
+ *     <div>
+ *       <h2>Messages</h2>
+ *       <p>Hello, {user.name}!</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @public
  * @category Hooks
+ * @returns The context value passed to the parent {@link Outlet} component
  */
 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.
+ * hierarchy. Used internally by {@link Outlet | `<Outlet>`} to render child
+ * routes.
  *
+ * @public
  * @category Hooks
+ * @param context The context to pass to the outlet
+ * @returns The child route element or `null` if no child routes match
  */
 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
+ * 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.
+ *
+ * Assuming a route pattern like `/posts/:postId` is matched by `/posts/123`
+ * then `params.postId` will be `"123"`.
+ *
+ * @example
+ * import { useParams } from "react-router";
+ *
+ * function SomeComponent() {
+ *   let params = useParams();
+ *   params.postId;
+ * }
+ *
+ * @additionalExamples
+ * ### Basic Usage
+ *
+ * ```tsx
+ * import { useParams } from "react-router";
+ *
+ * // given a route like:
+ * <Route path="/posts/:postId" element={<Post />} />;
+ *
+ * // or a data route like:
+ * createBrowserRouter([
+ *   {
+ *     path: "/posts/:postId",
+ *     component: Post,
+ *   },
+ * ]);
+ *
+ * // or in routes.ts
+ * route("/posts/:postId", "routes/post.tsx");
+ * ```
+ *
+ * Access the params in a component:
+ *
+ * ```tsx
+ * import { useParams } from "react-router";
+ *
+ * export default function Post() {
+ *   let params = useParams();
+ *   return <h1>Post: {params.postId}</h1>;
+ * }
+ * ```
+ *
+ * ### Multiple Params
+ *
+ * Patterns can have multiple params:
+ *
+ * ```tsx
+ * "/posts/:postId/comments/:commentId";
+ * ```
+ *
+ * All will be available in the params object:
+ *
+ * ```tsx
+ * import { useParams } from "react-router";
+ *
+ * export default function Post() {
+ *   let params = useParams();
+ *   return (
+ *     <h1>
+ *       Post: {params.postId}, Comment: {params.commentId}
+ *     </h1>
+ *   );
+ * }
+ * ```
+ *
+ * ### Catchall Params
+ *
+ * Catchall params are defined with `*`:
+ *
+ * ```tsx
+ * "/files/*";
+ * ```
+ *
+ * The matched value will be available in the params object as follows:
+ *
+ * ```tsx
+ * import { useParams } from "react-router";
+ *
+ * export default function File() {
+ *   let params = useParams();
+ *   let catchall = params["*"];
+ *   // ...
+ * }
+ * ```
+ *
+ * You can destructure the catchall param:
+ *
+ * ```tsx
+ * export default function File() {
+ *   let { "*": catchall } = useParams();
+ *   console.log(catchall);
+ * }
+ * ```
+ *
+ * @public
+ * @category Hooks
+ * @returns An object containing the dynamic route parameters
  */
 declare function useParams<ParamsOrKey extends string | Record<string, string | undefined> = string>(): Readonly<[
     ParamsOrKey
 ] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>>;
 /**
-  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
+ * Resolves the pathname of the given `to` value against the current
+ * {@link Location}. Similar to {@link useHref}, but returns a
+ * {@link Path} instead of a string.
+ *
+ * @example
+ * 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; // ""
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @param to The path to resolve
+ * @param options Options
+ * @param options.relative Defaults to `"route"` so routing is relative to the route tree.
+ *                         Set to `"path"` to make relative routing operate against path segments.
+ * @returns The resolved {@link Path} object with `pathname`, `search`, and `hash`
  */
 declare function useResolvedPath(to: To, { relative }?: {
     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
+ * 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.
+ *
+ * @example
+ * 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;
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @param routes An array of {@link RouteObject}s that define the route hierarchy
+ * @param locationArg An optional {@link Location} object or pathname string to
+ * use instead of the current {@link Location}
+ * @returns A React element to render the matched route, or `null` if no routes matched
  */
 declare function useRoutes(routes: RouteObject[], locationArg?: Partial<Location> | string): React.ReactElement | 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
+ * Returns the current {@link 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`](https://developer.mozilla.org/en-US/docs/Web/API/FormData)
+ * from a form navigation.
+ *
+ * @example
+ * import { useNavigation } from "react-router";
+ *
+ * function SomeComponent() {
+ *   let navigation = useNavigation();
+ *   navigation.state;
+ *   navigation.formData;
+ *   // etc.
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns The current {@link Navigation} object
  */
 declare function useNavigation(): Navigation;
 /**
-  Revalidate the data on the page for reasons outside of normal data mutations like window focus or polling on an interval.
-
-  ```tsx
-  import { useRevalidator } from "react-router";
-
-  function WindowFocusRevalidator() {
-    const revalidator = useRevalidator();
-
-    useFakeWindowFocus(() => {
-      revalidator.revalidate();
-    });
-
-    return (
-      <div hidden={revalidator.state === "idle"}>
-        Revalidating...
-      </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
+ * Revalidate the data on the page for reasons outside of normal data mutations
+ * like [`Window` focus](https://developer.mozilla.org/en-US/docs/Web/API/Window/focus_event)
+ * or polling on an interval.
+ *
+ * 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.
+ *
+ * @example
+ * import { useRevalidator } from "react-router";
+ *
+ * function WindowFocusRevalidator() {
+ *   const revalidator = useRevalidator();
+ *
+ *   useFakeWindowFocus(() => {
+ *     revalidator.revalidate();
+ *   });
+ *
+ *   return (
+ *     <div hidden={revalidator.state === "idle"}>
+ *       Revalidating...
+ *     </div>
+ *   );
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns An object with a `revalidate` function and the current revalidation
+ * `state`
  */
 declare function useRevalidator(): {
     revalidate: () => Promise<void>;
     state: Router["state"]["revalidation"];
 };
 /**
- * Returns the active route matches, useful for accessing loaderData for
- * parent/child routes or the route "handle" property
+ * Returns the active route matches, useful for accessing `loaderData` for
+ * parent/child routes or the route [`handle`](../../start/framework/route-module#handle)
+ * property
  *
+ * @public
  * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns An array of {@link UIMatch | UI matches} for the current route hierarchy
  */
 declare function useMatches(): UIMatch[];
 /**
-  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
+ * Returns the data from the closest route
+ * [`loader`](../../start/framework/route-module#loader) or
+ * [`clientLoader`](../../start/framework/route-module#clientloader).
+ *
+ * @example
+ * import { useLoaderData } from "react-router";
+ *
+ * export async function loader() {
+ *   return await fakeDb.invoices.findAll();
+ * }
+ *
+ * export default function Invoices() {
+ *   let invoices = useLoaderData<typeof loader>();
+ *   // ...
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns The data returned from the route's [`loader`](../../start/framework/route-module#loader) or [`clientLoader`](../../start/framework/route-module#clientloader) function
  */
 declare function useLoaderData<T = any>(): SerializeFrom<T>;
 /**
-  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
+ * Returns the [`loader`](../../start/framework/route-module#loader) data for a
+ * given route by route ID.
+ *
+ * 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"` |
+ *
+ * @example
+ * import { useRouteLoaderData } from "react-router";
+ *
+ * function SomeComponent() {
+ *   const { user } = useRouteLoaderData("root");
+ * }
+ *
+ * // You can also specify your own route ID's manually in your routes.ts file:
+ * route("/", "containers/app.tsx", { id: "app" })
+ * useRouteLoaderData("app");
+ *
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @mode data
+ * @param routeId The ID of the route to return loader data from
+ * @returns The data returned from the specified route's [`loader`](../../start/framework/route-module#loader)
+ * function, or `undefined` if not found
  */
 declare function useRouteLoaderData<T = any>(routeId: string): SerializeFrom<T> | undefined;
 /**
-  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
+ * Returns the [`action`](../../start/framework/route-module#action) data from
+ * the most recent `POST` navigation form submission or `undefined` if there
+ * hasn't been one.
+ *
+ * @example
+ * 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>
+ *   );
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns The data returned from the route's [`action`](../../start/framework/route-module#action)
+ * function, or `undefined` if no [`action`](../../start/framework/route-module#action)
+ * has been called
  */
 declare function useActionData<T = any>(): SerializeFrom<T> | undefined;
 /**
-  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
+ * Accesses the error thrown during an
+ * [`action`](../../start/framework/route-module#action),
+ * [`loader`](../../start/framework/route-module#loader),
+ * or component render to be used in a route module
+ * [`ErrorBoundary`](../../start/framework/route-module#errorboundary).
+ *
+ * @example
+ * export function ErrorBoundary() {
+ *   const error = useRouteError();
+ *   return <div>{error.message}</div>;
+ * }
+ *
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns The error that was thrown during route [loading](../../start/framework/route-module#loader),
+ * [`action`](../../start/framework/route-module#action) execution, or rendering
  */
 declare function useRouteError(): unknown;
 /**
-  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
+ * Returns the resolved promise value from the closest {@link Await | `<Await>`}.
+ *
+ * @example
+ * function SomeDescendant() {
+ *   const value = useAsyncValue();
+ *   // ...
+ * }
+ *
+ * // somewhere in your app
+ * <Await resolve={somePromise}>
+ *   <SomeDescendant />
+ * </Await>;
+ *
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns The resolved value from the nearest {@link Await} component
  */
 declare function useAsyncValue(): unknown;
 /**
-  Returns the rejection value from the closest {@link Await | `<Await>`}.
-
-  ```tsx
-  import { Await, useAsyncError } from "react-router"
-
-  function ErrorElement() {
-    const error = useAsyncError();
-    return (
-      <p>Uh Oh, something went wrong! {error.message}</p>
-    );
-  }
-
-  // somewhere in your app
-  <Await
-    resolve={promiseThatRejects}
-    errorElement={<ErrorElement />}
-  />
-  ```
-
-  @category Hooks
+ * Returns the rejection value from the closest {@link Await | `<Await>`}.
+ *
+ * @example
+ * import { Await, useAsyncError } from "react-router";
+ *
+ * function ErrorElement() {
+ *   const error = useAsyncError();
+ *   return (
+ *     <p>Uh Oh, something went wrong! {error.message}</p>
+ *   );
+ * }
+ *
+ * // somewhere in your app
+ * <Await
+ *   resolve={promiseThatRejects}
+ *   errorElement={<ErrorElement />}
+ * />;
+ *
+ * @public
+ * @category Hooks
+ * @mode framework
+ * @mode data
+ * @returns The error that was thrown in the nearest {@link Await} component
  */
 declare function useAsyncError(): unknown;
 /**
  * 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
+ * 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.
  *
+ * The {@link Blocker} object returned by the hook has the following properties:
+ *
+ * - **`state`**
+ *   - `unblocked` - the blocker is idle and has not prevented any navigation
+ *   - `blocked` - the blocker has prevented a navigation
+ *   - `proceeding` - the blocker is proceeding through from a blocked navigation
+ * - **`location`**
+ *   - When in a `blocked` state, this represents the {@link Location} to which we
+ *     blocked a navigation. When in a `proceeding` state, this is the location
+ *     being navigated to after a `blocker.proceed()` call.
+ * - **`proceed()`**
+ *   - When in a `blocked` state, you may call `blocker.proceed()` to proceed to the
+ *     blocked location.
+ * - **`reset()`**
+ *   - When in a `blocked` state, you may call `blocker.reset()` to return the blocker
+ *     back to an `unblocked` state and leave the user at the current location.
+ *
+ * @example
+ * // Boolean version
+ * const blocker = useBlocker(value !== "");
+ *
+ * // Function version
+ * const blocker = useBlocker(
+ *   ({ currentLocation, nextLocation, historyAction }) =>
+ *     value !== "" &&
+ *     currentLocation.pathname !== nextLocation.pathname
+ * );
+ *
+ * @additionalExamples
+ * ```tsx
+ * import { useCallback, useState } from "react";
+ * import { BlockerFunction, useBlocker } from "react-router";
+ *
+ * export function ImportantForm() {
+ *   const [value, setValue] = useState("");
+ *
+ *   const shouldBlock = useCallback<BlockerFunction>(
+ *     () => value !== "",
+ *     [value]
+ *   );
+ *   const blocker = useBlocker(shouldBlock);
+ *
+ *   return (
+ *     <form
+ *       onSubmit={(e) => {
+ *         e.preventDefault();
+ *         setValue("");
+ *         if (blocker.state === "blocked") {
+ *           blocker.proceed();
+ *         }
+ *       }}
+ *     >
+ *       <input
+ *         name="data"
+ *         value={value}
+ *         onChange={(e) => setValue(e.target.value)}
+ *       />
+ *
+ *       <button type="submit">Save</button>
+ *
+ *       {blocker.state === "blocked" ? (
+ *         <>
+ *           <p style={{ color: "red" }}>
+ *             Blocked the last navigation to
+ *           </p>
+ *           <button
+ *             type="button"
+ *             onClick={() => blocker.proceed()}
+ *           >
+ *             Let me through
+ *           </button>
+ *           <button
+ *             type="button"
+ *             onClick={() => blocker.reset()}
+ *           >
+ *             Keep me here
+ *           </button>
+ *         </>
+ *       ) : blocker.state === "proceeding" ? (
+ *         <p style={{ color: "orange" }}>
+ *           Proceeding through blocked navigation
+ *         </p>
+ *       ) : (
+ *         <p style={{ color: "green" }}>
+ *           Blocker is currently unblocked
+ *         </p>
+ *       )}
+ *     </form>
+ *   );
+ * }
+ * ```
+ *
+ * @public
  * @category Hooks
+ * @mode framework
+ * @mode data
+ * @param shouldBlock Either a boolean or a function returning a boolean which
+ * indicates whether the navigation should be blocked. The function format
+ * receives a single object parameter containing the `currentLocation`,
+ * `nextLocation`, and `historyAction` of the potential navigation.
+ * @returns A {@link Blocker} object with state and reset functionality
  */
 declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
 
@@ -399,11 +825,20 @@ interface ServerRouterProps {
     nonce?: string;
 }
 /**
- * The entry point for a Remix app when it is rendered on the server (in
- * `app/entry.server.js`). This component is used to generate the HTML in the
- * response from the server.
+ * The server entry point for a React Router app in Framework Mode. This component
+ * is used to generate the HTML in the response from the server.
+ * See [`entry.server.tsx`](../api/framework-conventions/entry.server.tsx).
  *
- * @category Components
+ * @public
+ * @category Framework Routers
+ * @mode framework
+ * @param props Props
+ * @param props.context The entry context containing the manifest, route modules,
+ * and other data needed for rendering.
+ * @param props.url The URL of the request being handled.
+ * @param props.nonce An optional nonce for Content Security Policy (CSP) compliance,
+ * used to allow inline scripts to run safely.
+ * @returns A React element that represents the server-rendered application.
  */
 declare function ServerRouter({ context, url, nonce, }: ServerRouterProps): ReactElement;
 
@@ -816,6 +1251,67 @@ type DecodeReplyFunction = (reply: FormData | string, { temporaryReferences }: {
     temporaryReferences: unknown;
 }) => Promise<unknown[]>;
 type LoadServerActionFunction = (id: string) => Promise<Function>;
+/**
+ * Matches the given routes to a Request and returns a RSC Response encoding an
+ * `RSCPayload` for consumption by a RSC enabled client router.
+ *
+ * @example
+ * import {
+ *   createTemporaryReferenceSet,
+ *   decodeAction,
+ *   decodeReply,
+ *   loadServerAction,
+ *   renderToReadableStream,
+ * } from "@vitejs/plugin-rsc/rsc";
+ * import { unstable_matchRSCServerRequest as matchRSCServerRequest } from "react-router";
+ *
+ * matchRSCServerRequest({
+ *   createTemporaryReferenceSet,
+ *   decodeAction,
+ *   decodeFormState,
+ *   decodeReply,
+ *   loadServerAction,
+ *   request,
+ *   routes: routes(),
+ *   generateResponse(match) {
+ *     return new Response(
+ *       renderToReadableStream(match.payload),
+ *       {
+ *         status: match.statusCode,
+ *         headers: match.headers,
+ *       }
+ *     );
+ *   },
+ * });
+ *
+ * @name unstable_matchRSCServerRequest
+ * @public
+ * @category RSC
+ * @mode data
+ * @param opts Options
+ * @param opts.basename The basename to use when matching the request.
+ * @param opts.decodeAction Your `react-server-dom-xyz/server`'s `decodeAction`
+ * function, responsible for loading a server action.
+ * @param opts.decodeReply Your `react-server-dom-xyz/server`'s `decodeReply`
+ * function, used to decode the server function's arguments and bind them to the
+ * implementation for invocation by the router.
+ * @param opts.decodeFormState A function responsible for decoding form state for
+ * progressively enhanceable forms with `useActionState` using your
+ * `react-server-dom-xyz/server`'s `decodeFormState`.
+ * @param opts.generateResponse A function responsible for using your
+ * `renderToReadableStream` to generate a Response encoding the `RSCPayload`.
+ * @param opts.loadServerAction Your `react-server-dom-xyz/server`'s
+ * `loadServerAction` function, used to load a server action by ID.
+ * @param opts.request The request to match against.
+ * @param opts.requestContext An instance of `unstable_RouterContextProvider`
+ * that should be created per request, to be passed to loaders, actions and middleware.
+ * @param opts.routes Your route definitions.
+ * @param opts.createTemporaryReferenceSet A function that returns a temporary
+ * reference set for the request, used to track temporary references in the RSC stream.
+ * @param opts.onError An optional error handler that will be called with any
+ * errors that occur during the request processing.
+ * @returns A Response that contains the RSC data for hydration.
+ */
 declare function matchRSCServerRequest({ createTemporaryReferenceSet, basename, decodeReply, requestContext, loadServerAction, decodeAction, decodeFormState, onError, request, routes, generateResponse, }: {
     createTemporaryReferenceSet: () => unknown;
     basename?: string;
@@ -838,21 +1334,171 @@ type BrowserCreateFromReadableStreamFunction = (body: ReadableStream<Uint8Array>
 type EncodeReplyFunction = (args: unknown[], options: {
     temporaryReferences: unknown;
 }) => Promise<BodyInit>;
+/**
+ * Create a React `callServer` implementation for React Router.
+ *
+ * @example
+ * import {
+ *   createFromReadableStream,
+ *   createTemporaryReferenceSet,
+ *   encodeReply,
+ *   setServerCallback,
+ * } from "@vitejs/plugin-rsc/browser";
+ * import { unstable_createCallServer as createCallServer } from "react-router";
+ *
+ * setServerCallback(
+ *   createCallServer({
+ *     createFromReadableStream,
+ *     createTemporaryReferenceSet,
+ *     encodeReply,
+ *   })
+ * );
+ *
+ * @name unstable_createCallServer
+ * @public
+ * @category RSC
+ * @mode data
+ * @param opts Options
+ * @param opts.createFromReadableStream Your `react-server-dom-xyz/client`'s
+ * `createFromReadableStream`. Used to decode payloads from the server.
+ * @param opts.createTemporaryReferenceSet A function that creates a temporary
+ * reference set for the RSC payload.
+ * @param opts.encodeReply Your `react-server-dom-xyz/client`'s `encodeReply`.
+ * Used when sending payloads to the server.
+ * @param opts.fetch Optional fetch implementation. Defaults to global `fetch`.
+ * @returns A function that can be used to call server actions.
+ */
 declare function createCallServer({ createFromReadableStream, createTemporaryReferenceSet, encodeReply, fetch: fetchImplementation, }: {
     createFromReadableStream: BrowserCreateFromReadableStreamFunction;
     createTemporaryReferenceSet: () => unknown;
     encodeReply: EncodeReplyFunction;
     fetch?: (request: Request) => Promise<Response>;
 }): (id: string, args: unknown[]) => Promise<unknown>;
-declare function RSCHydratedRouter({ createFromReadableStream, fetch: fetchImplementation, payload, routeDiscovery, unstable_getContext, }: {
+/**
+ * Props for the `unstable_RSCHydratedRouter` component.
+ * @name unstable_RSCHydratedRouterProps
+ */
+interface RSCHydratedRouterProps {
+    /**
+     * Your `react-server-dom-xyz/client`'s `createFromReadableStream` function,
+     * used to decode payloads from the server.
+     */
     createFromReadableStream: BrowserCreateFromReadableStreamFunction;
+    /**
+     * Optional fetch implementation.  Defaults to global `fetch`.
+     */
     fetch?: (request: Request) => Promise<Response>;
+    /**
+     * The decoded `RSCPayload` to hydrate.
+     */
     payload: RSCPayload;
+    /**
+     * `eager` or `lazy` - Determines if links are eagerly discovered, or delayed
+     * until clicked.
+     */
     routeDiscovery?: "eager" | "lazy";
+    /**
+     * A function that returns an `unstable_InitialContext` object
+     * (`Map<RouterContext, unknown>`), for use in client loaders, actions and
+     * middleware.
+     */
     unstable_getContext?: RouterInit["unstable_getContext"];
-}): React.JSX.Element;
+}
+/**
+ * Hydrates a server rendered `RSCPayload` in the browser.
+ *
+ * @example
+ * import { startTransition, StrictMode } from "react";
+ * import { hydrateRoot } from "react-dom/client";
+ * import {
+ *   unstable_getRSCStream as getRSCStream,
+ *   unstable_RSCHydratedRouter as RSCHydratedRouter,
+ * } from "react-router";
+ * import type { unstable_RSCPayload as RSCPayload } from "react-router";
+ *
+ * createFromReadableStream(getRSCStream()).then(
+ *   (payload: RSCServerPayload) => {
+ *     startTransition(async () => {
+ *       hydrateRoot(
+ *         document,
+ *         <StrictMode>
+ *           <RSCHydratedRouter
+ *             createFromReadableStream={
+ *               createFromReadableStream
+ *             }
+ *             payload={payload}
+ *           />
+ *         </StrictMode>,
+ *         {
+ *           formState: await getFormState(payload),
+ *         }
+ *       );
+ *     });
+ *   }
+ * );
+ *
+ * @name unstable_RSCHydratedRouter
+ * @public
+ * @category RSC
+ * @mode data
+ * @param props Props
+ * @param {unstable_RSCHydratedRouterProps.createFromReadableStream} props.createFromReadableStream n/a
+ * @param {unstable_RSCHydratedRouterProps.fetch} props.fetch n/a
+ * @param {unstable_RSCHydratedRouterProps.payload} props.payload n/a
+ * @param {unstable_RSCHydratedRouterProps.routeDiscovery} props.routeDiscovery n/a
+ * @param {unstable_RSCHydratedRouterProps.unstable_getContext} props.unstable_getContext n/a
+ * @returns A hydrated router that can be used to navigate and render routes.
+ */
+declare function RSCHydratedRouter({ createFromReadableStream, fetch: fetchImplementation, payload, routeDiscovery, unstable_getContext, }: RSCHydratedRouterProps): React.JSX.Element;
 
 type SSRCreateFromReadableStreamFunction = (body: ReadableStream<Uint8Array>) => Promise<unknown>;
+/**
+ * Routes the incoming request to the RSC server and appropriately proxies the
+ * server response for data / resource requests, or renders to HTML for a document
+ * request.
+ *
+ * @example
+ * import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
+ * import * as ReactDomServer from "react-dom/server.edge";
+ * import {
+ *   unstable_RSCStaticRouter as RSCStaticRouter,
+ *   unstable_routeRSCServerRequest as routeRSCServerRequest,
+ * } from "react-router";
+ *
+ * routeRSCServerRequest({
+ *   request,
+ *   fetchServer,
+ *   createFromReadableStream,
+ *   async renderHTML(getPayload) {
+ *     const payload = await getPayload();
+ *
+ *     return await renderHTMLToReadableStream(
+ *       <RSCStaticRouter getPayload={getPayload} />,
+ *       {
+ *         bootstrapScriptContent,
+ *         formState: await getFormState(payload),
+ *       }
+ *     );
+ *   },
+ * });
+ *
+ * @name unstable_routeRSCServerRequest
+ * @public
+ * @category RSC
+ * @mode data
+ * @param opts Options
+ * @param opts.createFromReadableStream Your `react-server-dom-xyz/client`'s
+ * `createFromReadableStream` function, used to decode payloads from the server.
+ * @param opts.fetchServer A function that forwards a `Request` to the RSC handler
+ * and returns a `Promise<Response>` containing a serialized `RSCPayload`.
+ * @param opts.renderHTML A function that renders the `RSCPayload` to HTML, usually
+ * using a `<RSCStaticRouter>`.
+ * @param opts.request The request to route.
+ * @param opts.hydrate Whether to hydrate the server response with the RSC payload.
+ * Defaults to `true`.
+ * @returns A `Response` that either contains the RSC payload for data requests, or
+ * renders the HTML for document requests.
+ */
 declare function routeRSCServerRequest({ request, fetchServer, createFromReadableStream, renderHTML, hydrate, }: {
     request: Request;
     fetchServer: (request: Request) => Promise<Response>;
@@ -860,15 +1506,96 @@ declare function routeRSCServerRequest({ request, fetchServer, createFromReadabl
     renderHTML: (getPayload: () => Promise<RSCPayload>) => ReadableStream<Uint8Array> | Promise<ReadableStream<Uint8Array>>;
     hydrate?: boolean;
 }): Promise<Response>;
-declare function RSCStaticRouter({ getPayload, }: {
+/**
+ * Props for the `RSCStaticRouter` component.
+ * @name unstable_RSCStaticRouterProps
+ */
+interface RSCStaticRouterProps {
+    /**
+     * A function that starts decoding of the `RSCPayload`. Usually passed through
+     * from `routeRSCServerRequest`'s `renderHTML`.
+     */
     getPayload: () => Promise<RSCPayload>;
-}): React.JSX.Element | null;
+}
+/**
+ * Pre-renders an `RSCPayload` to HTML. Usually used in `routeRSCServerRequest`'s
+ * `renderHTML` callback.
+ *
+ * @example
+ * import { createFromReadableStream } from "@vitejs/plugin-rsc/ssr";
+ * import * as ReactDomServer from "react-dom/server.edge";
+ * import {
+ *   unstable_RSCStaticRouter as RSCStaticRouter,
+ *   unstable_routeRSCServerRequest as routeRSCServerRequest,
+ * } from "react-router";
+ *
+ * routeRSCServerRequest({
+ *   request,
+ *   fetchServer,
+ *   createFromReadableStream,
+ *   async renderHTML(getPayload) {
+ *     const payload = await getPayload();
+ *
+ *     return await renderHTMLToReadableStream(
+ *       <RSCStaticRouter getPayload={getPayload} />,
+ *       {
+ *         bootstrapScriptContent,
+ *         formState: await getFormState(payload),
+ *       }
+ *     );
+ *   },
+ * });
+ *
+ * @name unstable_RSCStaticRouter
+ * @public
+ * @category RSC
+ * @mode data
+ * @param props Props
+ * @param {unstable_RSCStaticRouterProps.getPayload} props.getPayload n/a
+ * @returns A React component that renders the `RSCPayload` as HTML.
+ */
+declare function RSCStaticRouter({ getPayload }: RSCStaticRouterProps): React.JSX.Element | null;
 
 declare global {
     interface Window {
         __FLIGHT_DATA: any[];
     }
 }
+/**
+ * Get the prerendered RSC stream for hydration. Usually passed directly to your
+ * `react-server-dom-xyz/client`'s `createFromReadableStream`.
+ *
+ * @example
+ * import { startTransition, StrictMode } from "react";
+ * import { hydrateRoot } from "react-dom/client";
+ * import {
+ *   unstable_getRSCStream as getRSCStream,
+ *   unstable_RSCHydratedRouter as RSCHydratedRouter,
+ * } from "react-router";
+ * import type { unstable_RSCPayload as RSCPayload } from "react-router";
+ *
+ * createFromReadableStream(getRSCStream()).then(
+ *   (payload: RSCServerPayload) => {
+ *     startTransition(async () => {
+ *       hydrateRoot(
+ *         document,
+ *         <StrictMode>
+ *           <RSCHydratedRouter ...props />
+ *         </StrictMode>,
+ *         {
+ *           // Options
+ *         }
+ *       );
+ *     });
+ *   }
+ * );
+ *
+ * @name unstable_getRSCStream
+ * @public
+ * @category RSC
+ * @mode data
+ * @returns A `ReadableStream` that contains the RSC data for hydration.
+ */
 declare function getRSCStream(): ReadableStream<any>;
 
 declare function RSCDefaultRootErrorBoundary({ hasRootLayout, }: {
@@ -913,4 +1640,4 @@ declare function getHydrationData(state: {
 
 declare const unstable_matchRSCServerRequest: typeof matchRSCServerRequest;
 
-export { ActionFunction, AppLoadContext, Blocker, BlockerFunction, ClientActionFunction, ClientLoaderFunction, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, DataRouteObject, Router as DataRouter, DataStrategyFunction, EntryContext, type FlashSessionData, HeadersFunction, HydrationState, IndexRouteObject, InitialEntry, type IsCookieFunction, type IsSessionFunction, LinksFunction, LoaderFunction, Location, MetaFunction, type NavigateFunction, NavigateOptions, Navigation, Action as NavigationType, NonIndexRouteObject, ParamParseKey, Params, PatchRoutesOnNavigationFunction, Path, PathMatch, PathPattern, RelativeRoutingType, type RequestHandler, RouteObject, RouterInit, RouterState, type RoutesTestStubProps, ServerBuild, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, ShouldRevalidateFunction, To, UIMatch, AssetsManifest as UNSAFE_AssetsManifest, MiddlewareEnabled as UNSAFE_MiddlewareEnabled, RSCDefaultRootErrorBoundary as UNSAFE_RSCDefaultRootErrorBoundary, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getHydrationData as UNSAFE_getHydrationData, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, createCookie, createCookieSessionStorage, createMemorySessionStorage, createRequestHandler, createRoutesStub, createSession, createSessionStorage, href, isCookie, isSession, type BrowserCreateFromReadableStreamFunction as unstable_BrowserCreateFromReadableStreamFunction, type DecodeActionFunction as unstable_DecodeActionFunction, type DecodeFormStateFunction as unstable_DecodeFormStateFunction, type DecodeReplyFunction as unstable_DecodeReplyFunction, type EncodeReplyFunction as unstable_EncodeReplyFunction, unstable_InitialContext, type LoadServerActionFunction as unstable_LoadServerActionFunction, RSCHydratedRouter as unstable_RSCHydratedRouter, type RSCManifestPayload as unstable_RSCManifestPayload, type RSCMatch as unstable_RSCMatch, type RSCPayload as unstable_RSCPayload, type RSCRenderPayload as unstable_RSCRenderPayload, type RSCRouteConfig as unstable_RSCRouteConfig, type RSCRouteConfigEntry as unstable_RSCRouteConfigEntry, type RSCRouteManifest as unstable_RSCRouteManifest, type RSCRouteMatch as unstable_RSCRouteMatch, RSCStaticRouter as unstable_RSCStaticRouter, unstable_RouterContextProvider, type SSRCreateFromReadableStreamFunction as unstable_SSRCreateFromReadableStreamFunction, createCallServer as unstable_createCallServer, getRSCStream as unstable_getRSCStream, unstable_matchRSCServerRequest, routeRSCServerRequest as unstable_routeRSCServerRequest, setDevServerHooks as unstable_setDevServerHooks, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };
+export { ActionFunction, AppLoadContext, Blocker, BlockerFunction, ClientActionFunction, ClientLoaderFunction, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, DataRouteObject, Router as DataRouter, DataStrategyFunction, EntryContext, type FlashSessionData, HeadersFunction, HydrationState, IndexRouteObject, InitialEntry, type IsCookieFunction, type IsSessionFunction, LinksFunction, LoaderFunction, Location, MetaFunction, type NavigateFunction, NavigateOptions, Navigation, Action as NavigationType, NonIndexRouteObject, ParamParseKey, Params, PatchRoutesOnNavigationFunction, Path, PathMatch, PathPattern, RelativeRoutingType, type RequestHandler, RouteObject, RouterInit, RouterState, type RoutesTestStubProps, ServerBuild, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, ShouldRevalidateFunction, To, UIMatch, AssetsManifest as UNSAFE_AssetsManifest, MiddlewareEnabled as UNSAFE_MiddlewareEnabled, RSCDefaultRootErrorBoundary as UNSAFE_RSCDefaultRootErrorBoundary, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getHydrationData as UNSAFE_getHydrationData, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, createCookie, createCookieSessionStorage, createMemorySessionStorage, createRequestHandler, createRoutesStub, createSession, createSessionStorage, href, isCookie, isSession, type BrowserCreateFromReadableStreamFunction as unstable_BrowserCreateFromReadableStreamFunction, type DecodeActionFunction as unstable_DecodeActionFunction, type DecodeFormStateFunction as unstable_DecodeFormStateFunction, type DecodeReplyFunction as unstable_DecodeReplyFunction, type EncodeReplyFunction as unstable_EncodeReplyFunction, unstable_InitialContext, type LoadServerActionFunction as unstable_LoadServerActionFunction, RSCHydratedRouter as unstable_RSCHydratedRouter, type RSCHydratedRouterProps as unstable_RSCHydratedRouterProps, type RSCManifestPayload as unstable_RSCManifestPayload, type RSCMatch as unstable_RSCMatch, type RSCPayload as unstable_RSCPayload, type RSCRenderPayload as unstable_RSCRenderPayload, type RSCRouteConfig as unstable_RSCRouteConfig, type RSCRouteConfigEntry as unstable_RSCRouteConfigEntry, type RSCRouteManifest as unstable_RSCRouteManifest, type RSCRouteMatch as unstable_RSCRouteMatch, RSCStaticRouter as unstable_RSCStaticRouter, type RSCStaticRouterProps as unstable_RSCStaticRouterProps, unstable_RouterContextProvider, type SSRCreateFromReadableStreamFunction as unstable_SSRCreateFromReadableStreamFunction, createCallServer as unstable_createCallServer, getRSCStream as unstable_getRSCStream, unstable_matchRSCServerRequest, routeRSCServerRequest as unstable_routeRSCServerRequest, setDevServerHooks as unstable_setDevServerHooks, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };