react-router 7.7.1 → 7.8.0-pre.0

package/dist/development/{index-react-server-client-Bi_fx8qz.d.ts → index-react-server-client-DSU6bZil.d.ts}

@@ -1,4 +1,4 @@
-import { I as InitialEntry, T as To, i as RelativeRoutingType, w as NonIndexRouteObject, ag as LazyRouteFunction, q as IndexRouteObject, a as Location, A as Action, aD as Navigator, d as Router$1, V as RouterInit, aZ as FutureConfig$1, H as HydrationState, D as DataStrategyFunction, X as PatchRoutesOnNavigationFunction, p as RouteObject, aF as RouteMatch, o as Params, U as UIMatch, af as HTMLFormMethod, ad as FormEncType, a_ as RouteManifest, a$ as ServerRouteModule, z as MiddlewareEnabled, y as unstable_RouterContextProvider, x as AppLoadContext, ah as LoaderFunctionArgs, a7 as ActionFunctionArgs, e as RouteModules, Y as DataRouteObject, K as ClientLoaderFunction, a0 as StaticHandlerContext, aK as PageLinkDescriptor, b0 as History, $ as GetScrollRestorationKeyFunction, f as NavigateOptions, a1 as Fetcher, h as SerializeFrom, B as BlockerFunction, b1 as CreateStaticHandlerOptions$1, Z as StaticHandler } from './routeModules-BR2FO0ix.js';
+import { I as InitialEntry, T as To, i as RelativeRoutingType, w as NonIndexRouteObject, af as LazyRouteFunction, q as IndexRouteObject, a as Location, A as Action, aC as Navigator, d as Router$1, Q as RouterInit, aY as FutureConfig$1, H as HydrationState, D as DataStrategyFunction, W as PatchRoutesOnNavigationFunction, p as RouteObject, aE as RouteMatch, o as Params, U as UIMatch, ae as HTMLFormMethod, ac as FormEncType, aZ as RouteManifest, a_ as ServerRouteModule, z as MiddlewareEnabled, y as unstable_RouterContextProvider, x as AppLoadContext, ag as LoaderFunctionArgs, a6 as ActionFunctionArgs, e as RouteModules, X as DataRouteObject, J as ClientLoaderFunction, $ as StaticHandlerContext, aJ as PageLinkDescriptor, a$ as History, _ as GetScrollRestorationKeyFunction, f as NavigateOptions, a0 as Fetcher, h as SerializeFrom, B as BlockerFunction, b0 as CreateStaticHandlerOptions$1, Y as StaticHandler } from './routeModules-D5bppTB2.js';
 import * as React from 'react';
 
 declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
@@ -14,8 +14,11 @@ interface MemoryRouterOpts {
      */
     basename?: string;
     /**
-     * Function to provide the initial context values for all client side
-     * navigations/fetches
+     * A function that returns an {@link unstable_RouterContextProvider} instance
+     * which is provided as the `context` argument to client [`action`](../../start/data/route-object#action)s,
+     * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
+     * This function is called to generate a fresh `context` instance on each
+     * navigation or fetcher call.
      */
     unstable_getContext?: RouterInit["unstable_getContext"];
     /**
@@ -32,7 +35,7 @@ interface MemoryRouterOpts {
      */
     initialEntries?: InitialEntry[];
     /**
-     * Index of {@link initialEntries} the application should initialize to
+     * Index of `initialEntries` the application should initialize to
      */
     initialIndex?: number;
     /**
@@ -89,7 +92,7 @@ interface RouterProviderProps {
  * Render the UI for the given {@link DataRouter}. This component should
  * typically be at the top of an app's element tree.
  *
- * @example
+ * ```tsx
  * import { createBrowserRouter } from "react-router";
  * import { RouterProvider } from "react-router/dom";
  * import { createRoot } from "react-dom/client";
@@ -98,6 +101,14 @@ interface RouterProviderProps {
  * createRoot(document.getElementById("root")).render(
  *   <RouterProvider router={router} />
  * );
+ * ```
+ *
+ * <docs-info>Please note that this component is exported both from
+ * `react-router` and `react-router/dom` with the only difference being that the
+ * latter automatically wires up `react-dom`'s [`flushSync`](https://react.dev/reference/react-dom/flushSync)
+ * implementation. You _almost always_ want to use the version from
+ * `react-router/dom` unless you're running in a non-DOM environment.</docs-info>
+ *
  *
  * @public
  * @category Data Routers
@@ -125,7 +136,7 @@ interface MemoryRouterProps {
      */
     initialEntries?: InitialEntry[];
     /**
-     * Index of {@link initialEntries} the application should initialize to
+     * Index of `initialEntries` the application should initialize to
      */
     initialIndex?: number;
 }
@@ -140,7 +151,8 @@ interface MemoryRouterProps {
  * @param {MemoryRouterProps.children} props.children n/a
  * @param {MemoryRouterProps.initialEntries} props.initialEntries n/a
  * @param {MemoryRouterProps.initialIndex} props.initialIndex n/a
- * @returns A declarative in memory router for client side routing.
+ * @returns A declarative in-memory {@link Router | `<Router>`} for client-side
+ * routing.
  */
 declare function MemoryRouter({ basename, children, initialEntries, initialIndex, }: MemoryRouterProps): React.ReactElement;
 /**
@@ -161,7 +173,7 @@ interface NavigateProps {
      */
     state?: any;
     /**
-     * How to interpret relative routing in the {@link to} prop.
+     * How to interpret relative routing in the `to` prop.
      * See {@link RelativeRoutingType}.
      */
     relative?: RelativeRoutingType;
@@ -279,32 +291,32 @@ interface PathRouteProps {
     children?: React.ReactNode;
     /**
      * The React element to render when this Route matches.
-     * Mutually exclusive with {@link Component}.
+     * Mutually exclusive with `Component`.
      */
     element?: React.ReactNode | null;
     /**
      * The React element to render while this router is loading data.
-     * Mutually exclusive with {@link HydrateFallback}.
+     * Mutually exclusive with `HydrateFallback`.
      */
     hydrateFallbackElement?: React.ReactNode | null;
     /**
      * The React element to render at this route if an error occurs.
-     * Mutually exclusive with {@link ErrorBoundary}.
+     * Mutually exclusive with `ErrorBoundary`.
      */
     errorElement?: React.ReactNode | null;
     /**
      * The React Component to render when this route matches.
-     * Mutually exclusive with {@link element}.
+     * Mutually exclusive with `element`.
      */
     Component?: React.ComponentType | null;
     /**
      * The React Component to render while this router is loading data.
-     * Mutually exclusive with {@link hydrateFallbackElement}.
+     * Mutually exclusive with `hydrateFallbackElement`.
      */
     HydrateFallback?: React.ComponentType | null;
     /**
      * The React Component to render at this route if an error occurs.
-     * Mutually exclusive with {@link errorElement}.
+     * Mutually exclusive with `errorElement`.
      */
     ErrorBoundary?: React.ComponentType | null;
 }
@@ -366,32 +378,32 @@ interface IndexRouteProps {
     children?: undefined;
     /**
      * The React element to render when this Route matches.
-     * Mutually exclusive with {@link Component}.
+     * Mutually exclusive with `Component`.
      */
     element?: React.ReactNode | null;
     /**
      * The React element to render while this router is loading data.
-     * Mutually exclusive with {@link HydrateFallback}.
+     * Mutually exclusive with `HydrateFallback`.
      */
     hydrateFallbackElement?: React.ReactNode | null;
     /**
      * The React element to render at this route if an error occurs.
-     * Mutually exclusive with {@link ErrorBoundary}.
+     * Mutually exclusive with `ErrorBoundary`.
      */
     errorElement?: React.ReactNode | null;
     /**
      * The React Component to render when this route matches.
-     * Mutually exclusive with {@link element}.
+     * Mutually exclusive with `element`.
      */
     Component?: React.ComponentType | null;
     /**
      * The React Component to render while this router is loading data.
-     * Mutually exclusive with {@link hydrateFallbackElement}.
+     * Mutually exclusive with `hydrateFallbackElement`.
      */
     HydrateFallback?: React.ComponentType | null;
     /**
      * The React Component to render at this route if an error occurs.
-     * Mutually exclusive with {@link errorElement}.
+     * Mutually exclusive with `errorElement`.
      */
     ErrorBoundary?: React.ComponentType | null;
 }
@@ -471,7 +483,7 @@ interface RouterProps {
      */
     location: Partial<Location> | string;
     /**
-     * The type of navigation that triggered this location change.
+     * The type of navigation that triggered this `location` change.
      * Defaults to {@link NavigationType.Pop}.
      */
     navigationType?: Action;
@@ -1056,9 +1068,23 @@ type DiscoverBehavior = "render" | "none";
  */
 type PrefetchBehavior = "intent" | "render" | "none" | "viewport";
 /**
- * Renders all of the `<link>` tags created by the route module
- * [`links`](../../start/framework/route-module#links) export. You should render
- * it inside the `<head>` of your document.
+ * Props for the {@link Links} component.
+ *
+ * @category Types
+ */
+interface LinksProps {
+    /**
+     * A [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
+     * attribute to render on the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
+     * element
+     */
+    nonce?: string | undefined;
+}
+/**
+ * Renders all the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
+ * tags created by the route module's [`links`](../../start/framework/route-module#links)
+ * export. You should render it inside the [`<head>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/head)
+ * of your document.
  *
  * @example
  * import { Links } from "react-router";
@@ -1077,14 +1103,17 @@ type PrefetchBehavior = "intent" | "render" | "none" | "viewport";
  * @public
  * @category Components
  * @mode framework
- * @returns A collection of React elements for `<link>` tags
+ * @param props Props
+ * @param {LinksProps.nonce} props.nonce n/a
+ * @returns A collection of React elements for [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
+ * tags
  */
-declare function Links(): React.JSX.Element;
+declare function Links({ nonce }: LinksProps): React.JSX.Element;
 /**
- * Renders `<link rel=prefetch|modulepreload>` tags for modules and data of
- * another page to enable an instant navigation to that page.
- * [`<Link prefetch>`](../../components/Link#prefetch) uses this internally, but
- * you can render it to prefetch a page for any other reason.
+ * Renders [`<link rel=prefetch|modulepreload>`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement/rel)
+ * tags for modules and data of another page to enable an instant navigation to
+ * that page. [`<Link prefetch>`](./Link#prefetch) uses this internally, but you
+ * can render it to prefetch a page for any other reason.
  *
  * For example, you may render one of this as the user types into a search field
  * to prefetch search results before they click through to their selection.
@@ -1098,17 +1127,21 @@ declare function Links(): React.JSX.Element;
  * @category Components
  * @mode framework
  * @param props Props
- * @param props.page The absolute path of the page to prefetch, e.g. `/absolute/path`.
- * @param props.linkProps Additional props to spread onto the
- * [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/link)
- * tags, such as `crossOrigin`, `integrity`, `rel`, etc.
- * @returns A collection of React elements for `<link>` tags
+ * @param {PageLinkDescriptor.page} props.page n/a
+ * @param props.linkProps Additional props to spread onto the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
+ * tags, such as [`crossOrigin`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement/crossOrigin),
+ * [`integrity`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement/integrity),
+ * [`rel`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement/rel),
+ * etc.
+ * @returns A collection of React elements for [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
+ * tags
  */
 declare function PrefetchPageLinks({ page, ...linkProps }: PageLinkDescriptor): React.JSX.Element | null;
 /**
- * Renders all the `<meta>` tags created by the route module
- * [`meta`](../../start/framework/route-module#meta) exports. You should render
- * it inside the `<head>` of your HTML.
+ * Renders all the [`<meta>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta)
+ * tags created by the route module's [`meta`](../../start/framework/route-module#meta)
+ * export. You should render it inside the [`<head>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/head)
+ * of your document.
  *
  * @example
  * import { Meta } from "react-router";
@@ -1126,29 +1159,40 @@ declare function PrefetchPageLinks({ page, ...linkProps }: PageLinkDescriptor):
  * @public
  * @category Components
  * @mode framework
- * @returns A collection of React elements for `<meta>` tags
+ * @returns A collection of React elements for [`<meta>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/meta)
+ * tags
  */
 declare function Meta(): React.JSX.Element;
 /**
  * A couple common attributes:
  *
- * - `<Scripts crossOrigin>` for hosting your static assets on a different server than your app.
- * - `<Scripts nonce>` to support a [content security policy for scripts](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src) with [nonce-sources](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/Sources#sources) for your `<script>` tags.
+ * - `<Scripts crossOrigin>` for hosting your static assets on a different
+ *   server than your app.
+ * - `<Scripts nonce>` to support a [content security policy for scripts](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src)
+ * with [nonce-sources](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/Sources#sources)
+ * for your [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
+ * tags.
  *
- * You cannot pass through attributes such as `async`, `defer`, `src`, `type`, `noModule` because they are managed by React Router internally.
+ * You cannot pass through attributes such as [`async`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement/async),
+ * [`defer`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement/defer),
+ * [`noModule`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement/noModule),
+ * [`src`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement/src),
+ * or [`type`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement/type),
+ * because they are managed by React Router internally.
  *
  * @category Types
  */
-type ScriptsProps = Omit<React.HTMLProps<HTMLScriptElement>, "async" | "children" | "dangerouslySetInnerHTML" | "defer" | "src" | "type" | "noModule" | "suppressHydrationWarning"> & {
+type ScriptsProps = Omit<React.HTMLProps<HTMLScriptElement>, "async" | "children" | "dangerouslySetInnerHTML" | "defer" | "noModule" | "src" | "suppressHydrationWarning" | "type"> & {
     /**
      * A [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
-     * attribute to render on [the `<script>` element](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script)
+     * attribute to render on the [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
+     * element
      */
     nonce?: string | undefined;
 };
 /**
  * Renders the client runtime of your app. It should be rendered inside the
- * [`<body>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/body)
+ * [`<body>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/body)
  *  of the document.
  *
  * If server rendering, you can omit `<Scripts/>` and the app will work as a
@@ -1172,10 +1216,12 @@ type ScriptsProps = Omit<React.HTMLProps<HTMLScriptElement>, "async" | "children
  * @public
  * @category Components
  * @mode framework
- * @param scriptProps Additional props to spread onto the
- * [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script)
- * tag, such as `crossOrigin`, `nonce`, etc.
- * @returns A collection of React elements for `<script>` tags
+ * @param scriptProps Additional props to spread onto the [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
+ * tags, such as [`crossOrigin`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement/crossOrigin),
+ * [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce),
+ * etc.
+ * @returns A collection of React elements for [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
+ * tags
  */
 declare function Scripts(scriptProps: ScriptsProps): React.JSX.Element | null;
 
@@ -1188,7 +1234,11 @@ interface DOMRouterOpts {
      */
     basename?: string;
     /**
-     * Function to provide the initial `context` values for all client side navigations/fetches
+     * A function that returns an {@link unstable_RouterContextProvider} instance
+     * which is provided as the `context` argument to client [`action`](../../start/data/route-object#action)s,
+     * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
+     * This function is called to generate a fresh `context` instance on each
+     * navigation or fetcher call.
      */
     unstable_getContext?: RouterInit["unstable_getContext"];
     /**
@@ -1196,10 +1246,11 @@ interface DOMRouterOpts {
      */
     future?: Partial<FutureConfig$1>;
     /**
-     * When Server-Rendering and opting-out of automatic hydration, the `hydrationData`
-     * option allows you to pass in hydration data from your server-render. This will
-     * almost always be a subset of data from the {@link StaticHandlerContext} value you
-     * get back from the `{@link StaticHandler} `query()` method:
+     * When Server-Rendering and opting-out of automatic hydration, the
+     * `hydrationData` option allows you to pass in hydration data from your
+     * server-render. This will almost always be a subset of data from the
+     * {@link StaticHandlerContext} value you get back from {@link StaticHandler}'s
+     * `query` method:
      *
      * ```tsx
      * const router = createBrowserRouter(routes, {
@@ -1216,18 +1267,23 @@ interface DOMRouterOpts {
      *
      * You will almost always include a complete set of `loaderData` to hydrate a
      * server-rendered app. But in advanced use-cases (such as Framework Mode's
-     * `clientLoader`), you may want to include `loaderData` for only some routes
-     * that were loaded/rendered on the server. This allows you to hydrate _some_
-     * of the routes (such as the app layout/shell) while showing a `HydrateFallback`
-     * and running the loaders for other routes during hydration.
-     *
-     * A route `loader` will run during hydration in 2 scenarios:
-     *
-     *  - No hydration data is provided
-     *    - In these cases the `HydrateFallback` component will render on initial hydration
-     *  - The `loader.hydrate` property is set to true
-     *    - This allows you to run the loader even if you did not render a fallback
-     *      on initial hydration (i.e., to prime a cache with hydration data)
+     * [`clientLoader`](../../start/framework/route-module#clientLoader)), you may
+     * want to include `loaderData` for only some routes that were loaded/rendered
+     * on the server. This allows you to hydrate _some_ of the routes (such as the
+     * app layout/shell) while showing a `HydrateFallback` component and running
+     * the [`loader`](../../start/data/route-object#loader)s for other routes
+     * during hydration.
+     *
+     * A route [`loader`](../../start/data/route-object#loader) will run during
+     * hydration in two scenarios:
+     *
+     *  1. No hydration data is provided
+     *     In these cases the `HydrateFallback` component will render on initial
+     *     hydration
+     *  2. The `loader.hydrate` property is set to `true`
+     *     This allows you to run the [`loader`](../../start/data/route-object#loader)
+     *     even if you did not render a fallback on initial hydration (i.e., to
+     *     prime a cache with hydration data)
      *
      * ```tsx
      * const router = createBrowserRouter(
@@ -1263,31 +1319,36 @@ interface DOMRouterOpts {
      * See {@link DataStrategyFunction}.
      *
      * <docs-warning>This is a low-level API intended for advanced use-cases. This
-     * overrides React Router's internal handling of `loader`/`action` execution,
-     * and if done incorrectly will break your app code. Please use with caution
-     * and perform the appropriate testing.</docs-warning>
+     * overrides React Router's internal handling of
+     * [`action`](../../start/data/route-object#action)/[`loader`](../../start/data/route-object#loader)
+     * execution, and if done incorrectly will break your app code. Please use
+     * with caution and perform the appropriate testing.</docs-warning>
      *
      * By default, React Router is opinionated about how your data is loaded/submitted -
-     * and most notably, executes all of your loaders in parallel for optimal data
-     * fetching. While we think this is the right behavior for most use-cases, we
-     * realize that there is no "one size fits all" solution when it comes to data
-     * fetching for the wide landscape of application requirements.
-     *
-     * The `dataStrategy` option gives you full control over how your loaders and
-     * actions are executed and lays the foundation to build in more advanced APIs
-     * such as middleware, context, and caching layers. Over time, we expect that
-     * we'll leverage this API internally to bring more first class APIs to React
-     * Router, but until then (and beyond), this is your way to add more advanced
-     * functionality for your applications data needs.
-     *
-     * The `dataStrategy` function should return a key/value object of
-     * `routeId` -> {@link DataStrategyResult} and should include entries for any routes
-     * where a handler was executed. A `DataStrategyResult` indicates if the handler
-     * was successful or not based on the `DataStrategyResult.type` field. If the
-     * returned `DataStrategyResult["result"]` is a `Response`, React Router will
-     * unwrap it for you (via `res.json` or `res.text`). If you need to do custom
-     * decoding of a `Response` but want to preserve the status code, you can use
-     * the `data` utility to return your decoded data along with a `ResponseInit`.
+     * and most notably, executes all of your [`loader`](../../start/data/route-object#loader)s
+     * in parallel for optimal data fetching. While we think this is the right
+     * behavior for most use-cases, we realize that there is no "one size fits all"
+     * solution when it comes to data fetching for the wide landscape of
+     * application requirements.
+     *
+     * The `dataStrategy` option gives you full control over how your [`action`](../../start/data/route-object#action)s
+     * and [`loader`](../../start/data/route-object#loader)s are executed and lays
+     * the foundation to build in more advanced APIs such as middleware, context,
+     * and caching layers. Over time, we expect that we'll leverage this API
+     * internally to bring more first class APIs to React Router, but until then
+     * (and beyond), this is your way to add more advanced functionality for your
+     * application's data needs.
+     *
+     * The `dataStrategy` function should return a key/value-object of
+     * `routeId` -> {@link DataStrategyResult} and should include entries for any
+     * routes where a handler was executed. A `DataStrategyResult` indicates if
+     * the handler was successful or not based on the `DataStrategyResult.type`
+     * field. If the returned `DataStrategyResult.result` is a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response),
+     * React Router will unwrap it for you (via [`res.json`](https://developer.mozilla.org/en-US/docs/Web/API/Response/json)
+     * or [`res.text`](https://developer.mozilla.org/en-US/docs/Web/API/Response/text)).
+     * If you need to do custom decoding of a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+     * but want to preserve the status code, you can use the `data` utility to
+     * return your decoded data along with a `ResponseInit`.
      *
      * <details>
      * <summary><b>Example <code>dataStrategy</code> Use Cases</b></summary>
@@ -1295,13 +1356,14 @@ interface DOMRouterOpts {
      * **Adding logging**
      *
      * In the simplest case, let's look at hooking into this API to add some logging
-     * for when our route loaders/actions execute:
+     * for when our route [`action`](../../start/data/route-object#action)s/[`loader`](../../start/data/route-object#loader)s
+     * execute:
      *
-     * ```ts
+     * ```tsx
      * let router = createBrowserRouter(routes, {
-     *   async dataStrategy({ request, matches }) {
+     *   async dataStrategy({ matches, request }) {
      *     const matchesToLoad = matches.filter((m) => m.shouldLoad);
-     *     const results = {};
+     *     const results: Record<string, DataStrategyResult> = {};
      *     await Promise.all(
      *       matchesToLoad.map(async (match) => {
      *         console.log(`Processing ${match.route.id}`);
@@ -1315,9 +1377,10 @@ interface DOMRouterOpts {
      *
      * **Middleware**
      *
-     * Let's define a middleware on each route via `handle` and call middleware
-     * sequentially first, then call all loaders in parallel - providing any data
-     * made available via the middleware:
+     * Let's define a middleware on each route via [`handle`](../../start/data/route-object#handle)
+     * and call middleware sequentially first, then call all
+     * [`loader`](../../start/data/route-object#loader)s in parallel - providing
+     * any data made available via the middleware:
      *
      * ```ts
      * const routes = [
@@ -1350,7 +1413,7 @@ interface DOMRouterOpts {
      * ];
      *
      * let router = createBrowserRouter(routes, {
-     *   async dataStrategy({ request, params, matches }) {
+     *   async dataStrategy({ matches, params, request }) {
      *     // Run middleware sequentially and let them add data to `context`
      *     let context = {};
      *     for (const match of matches) {
@@ -1386,11 +1449,11 @@ interface DOMRouterOpts {
      *
      * **Custom Handler**
      *
-     * It's also possible you don't even want to define a loader implementation at
-     * the route level. Maybe you want to just determine the routes and issue a single
-     * GraphQL request for all of your data? You can do that by setting your
-     * `route.loader=true` so it qualifies as "having a loader", and then store GQL
-     * fragments on `route.handle`:
+     * It's also possible you don't even want to define a [`loader`](../../start/data/route-object#loader)
+     * implementation at the route level. Maybe you want to just determine the
+     * routes and issue a single GraphQL request for all of your data? You can do
+     * that by setting your `route.loader=true` so it qualifies as "having a
+     * loader", and then store GQL fragments on `route.handle`:
      *
      * ```ts
      * const routes = [
@@ -1423,7 +1486,7 @@ interface DOMRouterOpts {
      * ];
      *
      * let router = createBrowserRouter(routes, {
-     *   async dataStrategy({ request, params, matches }) {
+     *   async dataStrategy({ matches, params, request }) {
      *     // Compose route fragments into a single GQL payload
      *     let gql = getFragmentsFromRouteHandles(matches);
      *     let data = await fetchGql(gql);
@@ -1445,37 +1508,39 @@ interface DOMRouterOpts {
      * `createBrowserRouter(routes)`. This allows React Router to perform synchronous
      * route matching, execute loaders, and then render route components in the most
      * optimistic manner without introducing waterfalls. The tradeoff is that your
-     * initial JS bundle is larger by definition - which may slow down application
+     * initial JS bundle is larger by definition — which may slow down application
      * start-up times as your application grows.
      *
-     * To combat this, we introduced [`route.lazy`][route-lazy] in [v6.9.0][6-9-0]
-     * which let's you lazily load the route _implementation_ (`loader`, `Component`,
-     * etc.) while still providing the route _definition_ aspects up front (`path`,
-     * `index`, etc.). This is a good middle ground because React Router still knows
-     * about your route definitions (the lightweight part) up front and can perform
-     * synchronous route matching, but then delay loading any of the route implementation
+     * To combat this, we introduced [`route.lazy`](../../start/data/route-object#lazy)
+     * in [v6.9.0](https://github.com/remix-run/react-router/blob/main/CHANGELOG.md#v690)
+     * which lets you lazily load the route _implementation_ ([`loader`](../../start/data/route-object#loader),
+     * [`Component`](../../start/data/route-object#Component), etc.) while still
+     * providing the route _definition_ aspects up front (`path`, `index`, etc.).
+     * This is a good middle ground. React Router still knows about your route
+     * definitions (the lightweight part) up front and can perform synchronous
+     * route matching, but then delay loading any of the route implementation
      * aspects (the heavier part) until the route is actually navigated to.
      *
-     * In some cases, even this doesn't go far enough. For very large applications,
+     * In some cases, even this doesn't go far enough. For huge applications,
      * providing all route definitions up front can be prohibitively expensive.
      * Additionally, it might not even be possible to provide all route definitions
      * up front in certain Micro-Frontend or Module-Federation architectures.
      *
-     * This is where `patchRoutesOnNavigation` comes in ([RFC][fog-of-war-rfc]).
+     * This is where `patchRoutesOnNavigation` comes in ([RFC](https://github.com/remix-run/react-router/discussions/11113)).
      * This API is for advanced use-cases where you are unable to provide the full
      * route tree up-front and need a way to lazily "discover" portions of the route
-     * tree at runtime. This feature is often referred to as ["Fog of War"][fog-of-war]
+     * tree at runtime. This feature is often referred to as ["Fog of War"](https://en.wikipedia.org/wiki/Fog_of_war),
      * because similar to how video games expand the "world" as you move around -
      * the router would be expanding its routing tree as the user navigated around
      * the app - but would only ever end up loading portions of the tree that the
      * user visited.
      *
      * `patchRoutesOnNavigation` will be called anytime React Router is unable to
-     * match a `path`. The arguments include the `path`, any partial `matches`, and
-     * a `patch` function you can call to patch new routes into the tree at a
+     * match a `path`. The arguments include the `path`, any partial `matches`,
+     * and a `patch` function you can call to patch new routes into the tree at a
      * specific location. This method is executed during the `loading` portion of
-     * the navigation for `GET` requests and during the `submitting` portion of the
-     * navigation for non-`GET` requests.
+     * the navigation for `GET` requests and during the `submitting` portion of
+     * the navigation for non-`GET` requests.
      *
      * <details>
      *   <summary><b>Example <code>patchRoutesOnNavigation</code> Use Cases</b></summary>
@@ -1492,7 +1557,7 @@ interface DOMRouterOpts {
      *       },
      *     ],
      *     {
-     *       async patchRoutesOnNavigation({ path, patch }) {
+     *       async patchRoutesOnNavigation({ patch, path }) {
      *         if (path === "/a") {
      *           // Load/patch the `a` route as a child of the route with id `root`
      *           let route = await getARoute();
@@ -1504,13 +1569,13 @@ interface DOMRouterOpts {
      *   );
      *   ```
      *
-     *   In the above example, if the user clicks a link to `/a`, React Router won't
-     *   match any routes initially and will call `patchRoutesOnNavigation` with a
-     *   `path = "/a"` and a `matches` array containing the root route match. By calling
-     *   `patch('root', [route])`, the new route will be added to the route tree as a
-     *   child of the `root` route and React Router will perform matching on the updated
-     *   routes. This time it will successfully match the `/a` path and the navigation
-     *   will complete successfully.
+     *   In the above example, if the user clicks a link to `/a`, React Router
+     *   won't match any routes initially and will call `patchRoutesOnNavigation`
+     *   with a `path = "/a"` and a `matches` array containing the root route
+     *   match. By calling `patch('root', [route])`, the new route will be added
+     *   to the route tree as a child of the `root` route and React Router will
+     *   perform matching on the updated routes. This time it will successfully
+     *   match the `/a` path and the navigation will complete successfully.
      *
      *   **Patching new root-level routes**
      *
@@ -1527,7 +1592,7 @@ interface DOMRouterOpts {
      *       },
      *     ],
      *     {
-     *       async patchRoutesOnNavigation({ path, patch }) {
+     *       async patchRoutesOnNavigation({ patch, path }) {
      *         if (path === "/root-sibling") {
      *           // Load/patch the `/root-sibling` route as a sibling of the root route
      *           let route = await getRootSiblingRoute();
@@ -1539,12 +1604,12 @@ interface DOMRouterOpts {
      *   );
      *   ```
      *
-     *   **Patching sub-trees asynchronously**
+     *   **Patching subtrees asynchronously**
      *
      *   You can also perform asynchronous matching to lazily fetch entire sections
-     * of your application:
+     *   of your application:
      *
-     *   ```jsx
+     *   ```tsx
      *   let router = createBrowserRouter(
      *     [
      *       {
@@ -1553,7 +1618,7 @@ interface DOMRouterOpts {
      *       },
      *     ],
      *     {
-     *       async patchRoutesOnNavigation({ path, patch }) {
+     *       async patchRoutesOnNavigation({ patch, path }) {
      *         if (path.startsWith("/dashboard")) {
      *           let children = await import("./dashboard");
      *           patch(null, children);
@@ -1568,17 +1633,17 @@ interface DOMRouterOpts {
      *   ```
      *
      *   <docs-info>If in-progress execution of `patchRoutesOnNavigation` is
-     *   interrupted by a subsequent navigation, then any remaining `patch` calls
-     *   in the interrupted execution will not update the route tree because the
+     *   interrupted by a later navigation, then any remaining `patch` calls in
+     *   the interrupted execution will not update the route tree because the
      *   operation was cancelled.</docs-info>
      *
      *   **Co-locating route discovery with route definition**
      *
-     *   If you don't wish to perform your own pseudo-matching, you can leverage the
-     * partial `matches` array and the `handle` field on a route to keep the children
-     * definitions co-located:
+     *   If you don't wish to perform your own pseudo-matching, you can leverage
+     *   the partial `matches` array and the [`handle`](../../start/data/route-object#handle)
+     *   field on a route to keep the children definitions co-located:
      *
-     *   ```jsx
+     *   ```tsx
      *   let router = createBrowserRouter(
      *     [
      *       {
@@ -1629,18 +1694,19 @@ interface DOMRouterOpts {
      *
      *   **A note on routes with parameters**
      *
-     *   Because React Router uses ranked routes to find the best match for a given
-     *   path, there is an interesting ambiguity introduced when only a partial route
-     *   tree is known at any given point in time. If we match a fully static route
-     *   such as `path: "/about/contact-us"` then we know we've found the right match
-     *   since it's composed entirely of static URL segments, and thus we do not need
-     *   to bother asking for any other potentially higher-scoring routes.
+     *   Because React Router uses ranked routes to find the best match for a
+     *   given path, there is an interesting ambiguity introduced when only a
+     *   partial route tree is known at any given point in time. If we match a
+     *   fully static route such as `path: "/about/contact-us"` then we know we've
+     *   found the right match since it's composed entirely of static URL segments.
+     *   Thus, we do not need to bother asking for any other potentially
+     *   higher-scoring routes.
      *
-     *   However, routes with parameters (dynamic or splat) can't make this assumption
-     *   because there might be a not-yet-discovered route tht scores higher. Consider
-     *   a full route tree such as:
+     *   However, routes with parameters (dynamic or splat) can't make this
+     *   assumption because there might be a not-yet-discovered route that scores
+     *   higher. Consider a full route tree such as:
      *
-     *   ```js
+     *   ```tsx
      *   // Assume this is the full route tree for your app
      *   const routes = [
      *     {
@@ -1662,7 +1728,7 @@ interface DOMRouterOpts {
      *   And then assume we want to use `patchRoutesOnNavigation` to fill this in
      *   as the user navigates around:
      *
-     *   ```js
+     *   ```tsx
      *   // Start with only the index route
      *   const router = createBrowserRouter(
      *     [
@@ -1672,7 +1738,7 @@ interface DOMRouterOpts {
      *       },
      *     ],
      *     {
-     *       patchRoutesOnNavigation({ path, patch }) {
+     *       async patchRoutesOnNavigation({ patch, path }) {
      *         if (path === "/blog/new") {
      *           patch("blog", [
      *             {
@@ -1693,28 +1759,30 @@ interface DOMRouterOpts {
      *   );
      *   ```
      *
-     *   If the user were to a blog post first (i.e., `/blog/my-post`) we would patch
-     *   in the `:slug` route. Then if the user navigated to `/blog/new` to write a
-     *   new post, we'd match `/blog/:slug` but it wouldn't be the _right_ match!
-     *   We need to call `patchRoutesOnNavigation` just in case there exists a
-     *   higher-scoring route we've not yet discovered, which in this case there is.
+     *   If the user were to a blog post first (i.e., `/blog/my-post`) we would
+     *   patch in the `:slug` route. Then, if the user navigated to `/blog/new` to
+     *   write a new post, we'd match `/blog/:slug` but it wouldn't be the _right_
+     *   match! We need to call `patchRoutesOnNavigation` just in case there
+     *   exists a higher-scoring route we've not yet discovered, which in this
+     *   case there is.
      *
      *   So, anytime React Router matches a path that contains at least one param,
      *   it will call `patchRoutesOnNavigation` and match routes again just to
      *   confirm it has found the best match.
      *
      *   If your `patchRoutesOnNavigation` implementation is expensive or making
-     *   side-effect `fetch` calls to a backend server, you may want to consider
-     *   tracking previously seen routes to avoid over-fetching in cases where you
-     *   know the proper route has already been found. This can usually be as simple
-     *   as maintaining a small cache of prior `path` values for which you've already
+     *   side effect [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch)
+     *   calls to a backend server, you may want to consider tracking previously
+     *   seen routes to avoid over-fetching in cases where you know the proper
+     *   route has already been found. This can usually be as simple as
+     *   maintaining a small cache of prior `path` values for which you've already
      *   patched in the right routes:
      *
-     *   ```js
+     *   ```tsx
      *   let discoveredRoutes = new Set();
      *
      *   const router = createBrowserRouter(routes, {
-     *     patchRoutesOnNavigation({ path, patch }) {
+     *     async patchRoutesOnNavigation({ patch, path }) {
      *       if (discoveredRoutes.has(path)) {
      *         // We've seen this before so nothing to patch in and we can let the router
      *         // use the routes it already knows about
@@ -1732,7 +1800,7 @@ interface DOMRouterOpts {
     patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
     /**
      * [`Window`](https://developer.mozilla.org/en-US/docs/Web/API/Window) object
-     * override - defaults to the global `window` instance.
+     * override. Defaults to the global `window` instance.
      */
     window?: Window;
 }
@@ -1779,8 +1847,18 @@ declare function createHashRouter(routes: RouteObject[], opts?: DOMRouterOpts):
  * @category Types
  */
 interface BrowserRouterProps {
+    /**
+     * Application basename
+     */
     basename?: string;
+    /**
+     * {@link Route | `<Route>`} components describing your route configuration
+     */
     children?: React.ReactNode;
+    /**
+     * [`Window`](https://developer.mozilla.org/en-US/docs/Web/API/Window) object
+     * override. Defaults to the global `window` instance
+     */
     window?: Window;
 }
 /**
@@ -1791,10 +1869,9 @@ interface BrowserRouterProps {
  * @category Declarative Routers
  * @mode declarative
  * @param props Props
- * @param props.basename Application basename
- * @param props.children {@link Route | `<Route>`} components describing your route configuration
- * @param props.window [`Window`](https://developer.mozilla.org/en-US/docs/Web/API/Window)
- * object override - defaults to the global `window` instance
+ * @param {BrowserRouterProps.basename} props.basename n/a
+ * @param {BrowserRouterProps.children} props.children n/a
+ * @param {BrowserRouterProps.window} props.window n/a
  * @returns A declarative {@link Router | `<Router>`} using the browser [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
  * API for client-side routing.
  */
@@ -1803,8 +1880,18 @@ declare function BrowserRouter({ basename, children, window, }: BrowserRouterPro
  * @category Types
  */
 interface HashRouterProps {
+    /**
+     * Application basename
+     */
     basename?: string;
+    /**
+     * {@link Route | `<Route>`} components describing your route configuration
+     */
     children?: React.ReactNode;
+    /**
+     * [`Window`](https://developer.mozilla.org/en-US/docs/Web/API/Window) object
+     * override. Defaults to the global `window` instance
+     */
     window?: Window;
 }
 /**
@@ -1816,10 +1903,9 @@ interface HashRouterProps {
  * @category Declarative Routers
  * @mode declarative
  * @param props Props
- * @param props.basename Application basename
- * @param props.children {@link Route | `<Route>`} components describing your route configuration
- * @param props.window [`Window`](https://developer.mozilla.org/en-US/docs/Web/API/Window)
- * object override - defaults to the global `window` instance
+ * @param {HashRouterProps.basename} props.basename n/a
+ * @param {HashRouterProps.children} props.children n/a
+ * @param {HashRouterProps.window} props.window n/a
  * @returns A declarative {@link Router | `<Router>`} using the URL [`hash`](https://developer.mozilla.org/en-US/docs/Web/API/URL/hash)
  * for client-side routing.
  */
@@ -1828,8 +1914,17 @@ declare function HashRouter({ basename, children, window }: HashRouterProps): Re
  * @category Types
  */
 interface HistoryRouterProps {
+    /**
+     * Application basename
+     */
     basename?: string;
+    /**
+     * {@link Route | `<Route>`} components describing your route configuration
+     */
     children?: React.ReactNode;
+    /**
+     *  A {@link History} implementation for use by the router
+     */
     history: History;
 }
 /**
@@ -1844,10 +1939,11 @@ interface HistoryRouterProps {
  * @category Declarative Routers
  * @mode declarative
  * @param props Props
- * @param props.basename Application basename
- * @param props.children {@link Route | `<Route>`} components describing your route configuration
- * @param props.history A history implementation for use by the router
- * @returns A declarative router using the provided history implementation for client-side routing.
+ * @param {HistoryRouterProps.basename} props.basename n/a
+ * @param {HistoryRouterProps.children} props.children n/a
+ * @param {HistoryRouterProps.history} props.history n/a
+ * @returns A declarative {@link Router | `<Router>`} using the provided history
+ * implementation for client-side routing.
  */
 declare function HistoryRouter({ basename, children, history, }: HistoryRouterProps): React.JSX.Element;
 declare namespace HistoryRouter {
@@ -1866,8 +1962,8 @@ interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>,
      * <Link discover="none" />
      * ```
      *
-     * - **render** - default, discover the route when the link renders
-     * - **none** - don't eagerly discover, only discover if the link is clicked
+     * - **render** — default, discover the route when the link renders
+     * - **none** — don't eagerly discover, only discover if the link is clicked
      */
     discover?: DiscoverBehavior;
     /**
@@ -1881,10 +1977,10 @@ interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>,
      * <Link prefetch="viewport" />
      * ```
      *
-     * - **none** - default, no prefetching
-     * - **intent** - prefetches when the user hovers or focuses the link
-     * - **render** - prefetches when the link renders
-     * - **viewport** - prefetches when the link is in the viewport, very useful for mobile
+     * - **none** — default, no prefetching
+     * - **intent** — prefetches when the user hovers or focuses the link
+     * - **render** — prefetches when the link renders
+     * - **viewport** — prefetches when the link is in the viewport, very useful for mobile
      *
      * Prefetching is done with HTML [`<link rel="prefetch">`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
      * tags. They are inserted after the link.
@@ -1912,7 +2008,7 @@ interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>,
     reloadDocument?: boolean;
     /**
      * Replaces the current entry in the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
-     * stack instead of pushing a new one  onto it.
+     * stack instead of pushing a new one onto it.
      *
      * ```tsx
      * <Link replace />
@@ -1973,10 +2069,10 @@ interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>,
      * Consider a route hierarchy where a parent route pattern is `"blog"` and a child
      * route pattern is `"blog/:slug/edit"`.
      *
-     * - **route** - default, resolves the link relative to the route pattern. In the
-     * example above, a relative link of `".."` will remove both `:slug/edit` segments
+     * - **route** — default, resolves the link relative to the route pattern. In the
+     * example above, a relative link of `"..."` will remove both `:slug/edit` segments
      * back to `"/blog"`.
-     * - **path** - relative to the path so `".."` will only remove one URL segment up
+     * - **path** — relative to the path so `"..."` will only remove one URL segment up
      * to `"/blog/:slug"`
      *
      * Note that index routes and layout routes do not have paths so they are not
@@ -2228,11 +2324,11 @@ declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefA
  */
 interface SharedFormProps extends React.FormHTMLAttributes<HTMLFormElement> {
     /**
-     * The HTTP verb to use when the form is submitted. Supports "get", "post",
-     * "put", "delete", and "patch".
+     * The HTTP verb to use when the form is submitted. Supports `"delete"`,
+     * `"get"`, `"patch"`, `"post"`, and `"put"`.
      *
      * Native [`<form>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form)
-     * only supports `get` and `post`, avoid the other verbs if you'd like to
+     * only supports `"get"` and `"post"`, avoid the other verbs if you'd like to
      * support progressive enhancement
      */
     method?: HTMLFormMethod;
@@ -2291,8 +2387,8 @@ interface FormProps extends SharedFormProps {
      * <Link discover="none" />
      * ```
      *
-     * - **render** - default, discover the route when the link renders
-     * - **none** - don't eagerly discover, only discover if the link is clicked
+     * - **render** — default, discover the route when the link renders
+     * - **none** — don't eagerly discover, only discover if the link is clicked
      */
     discover?: DiscoverBehavior;
     /**
@@ -2331,7 +2427,7 @@ interface FormProps extends SharedFormProps {
 }
 /**
  * A progressively enhanced HTML [`<form>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form)
- * that submits data to actions via [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API),
+ * that submits data to actions via [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch),
  * activating pending states in {@link useNavigation} which enables advanced
  * user interfaces beyond a basic HTML [`<form>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form).
  * After a form's `action` completes, all data on the page is automatically
@@ -2345,7 +2441,8 @@ interface FormProps extends SharedFormProps {
  *
  * `Form` is most useful for submissions that should also change the URL or
  * otherwise add an entry to the browser history stack. For forms that shouldn't
- * manipulate the browser history stack, use [`<fetcher.Form>`][fetcher_form].
+ * manipulate the browser [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
+ * stack, use {@link FetcherWithComponents.Form | `<fetcher.Form>`}.
  *
  * @example
  * import { Form } from "react-router";
@@ -2383,8 +2480,8 @@ type ScrollRestorationProps = ScriptsProps & {
     /**
      * A function that returns a key to use for scroll restoration. This is useful
      * for custom scroll restoration logic, such as using only the pathname so
-     * that subsequent navigations to prior paths will restore the scroll. Defaults
-     * to `location.key`. See {@link GetScrollRestorationKeyFunction}.
+     * that later navigations to prior paths will restore the scroll. Defaults to
+     * `location.key`. See {@link GetScrollRestorationKeyFunction}.
      *
      * ```tsx
      * <ScrollRestoration
@@ -2437,7 +2534,7 @@ type ScrollRestorationProps = ScriptsProps & {
  * @param {ScrollRestorationProps.getKey} props.getKey n/a
  * @param {ScriptsProps.nonce} props.nonce n/a
  * @param {ScrollRestorationProps.storageKey} props.storageKey n/a
- * @returns A [`script`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
+ * @returns A [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
  * tag that restores scroll positions on navigation.
  */
 declare function ScrollRestoration({ getKey, storageKey, ...props }: ScrollRestorationProps): React.JSX.Element | null;
@@ -2492,8 +2589,8 @@ declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to:
  * ### `setSearchParams` function
  *
  * The second element of the tuple is a function that can be used to update the
- * search params. It accepts the same types as `defaultInit` and will
- * cause a navigation to the new URL.
+ * search params. It accepts the same types as `defaultInit` and will cause a
+ * navigation to the new URL.
  *
  * ```tsx
  * let [searchParams, setSearchParams] = useSearchParams();
@@ -2514,7 +2611,8 @@ declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to:
  * setSearchParams(new URLSearchParams("?tab=1"));
  * ```
  *
- * It also supports a function callback like React's [`setState`](https://react.dev/reference/react/useState#setstate):
+ * It also supports a function callback like React's
+ * [`setState`](https://react.dev/reference/react/useState#setstate):
  *
  * ```tsx
  * setSearchParams((searchParams) => {
@@ -2523,6 +2621,12 @@ declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to:
  * });
  * ```
  *
+ * <docs-warning>The function callback version of `setSearchParams` does not support
+ * the [queueing](https://react.dev/reference/react/useState#setstate-parameters)
+ * logic that React's `setState` implements.  Multiple calls to `setSearchParams`
+ * in the same tick will not build on the prior value.  If you need this behavior,
+ * you can use `setState` manually.</docs-warning>
+ *
  * ### Notes
  *
  * Note that `searchParams` is a stable reference, so you can reliably use it
@@ -2879,6 +2983,7 @@ type FetcherWithComponents<TData> = Fetcher<TData> & {
  * @param options Options
  * @param options.key A unique key to identify the fetcher.
  *
+ *
  * By default, `useFetcher` generates a unique fetcher scoped to that component.
  * If you want to identify a fetcher with your own key such that you can access
  * it from elsewhere in your app, you can do that with the `key` option:
@@ -3033,7 +3138,8 @@ declare function usePrompt({ when, message, }: {
  * @param to The {@link To} location to check for an active [View Transition](https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API).
  * @param options Options
  * @param options.relative The relative routing type to use when resolving the
- * `to` location, defaults to `"route"`. See {@link RelativeRoutingType} for more details.
+ * `to` location, defaults to `"route"`. See {@link RelativeRoutingType} for
+ * more details.
  * @returns `true` if there is an active [View Transition](https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API)
  * to the specified {@link Location}, otherwise `false`.
  */
@@ -3041,34 +3147,64 @@ declare function useViewTransitionState(to: To, { relative }?: {
     relative?: RelativeRoutingType;
 }): boolean;
 
+/**
+ * @category Types
+ */
 interface StaticRouterProps {
+    /**
+     * The base URL for the static router (default: `/`)
+     */
     basename?: string;
+    /**
+     * The child elements to render inside the static router
+     */
     children?: React.ReactNode;
+    /**
+     * The {@link Location} to render the static router at (default: `/`)
+     */
     location: Partial<Location> | string;
 }
 /**
- * A `<Router>` that may not navigate to any other location. This is useful
- * on the server where there is no stateful UI.
+ * A {@link Router | `<Router>`} that may not navigate to any other {@link Location}.
+ * This is useful on the server where there is no stateful UI.
  *
  * @public
  * @category Declarative Routers
  * @mode declarative
  * @param props Props
- * @param props.basename The base URL for the static router (default: `/`)
- * @param props.children The child elements to render inside the static router
- * @param props.location The location to render the static router at (default: `/`)
- * @returns A React element that renders the static router
+ * @param {StaticRouterProps.basename} props.basename n/a
+ * @param {StaticRouterProps.children} props.children n/a
+ * @param {StaticRouterProps.location} props.location n/a
+ * @returns A React element that renders the static {@link Router | `<Router>`}
  */
 declare function StaticRouter({ basename, children, location: locationProp, }: StaticRouterProps): React.JSX.Element;
+/**
+ * @category Types
+ */
 interface StaticRouterProviderProps {
+    /**
+     * The {@link StaticHandlerContext} returned from {@link StaticHandler}'s
+     * `query`
+     */
     context: StaticHandlerContext;
+    /**
+     * The static {@link DataRouter} from {@link createStaticRouter}
+     */
     router: Router$1;
+    /**
+     * Whether to hydrate the router on the client (default `true`)
+     */
     hydrate?: boolean;
+    /**
+     * The [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
+     * to use for the hydration [`<script>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script)
+     * tag
+     */
     nonce?: string;
 }
 /**
- * A Data Router that may not navigate to any other location. This is useful
- * on the server where there is no stateful UI.
+ * A {@link DataRouter} that may not navigate to any other {@link Location}.
+ * This is useful on the server where there is no stateful UI.
  *
  * @example
  * export async function handleRequest(request: Request) {
@@ -3090,11 +3226,10 @@ interface StaticRouterProviderProps {
  * @category Data Routers
  * @mode data
  * @param props Props
- * @param props.context The {@link StaticHandlerContext} returned from `staticHandler.query()`
- * @param props.router The static data router from {@link createStaticRouter}
- * @param props.hydrate Whether to hydrate the router on the client (default `true`)
- * @param props.nonce The [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
- * to use for the hydration `<script>` tag
+ * @param {StaticRouterProviderProps.context} props.context n/a
+ * @param {StaticRouterProviderProps.hydrate} props.hydrate n/a
+ * @param {StaticRouterProviderProps.nonce} props.nonce n/a
+ * @param {StaticRouterProviderProps.router} props.router n/a
  * @returns A React element that renders the static router provider
  */
 declare function StaticRouterProvider({ context, router, hydrate, nonce, }: StaticRouterProviderProps): React.JSX.Element;
@@ -3105,7 +3240,7 @@ type CreateStaticHandlerOptions = Omit<CreateStaticHandlerOptions$1, "mapRoutePr
  * @example
  * export async function handleRequest(request: Request) {
  *   let { query, dataRoutes } = createStaticHandler(routes);
- *   let context = await query(request));
+ *   let context = await query(request);
  *
  *   if (context instanceof Response) {
  *     return context;
@@ -3121,20 +3256,22 @@ type CreateStaticHandlerOptions = Omit<CreateStaticHandlerOptions$1, "mapRoutePr
  * @public
  * @category Data Routers
  * @mode data
- * @param routes The route objects to create a static handler for
+ * @param routes The {@link RouteObject | route objects} to create a static
+ * handler for
  * @param opts Options
  * @param opts.basename The base URL for the static handler (default: `/`)
  * @param opts.future Future flags for the static handler
- * @returns A static handler that can be used to query data for the provided routes
+ * @returns A static handler that can be used to query data for the provided
+ * routes
  */
 declare function createStaticHandler(routes: RouteObject[], opts?: CreateStaticHandlerOptions): StaticHandler;
 /**
- * Create a static data router for server-side rendering
+ * Create a static {@link DataRouter} for server-side rendering
  *
  * @example
  * export async function handleRequest(request: Request) {
  *   let { query, dataRoutes } = createStaticHandler(routes);
- *   let context = await query(request));
+ *   let context = await query(request);
  *
  *   if (context instanceof Response) {
  *     return context;
@@ -3150,14 +3287,15 @@ declare function createStaticHandler(routes: RouteObject[], opts?: CreateStaticH
  * @public
  * @category Data Routers
  * @mode data
- * @param routes The route objects to create a static data router for
- * @param context The static handler context returned from `staticHandler.query()`
+ * @param routes The route objects to create a static {@link DataRouter} for
+ * @param context The {@link StaticHandlerContext} returned from {@link StaticHandler}'s
+ * `query`
  * @param opts Options
- * @param opts.future Future flags for the static data router
- * @returns A static data router that can be used to render the provided routes
+ * @param opts.future Future flags for the static {@link DataRouter}
+ * @returns A static {@link DataRouter} that can be used to render the provided routes
  */
 declare function createStaticRouter(routes: RouteObject[], context: StaticHandlerContext, opts?: {
     future?: Partial<FutureConfig$1>;
 }): Router$1;
 
-export { ScrollRestoration as $, type AssetsManifest as A, type BrowserRouterProps as B, type ScrollRestorationProps as C, type DOMRouterOpts as D, type EntryContext as E, type FutureConfig as F, type SetURLSearchParams as G, type HydrateFallbackType as H, type IndexRouteProps as I, type SubmitFunction as J, type FetcherSubmitFunction as K, type LayoutRouteProps as L, type MemoryRouterOpts as M, type NavigateProps as N, type OutletProps as O, type PathRouteProps as P, type FetcherWithComponents as Q, type RouteComponentType as R, type ServerBuild as S, createBrowserRouter as T, createHashRouter as U, BrowserRouter as V, HashRouter as W, Link as X, HistoryRouter as Y, NavLink as Z, Form as _, type ErrorBoundaryType as a, useLinkClickHandler as a0, useSearchParams as a1, useSubmit as a2, useFormAction as a3, useFetcher as a4, useFetchers as a5, useBeforeUnload as a6, usePrompt as a7, useViewTransitionState as a8, type FetcherSubmitOptions as a9, WithHydrateFallbackProps as aA, withHydrateFallbackProps as aB, WithErrorBoundaryProps as aC, withErrorBoundaryProps as aD, FrameworkContext as aE, createClientRoutes as aF, createClientRoutesWithHMRRevalidationOptOut as aG, shouldHydrateRouteLoader as aH, useScrollRestoration as aI, type ParamKeyValuePair as aa, type SubmitOptions as ab, type URLSearchParamsInit as ac, type SubmitTarget as ad, createSearchParams as ae, type StaticRouterProps as af, type StaticRouterProviderProps as ag, createStaticHandler as ah, createStaticRouter as ai, StaticRouter as aj, StaticRouterProvider as ak, Meta as al, Links as am, Scripts as an, PrefetchPageLinks as ao, type ScriptsProps as ap, type PrefetchBehavior as aq, type DiscoverBehavior as ar, type HandleDataRequestFunction as as, type HandleDocumentRequestFunction as at, type HandleErrorFunction as au, type ServerEntryModule as av, hydrationRouteProperties as aw, mapRouteProperties as ax, WithComponentProps as ay, withComponentProps as az, type AwaitProps as b, type MemoryRouterProps as c, type RouteProps as d, type RouterProps as e, type RouterProviderProps as f, type RoutesProps as g, Await as h, MemoryRouter as i, Navigate as j, Outlet as k, Route$1 as l, Router as m, RouterProvider as n, Routes as o, createMemoryRouter as p, createRoutesFromChildren as q, createRoutesFromElements as r, renderMatches as s, type HashRouterProps as t, type HistoryRouterProps as u, type LinkProps as v, type NavLinkProps as w, type NavLinkRenderProps as x, type FetcherFormProps as y, type FormProps as z };
+export { ScrollRestoration as $, type AssetsManifest as A, type BrowserRouterProps as B, type ScrollRestorationProps as C, type DOMRouterOpts as D, type EntryContext as E, type FutureConfig as F, type SetURLSearchParams as G, type HydrateFallbackType as H, type IndexRouteProps as I, type SubmitFunction as J, type FetcherSubmitFunction as K, type LayoutRouteProps as L, type MemoryRouterOpts as M, type NavigateProps as N, type OutletProps as O, type PathRouteProps as P, type FetcherWithComponents as Q, type RouteComponentType as R, type ServerBuild as S, createBrowserRouter as T, createHashRouter as U, BrowserRouter as V, HashRouter as W, Link as X, HistoryRouter as Y, NavLink as Z, Form as _, type ErrorBoundaryType as a, useLinkClickHandler as a0, useSearchParams as a1, useSubmit as a2, useFormAction as a3, useFetcher as a4, useFetchers as a5, useBeforeUnload as a6, usePrompt as a7, useViewTransitionState as a8, type FetcherSubmitOptions as a9, withComponentProps as aA, WithHydrateFallbackProps as aB, withHydrateFallbackProps as aC, WithErrorBoundaryProps as aD, withErrorBoundaryProps as aE, FrameworkContext as aF, createClientRoutes as aG, createClientRoutesWithHMRRevalidationOptOut as aH, shouldHydrateRouteLoader as aI, useScrollRestoration as aJ, type ParamKeyValuePair as aa, type SubmitOptions as ab, type URLSearchParamsInit as ac, type SubmitTarget as ad, createSearchParams as ae, type StaticRouterProps as af, type StaticRouterProviderProps as ag, createStaticHandler as ah, createStaticRouter as ai, StaticRouter as aj, StaticRouterProvider as ak, Meta as al, Links as am, Scripts as an, PrefetchPageLinks as ao, type LinksProps as ap, type ScriptsProps as aq, type PrefetchBehavior as ar, type DiscoverBehavior as as, type HandleDataRequestFunction as at, type HandleDocumentRequestFunction as au, type HandleErrorFunction as av, type ServerEntryModule as aw, hydrationRouteProperties as ax, mapRouteProperties as ay, WithComponentProps as az, type AwaitProps as b, type MemoryRouterProps as c, type RouteProps as d, type RouterProps as e, type RouterProviderProps as f, type RoutesProps as g, Await as h, MemoryRouter as i, Navigate as j, Outlet as k, Route$1 as l, Router as m, RouterProvider as n, Routes as o, createMemoryRouter as p, createRoutesFromChildren as q, createRoutesFromElements as r, renderMatches as s, type HashRouterProps as t, type HistoryRouterProps as u, type LinkProps as v, type NavLinkProps as w, type NavLinkRenderProps as x, type FetcherFormProps as y, type FormProps as z };