react-router 7.9.4 → 7.9.6

package/dist/{production/context-DSyS5mLj.d.mts → development/router-CAvh_Drx.d.mts}

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { ComponentType, ReactElement } from 'react';
 
 /**
  * Actions represent the type of change to a location value.
@@ -394,6 +395,11 @@ type DefaultContext = MiddlewareEnabled extends true ? Readonly<RouterContextPro
 interface DataFunctionArgs<Context> {
     /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read headers (like cookies, and {@link https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams URLSearchParams} from the request. */
     request: Request;
+    /**
+     * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+     * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+     */
+    unstable_pattern: string;
     /**
      * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
      * @example
@@ -614,7 +620,7 @@ type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = Agn
  * properties from framework-agnostic properties
  */
 interface MapRoutePropertiesFunction {
-    (route: AgnosticRouteObject): {
+    (route: AgnosticDataRouteObject): {
         hasErrorBoundary: boolean;
     } & Record<string, any>;
 }
@@ -1040,1529 +1046,2146 @@ declare class ErrorResponseImpl implements ErrorResponse {
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 
 /**
- * A Router instance manages all navigation and data loading/mutations
+ * An object of unknown type for route loaders and actions provided by the
+ * server's `getLoadContext()` function.  This is defined as an empty interface
+ * specifically so apps can leverage declaration merging to augment this type
+ * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
  */
-interface Router$1 {
-    /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Return the basename for the router
-     */
-    get basename(): RouterInit["basename"];
+interface AppLoadContext {
+    [key: string]: unknown;
+}
+
+declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
+    hasErrorBoundary: boolean;
+};
+declare const hydrationRouteProperties: (keyof RouteObject)[];
+/**
+ * @category Data Routers
+ */
+interface MemoryRouterOpts {
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Return the future config for the router
+     * Basename path for the application.
      */
-    get future(): FutureConfig;
+    basename?: string;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Return the current state of the router
+     * A function that returns an {@link 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.
      */
-    get state(): RouterState;
+    getContext?: RouterInit["getContext"];
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Return the routes for this router instance
+     * Future flags to enable for the router.
      */
-    get routes(): AgnosticDataRouteObject[];
+    future?: Partial<FutureConfig>;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Return the window associated with the router
+     * Hydration data to initialize the router with if you have already performed
+     * data loading on the server.
      */
-    get window(): RouterInit["window"];
+    hydrationData?: HydrationState;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Initialize the router, including adding history listeners and kicking off
-     * initial data fetches.  Returns a function to cleanup listeners and abort
-     * any in-progress loads
+     * Initial entries in the in-memory history stack
      */
-    initialize(): Router$1;
+    initialEntries?: InitialEntry[];
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Subscribe to router.state updates
-     *
-     * @param fn function to call with the new state
+     * Index of `initialEntries` the application should initialize to
      */
-    subscribe(fn: RouterSubscriber): () => void;
+    initialIndex?: number;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
+     * Array of instrumentation objects allowing you to instrument the router and
+     * individual routes prior to router initialization (and on any subsequently
+     * added routes via `route.lazy` or `patchRoutesOnNavigation`).  This is
+     * mostly useful for observability such as wrapping navigations, fetches,
+     * as well as route loaders/actions/middlewares with logging and/or performance
+     * tracing.
      *
-     * Enable scroll restoration behavior in the router
-     *
-     * @param savedScrollPositions Object that will manage positions, in case
-     *                             it's being restored from sessionStorage
-     * @param getScrollPosition    Function to get the active Y scroll position
-     * @param getKey               Function to get the key to use for restoration
+     * ```tsx
+     * let router = createBrowserRouter(routes, {
+     *   unstable_instrumentations: [logging]
+     * });
+     *
+     *
+     * let logging = {
+     *   router({ instrument }) {
+     *     instrument({
+     *       navigate: (impl, info) => logExecution(`navigate ${info.to}`, impl),
+     *       fetch: (impl, info) => logExecution(`fetch ${info.to}`, impl)
+     *     });
+     *   },
+     *   route({ instrument, id }) {
+     *     instrument({
+     *       middleware: (impl, info) => logExecution(
+     *         `middleware ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *       loader: (impl, info) => logExecution(
+     *         `loader ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *       action: (impl, info) => logExecution(
+     *         `action ${info.request.url} (route ${id})`,
+     *         impl
+     *       ),
+     *     })
+     *   }
+     * };
+     *
+     * async function logExecution(label: string, impl: () => Promise<void>) {
+     *   let start = performance.now();
+     *   console.log(`start ${label}`);
+     *   await impl();
+     *   let duration = Math.round(performance.now() - start);
+     *   console.log(`end ${label} (${duration}ms)`);
+     * }
+     * ```
      */
-    enableScrollRestoration(savedScrollPositions: Record<string, number>, getScrollPosition: GetScrollPositionFunction, getKey?: GetScrollRestorationKeyFunction): () => void;
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Navigate forward/backward in the history stack
-     * @param to Delta to move in the history stack
+     * Override the default data strategy of loading in parallel.
+     * Only intended for advanced usage.
      */
-    navigate(to: number): Promise<void>;
+    dataStrategy?: DataStrategyFunction;
     /**
-     * Navigate to the given path
-     * @param to Path to navigate to
-     * @param opts Navigation options (method, submission, etc.)
+     * Lazily define portions of the route tree on navigations.
      */
-    navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;
+    patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
+}
+/**
+ * Create a new {@link DataRouter} that manages the application path using an
+ * in-memory [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
+ * stack. Useful for non-browser environments without a DOM API.
+ *
+ * @public
+ * @category Data Routers
+ * @mode data
+ * @param routes Application routes
+ * @param opts Options
+ * @param {MemoryRouterOpts.basename} opts.basename n/a
+ * @param {MemoryRouterOpts.dataStrategy} opts.dataStrategy n/a
+ * @param {MemoryRouterOpts.future} opts.future n/a
+ * @param {MemoryRouterOpts.getContext} opts.getContext n/a
+ * @param {MemoryRouterOpts.hydrationData} opts.hydrationData n/a
+ * @param {MemoryRouterOpts.initialEntries} opts.initialEntries n/a
+ * @param {MemoryRouterOpts.initialIndex} opts.initialIndex n/a
+ * @param {MemoryRouterOpts.unstable_instrumentations} opts.unstable_instrumentations n/a
+ * @param {MemoryRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
+ * @returns An initialized {@link DataRouter} to pass to {@link RouterProvider | `<RouterProvider>`}
+ */
+declare function createMemoryRouter(routes: RouteObject[], opts?: MemoryRouterOpts): Router;
+/**
+ * Function signature for client side error handling for loader/actions errors
+ * and rendering errors via `componentDidCatch`
+ */
+interface unstable_ClientOnErrorFunction {
+    (error: unknown, info: {
+        location: Location;
+        params: Params;
+        errorInfo?: React.ErrorInfo;
+    }): void;
+}
+/**
+ * @category Types
+ */
+interface RouterProviderProps {
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Trigger a fetcher load/submission
-     *
-     * @param key     Fetcher key
-     * @param routeId Route that owns the fetcher
-     * @param href    href to fetch
-     * @param opts    Fetcher options, (method, submission, etc.)
+     * The {@link DataRouter} instance to use for navigation and data fetching.
      */
-    fetch(key: string, routeId: string, href: string | null, opts?: RouterFetchOptions): Promise<void>;
+    router: Router;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
+     * The [`ReactDOM.flushSync`](https://react.dev/reference/react-dom/flushSync)
+     * implementation to use for flushing updates.
      *
-     * Trigger a revalidation of all current route loaders and fetcher loads
+     * You usually don't have to worry about this:
+     * - The `RouterProvider` exported from `react-router/dom` handles this internally for you
+     * - If you are rendering in a non-DOM environment, you can import
+     *   `RouterProvider` from `react-router` and ignore this prop
      */
-    revalidate(): Promise<void>;
+    flushSync?: (fn: () => unknown) => undefined;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
+     * An error handler function that will be called for any loader/action/render
+     * errors that are encountered in your application.  This is useful for
+     * logging or reporting errors instead of the `ErrorBoundary` because it's not
+     * subject to re-rendering and will only run one time per error.
      *
-     * Utility function to create an href for the given location
-     * @param location
-     */
-    createHref(location: Location | URL): string;
-    /**
-     * @private
-     * PRIVATE - DO NOT USE
+     * The `errorInfo` parameter is passed along from
+     * [`componentDidCatch`](https://react.dev/reference/react/Component#componentdidcatch)
+     * and is only present for render errors.
      *
-     * Utility function to URL encode a destination path according to the internal
-     * history implementation
-     * @param to
+     * ```tsx
+     * <RouterProvider unstable_onError=(error, errorInfo) => {
+     *   console.error(error, errorInfo);
+     *   reportToErrorService(error, errorInfo);
+     * }} />
+     * ```
      */
-    encodeLocation(to: To): Path;
+    unstable_onError?: unstable_ClientOnErrorFunction;
+}
+/**
+ * Render the UI for the given {@link DataRouter}. This component should
+ * typically be at the top of an app's element tree.
+ *
+ * ```tsx
+ * import { createBrowserRouter } from "react-router";
+ * import { RouterProvider } from "react-router/dom";
+ * import { createRoot } from "react-dom/client";
+ *
+ * const router = createBrowserRouter(routes);
+ * createRoot(document.getElementById("root")).render(
+ *   <RouterProvider router={router} />
+ * );
+ * ```
+ *
+ * <docs-info>Please note that this component is exported both from
+ * `react-router` and `react-router/dom` with the only difference being that the
+ * latter automatically wires up `react-dom`'s [`flushSync`](https://react.dev/reference/react-dom/flushSync)
+ * implementation. You _almost always_ want to use the version from
+ * `react-router/dom` unless you're running in a non-DOM environment.</docs-info>
+ *
+ *
+ * @public
+ * @category Data Routers
+ * @mode data
+ * @param props Props
+ * @param {RouterProviderProps.flushSync} props.flushSync n/a
+ * @param {RouterProviderProps.unstable_onError} props.unstable_onError n/a
+ * @param {RouterProviderProps.router} props.router n/a
+ * @returns React element for the rendered router
+ */
+declare function RouterProvider({ router, flushSync: reactDomFlushSyncImpl, unstable_onError, }: RouterProviderProps): React.ReactElement;
+/**
+ * @category Types
+ */
+interface MemoryRouterProps {
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Get/create a fetcher for the given key
-     * @param key
+     * Application basename
      */
-    getFetcher<TData = any>(key: string): Fetcher<TData>;
+    basename?: string;
     /**
-     * @internal
-     * PRIVATE - DO NOT USE
-     *
-     * Reset the fetcher for a given key
-     * @param key
+     * Nested {@link Route} elements describing the route tree
      */
-    resetFetcher(key: string, opts?: {
-        reason?: unknown;
-    }): void;
+    children?: React.ReactNode;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Delete the fetcher for a given key
-     * @param key
+     * Initial entries in the in-memory history stack
      */
-    deleteFetcher(key: string): void;
+    initialEntries?: InitialEntry[];
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Cleanup listeners and abort any in-progress loads
+     * Index of `initialEntries` the application should initialize to
      */
-    dispose(): void;
-    /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Get a navigation blocker
-     * @param key The identifier for the blocker
-     * @param fn The blocker function implementation
-     */
-    getBlocker(key: string, fn: BlockerFunction): Blocker;
+    initialIndex?: number;
+}
+/**
+ * A declarative {@link Router | `<Router>`} that stores all entries in memory.
+ *
+ * @public
+ * @category Declarative Routers
+ * @mode declarative
+ * @param props Props
+ * @param {MemoryRouterProps.basename} props.basename n/a
+ * @param {MemoryRouterProps.children} props.children n/a
+ * @param {MemoryRouterProps.initialEntries} props.initialEntries n/a
+ * @param {MemoryRouterProps.initialIndex} props.initialIndex n/a
+ * @returns A declarative in-memory {@link Router | `<Router>`} for client-side
+ * routing.
+ */
+declare function MemoryRouter({ basename, children, initialEntries, initialIndex, }: MemoryRouterProps): React.ReactElement;
+/**
+ * @category Types
+ */
+interface NavigateProps {
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Delete a navigation blocker
-     * @param key The identifier for the blocker
+     * The path to navigate to. This can be a string or a {@link Path} object
      */
-    deleteBlocker(key: string): void;
+    to: To;
     /**
-     * @private
-     * PRIVATE DO NOT USE
-     *
-     * Patch additional children routes into an existing parent route
-     * @param routeId The parent route id or a callback function accepting `patch`
-     *                to perform batch patching
-     * @param children The additional children routes
-     * @param unstable_allowElementMutations Allow mutation or route elements on
-     *                                       existing routes. Intended for RSC-usage
-     *                                       only.
+     * Whether to replace the current entry in the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
+     * stack
      */
-    patchRoutes(routeId: string | null, children: AgnosticRouteObject[], unstable_allowElementMutations?: boolean): void;
+    replace?: boolean;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * HMR needs to pass in-flight route updates to React Router
-     * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)
+     * State to pass to the new {@link Location} to store in [`history.state`](https://developer.mozilla.org/en-US/docs/Web/API/History/state).
      */
-    _internalSetRoutes(routes: AgnosticRouteObject[]): void;
+    state?: any;
     /**
-     * @private
-     * PRIVATE - DO NOT USE
-     *
-     * Cause subscribers to re-render.  This is used to force a re-render.
+     * How to interpret relative routing in the `to` prop.
+     * See {@link RelativeRoutingType}.
      */
-    _internalSetStateDoNotUseOrYouWillBreakYourApp(state: Partial<RouterState>): void;
+    relative?: RelativeRoutingType;
+}
+/**
+ * A component-based version of {@link useNavigate} to use in a
+ * [`React.Component` class](https://react.dev/reference/react/Component) where
+ * hooks cannot be used.
+ *
+ * It's recommended to avoid using this component in favor of {@link useNavigate}.
+ *
+ * @example
+ * <Navigate to="/tasks" />
+ *
+ * @public
+ * @category Components
+ * @param props Props
+ * @param {NavigateProps.relative} props.relative n/a
+ * @param {NavigateProps.replace} props.replace n/a
+ * @param {NavigateProps.state} props.state n/a
+ * @param {NavigateProps.to} props.to n/a
+ * @returns {void}
+ *
+ */
+declare function Navigate({ to, replace, state, relative, }: NavigateProps): null;
+/**
+ * @category Types
+ */
+interface OutletProps {
     /**
-     * @private
-     * PRIVATE - DO NOT USE
+     * Provides a context value to the element tree below the outlet. Use when
+     * the parent route needs to provide values to child routes.
      *
-     * Internal fetch AbortControllers accessed by unit tests
+     * ```tsx
+     * <Outlet context={myContextValue} />
+     * ```
+     *
+     * Access the context with {@link useOutletContext}.
      */
-    _internalFetchControllers: Map<string, AbortController>;
+    context?: unknown;
 }
 /**
- * State maintained internally by the router.  During a navigation, all states
- * reflect the "old" location unless otherwise noted.
+ * Renders the matching child route of a parent route or nothing if no child
+ * route matches.
+ *
+ * @example
+ * import { Outlet } from "react-router";
+ *
+ * export default function SomeParent() {
+ *   return (
+ *     <div>
+ *       <h1>Parent Content</h1>
+ *       <Outlet />
+ *     </div>
+ *   );
+ * }
+ *
+ * @public
+ * @category Components
+ * @param props Props
+ * @param {OutletProps.context} props.context n/a
+ * @returns React element for the rendered outlet or `null` if no child route matches.
  */
-interface RouterState {
+declare function Outlet(props: OutletProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface PathRouteProps {
     /**
-     * The action of the most recent navigation
+     * Whether the path should be case-sensitive. Defaults to `false`.
      */
-    historyAction: Action;
+    caseSensitive?: NonIndexRouteObject["caseSensitive"];
     /**
-     * The current location reflected by the router
+     * The path pattern to match. If unspecified or empty, then this becomes a
+     * layout route.
      */
-    location: Location;
+    path?: NonIndexRouteObject["path"];
     /**
-     * The current set of route matches
+     * The unique identifier for this route (for use with {@link DataRouter}s)
      */
-    matches: AgnosticDataRouteMatch[];
+    id?: NonIndexRouteObject["id"];
     /**
-     * Tracks whether we've completed our initial data load
+     * A function that returns a promise that resolves to the route object.
+     * Used for code-splitting routes.
+     * See [`lazy`](../../start/data/route-object#lazy).
      */
-    initialized: boolean;
+    lazy?: LazyRouteFunction<NonIndexRouteObject>;
     /**
-     * Current scroll position we should start at for a new view
-     *  - number -> scroll position to restore to
-     *  - false -> do not restore scroll at all (used during submissions/revalidations)
-     *  - null -> don't have a saved position, scroll to hash or top of page
+     * The route middleware.
+     * See [`middleware`](../../start/data/route-object#middleware).
      */
-    restoreScrollPosition: number | false | null;
+    middleware?: NonIndexRouteObject["middleware"];
     /**
-     * Indicate whether this navigation should skip resetting the scroll position
-     * if we are unable to restore the scroll position
+     * The route loader.
+     * See [`loader`](../../start/data/route-object#loader).
      */
-    preventScrollReset: boolean;
+    loader?: NonIndexRouteObject["loader"];
     /**
-     * Tracks the state of the current navigation
+     * The route action.
+     * See [`action`](../../start/data/route-object#action).
      */
-    navigation: Navigation;
+    action?: NonIndexRouteObject["action"];
+    hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"];
     /**
-     * Tracks any in-progress revalidations
+     * The route shouldRevalidate function.
+     * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
      */
-    revalidation: RevalidationState;
+    shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"];
     /**
-     * Data from the loaders for the current matches
+     * The route handle.
      */
-    loaderData: RouteData;
+    handle?: NonIndexRouteObject["handle"];
     /**
-     * Data from the action for the current matches
+     * Whether this is an index route.
      */
-    actionData: RouteData | null;
+    index?: false;
     /**
-     * Errors caught from loaders for the current matches
+     * Child Route components
      */
-    errors: RouteData | null;
+    children?: React.ReactNode;
     /**
-     * Map of current fetchers
+     * The React element to render when this Route matches.
+     * Mutually exclusive with `Component`.
      */
-    fetchers: Map<string, Fetcher>;
+    element?: React.ReactNode | null;
     /**
-     * Map of current blockers
+     * The React element to render while this router is loading data.
+     * Mutually exclusive with `HydrateFallback`.
      */
-    blockers: Map<string, Blocker>;
-}
-/**
- * Data that can be passed into hydrate a Router from SSR
- */
-type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
-/**
- * Future flags to toggle new feature behavior
- */
-interface FutureConfig {
-}
-/**
- * Initialization options for createRouter
- */
-interface RouterInit {
-    routes: AgnosticRouteObject[];
-    history: History;
-    basename?: string;
-    getContext?: () => MaybePromise<RouterContextProvider>;
-    mapRouteProperties?: MapRoutePropertiesFunction;
-    future?: Partial<FutureConfig>;
-    hydrationRouteProperties?: string[];
-    hydrationData?: HydrationState;
-    window?: Window;
-    dataStrategy?: DataStrategyFunction;
-    patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;
+    hydrateFallbackElement?: React.ReactNode | null;
+    /**
+     * The React element to render at this route if an error occurs.
+     * Mutually exclusive with `ErrorBoundary`.
+     */
+    errorElement?: React.ReactNode | null;
+    /**
+     * The React Component to render when this route matches.
+     * Mutually exclusive with `element`.
+     */
+    Component?: React.ComponentType | null;
+    /**
+     * The React Component to render while this router is loading data.
+     * Mutually exclusive with `hydrateFallbackElement`.
+     */
+    HydrateFallback?: React.ComponentType | null;
+    /**
+     * The React Component to render at this route if an error occurs.
+     * Mutually exclusive with `errorElement`.
+     */
+    ErrorBoundary?: React.ComponentType | null;
 }
 /**
- * State returned from a server-side query() call
+ * @category Types
  */
-interface StaticHandlerContext {
-    basename: Router$1["basename"];
-    location: RouterState["location"];
-    matches: RouterState["matches"];
-    loaderData: RouterState["loaderData"];
-    actionData: RouterState["actionData"];
-    errors: RouterState["errors"];
-    statusCode: number;
-    loaderHeaders: Record<string, Headers>;
-    actionHeaders: Record<string, Headers>;
-    _deepestRenderedBoundaryId?: string | null;
+interface LayoutRouteProps extends PathRouteProps {
 }
 /**
- * A StaticHandler instance manages a singular SSR navigation/fetch event
+ * @category Types
  */
-interface StaticHandler {
-    dataRoutes: AgnosticDataRouteObject[];
-    query(request: Request, opts?: {
-        requestContext?: unknown;
-        filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
-        skipLoaderErrorBubbling?: boolean;
-        skipRevalidation?: boolean;
-        dataStrategy?: DataStrategyFunction<unknown>;
-        generateMiddlewareResponse?: (query: (r: Request, args?: {
-            filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
-        }) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
-    }): Promise<StaticHandlerContext | Response>;
-    queryRoute(request: Request, opts?: {
-        routeId?: string;
-        requestContext?: unknown;
-        dataStrategy?: DataStrategyFunction<unknown>;
-        generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>;
-    }): Promise<any>;
-}
-type ViewTransitionOpts = {
-    currentLocation: Location;
-    nextLocation: Location;
-};
-/**
- * Subscriber function signature for changes to router state
- */
-interface RouterSubscriber {
-    (state: RouterState, opts: {
-        deletedFetchers: string[];
-        viewTransitionOpts?: ViewTransitionOpts;
-        flushSync: boolean;
-    }): void;
-}
-/**
- * Function signature for determining the key to be used in scroll restoration
- * for a given location
- */
-interface GetScrollRestorationKeyFunction {
-    (location: Location, matches: UIMatch[]): string | null;
-}
-/**
- * Function signature for determining the current scroll position
- */
-interface GetScrollPositionFunction {
-    (): number;
-}
-/**
- * - "route": relative to the route hierarchy so `..` means remove all segments
- * of the current route even if it has many. For example, a `route("posts/:id")`
- * would have both `:id` and `posts` removed from the url.
- * - "path": relative to the pathname so `..` means remove one segment of the
- * pathname. For example, a `route("posts/:id")` would have only `:id` removed
- * from the url.
- */
-type RelativeRoutingType = "route" | "path";
-type BaseNavigateOrFetchOptions = {
-    preventScrollReset?: boolean;
-    relative?: RelativeRoutingType;
-    flushSync?: boolean;
-};
-type BaseNavigateOptions = BaseNavigateOrFetchOptions & {
-    replace?: boolean;
-    state?: any;
-    fromRouteId?: string;
-    viewTransition?: boolean;
-};
-type BaseSubmissionOptions = {
-    formMethod?: HTMLFormMethod;
-    formEncType?: FormEncType;
-} & ({
-    formData: FormData;
-    body?: undefined;
-} | {
-    formData?: undefined;
-    body: any;
-});
-/**
- * Options for a navigate() call for a normal (non-submission) navigation
- */
-type LinkNavigateOptions = BaseNavigateOptions;
-/**
- * Options for a navigate() call for a submission navigation
- */
-type SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;
-/**
- * Options to pass to navigate() for a navigation
- */
-type RouterNavigateOptions = LinkNavigateOptions | SubmissionNavigateOptions;
-/**
- * Options for a fetch() load
- */
-type LoadFetchOptions = BaseNavigateOrFetchOptions;
-/**
- * Options for a fetch() submission
- */
-type SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;
-/**
- * Options to pass to fetch()
- */
-type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;
-/**
- * Potential states for state.navigation
- */
-type NavigationStates = {
-    Idle: {
-        state: "idle";
-        location: undefined;
-        formMethod: undefined;
-        formAction: undefined;
-        formEncType: undefined;
-        formData: undefined;
-        json: undefined;
-        text: undefined;
-    };
-    Loading: {
-        state: "loading";
-        location: Location;
-        formMethod: Submission["formMethod"] | undefined;
-        formAction: Submission["formAction"] | undefined;
-        formEncType: Submission["formEncType"] | undefined;
-        formData: Submission["formData"] | undefined;
-        json: Submission["json"] | undefined;
-        text: Submission["text"] | undefined;
-    };
-    Submitting: {
-        state: "submitting";
-        location: Location;
-        formMethod: Submission["formMethod"];
-        formAction: Submission["formAction"];
-        formEncType: Submission["formEncType"];
-        formData: Submission["formData"];
-        json: Submission["json"];
-        text: Submission["text"];
-    };
-};
-type Navigation = NavigationStates[keyof NavigationStates];
-type RevalidationState = "idle" | "loading";
-/**
- * Potential states for fetchers
- */
-type FetcherStates<TData = any> = {
+interface IndexRouteProps {
     /**
-     * The fetcher is not calling a loader or action
-     *
-     * ```tsx
-     * fetcher.state === "idle"
-     * ```
+     * Whether the path should be case-sensitive. Defaults to `false`.
      */
-    Idle: {
-        state: "idle";
-        formMethod: undefined;
-        formAction: undefined;
-        formEncType: undefined;
-        text: undefined;
-        formData: undefined;
-        json: undefined;
-        /**
-         * If the fetcher has never been called, this will be undefined.
-         */
-        data: TData | undefined;
-    };
+    caseSensitive?: IndexRouteObject["caseSensitive"];
     /**
-     * The fetcher is loading data from a {@link LoaderFunction | loader} from a
-     * call to {@link FetcherWithComponents.load | `fetcher.load`}.
-     *
-     * ```tsx
-     * // somewhere
-     * <button onClick={() => fetcher.load("/some/route") }>Load</button>
-     *
-     * // the state will update
-     * fetcher.state === "loading"
-     * ```
+     * The path pattern to match. If unspecified or empty, then this becomes a
+     * layout route.
      */
-    Loading: {
-        state: "loading";
-        formMethod: Submission["formMethod"] | undefined;
-        formAction: Submission["formAction"] | undefined;
-        formEncType: Submission["formEncType"] | undefined;
-        text: Submission["text"] | undefined;
-        formData: Submission["formData"] | undefined;
-        json: Submission["json"] | undefined;
-        data: TData | undefined;
-    };
+    path?: IndexRouteObject["path"];
     /**
-      The fetcher is submitting to a {@link LoaderFunction} (GET) or {@link ActionFunction} (POST) from a {@link FetcherWithComponents.Form | `fetcher.Form`} or {@link FetcherWithComponents.submit | `fetcher.submit`}.
-  
-      ```tsx
-      // somewhere
-      <input
-        onChange={e => {
-          fetcher.submit(event.currentTarget.form, { method: "post" });
-        }}
-      />
-  
-      // the state will update
-      fetcher.state === "submitting"
-  
-      // and formData will be available
-      fetcher.formData
-      ```
+     * The unique identifier for this route (for use with {@link DataRouter}s)
      */
-    Submitting: {
-        state: "submitting";
-        formMethod: Submission["formMethod"];
-        formAction: Submission["formAction"];
-        formEncType: Submission["formEncType"];
-        text: Submission["text"];
-        formData: Submission["formData"];
-        json: Submission["json"];
-        data: TData | undefined;
-    };
-};
-type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
-interface BlockerBlocked {
-    state: "blocked";
-    reset: () => void;
-    proceed: () => void;
-    location: Location;
-}
-interface BlockerUnblocked {
-    state: "unblocked";
-    reset: undefined;
-    proceed: undefined;
-    location: undefined;
-}
-interface BlockerProceeding {
-    state: "proceeding";
-    reset: undefined;
-    proceed: undefined;
-    location: Location;
+    id?: IndexRouteObject["id"];
+    /**
+     * A function that returns a promise that resolves to the route object.
+     * Used for code-splitting routes.
+     * See [`lazy`](../../start/data/route-object#lazy).
+     */
+    lazy?: LazyRouteFunction<IndexRouteObject>;
+    /**
+     * The route middleware.
+     * See [`middleware`](../../start/data/route-object#middleware).
+     */
+    middleware?: IndexRouteObject["middleware"];
+    /**
+     * The route loader.
+     * See [`loader`](../../start/data/route-object#loader).
+     */
+    loader?: IndexRouteObject["loader"];
+    /**
+     * The route action.
+     * See [`action`](../../start/data/route-object#action).
+     */
+    action?: IndexRouteObject["action"];
+    hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"];
+    /**
+     * The route shouldRevalidate function.
+     * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
+     */
+    shouldRevalidate?: IndexRouteObject["shouldRevalidate"];
+    /**
+     * The route handle.
+     */
+    handle?: IndexRouteObject["handle"];
+    /**
+     * Whether this is an index route.
+     */
+    index: true;
+    /**
+     * Child Route components
+     */
+    children?: undefined;
+    /**
+     * The React element to render when this Route matches.
+     * Mutually exclusive with `Component`.
+     */
+    element?: React.ReactNode | null;
+    /**
+     * The React element to render while this router is loading data.
+     * Mutually exclusive with `HydrateFallback`.
+     */
+    hydrateFallbackElement?: React.ReactNode | null;
+    /**
+     * The React element to render at this route if an error occurs.
+     * Mutually exclusive with `ErrorBoundary`.
+     */
+    errorElement?: React.ReactNode | null;
+    /**
+     * The React Component to render when this route matches.
+     * Mutually exclusive with `element`.
+     */
+    Component?: React.ComponentType | null;
+    /**
+     * The React Component to render while this router is loading data.
+     * Mutually exclusive with `hydrateFallbackElement`.
+     */
+    HydrateFallback?: React.ComponentType | null;
+    /**
+     * The React Component to render at this route if an error occurs.
+     * Mutually exclusive with `errorElement`.
+     */
+    ErrorBoundary?: React.ComponentType | null;
 }
-type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
-type BlockerFunction = (args: {
-    currentLocation: Location;
-    nextLocation: Location;
-    historyAction: Action;
-}) => boolean;
-declare const IDLE_NAVIGATION: NavigationStates["Idle"];
-declare const IDLE_FETCHER: FetcherStates["Idle"];
-declare const IDLE_BLOCKER: BlockerUnblocked;
+type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;
 /**
- * Create a router and listen to history POP navigations
+ * Configures an element to render when a pattern matches the current location.
+ * It must be rendered within a {@link Routes} element. Note that these routes
+ * do not participate in data loading, actions, code splitting, or any other
+ * route module features.
+ *
+ * @example
+ * // Usually used in a declarative router
+ * function App() {
+ *   return (
+ *     <BrowserRouter>
+ *       <Routes>
+ *         <Route index element={<StepOne />} />
+ *         <Route path="step-2" element={<StepTwo />} />
+ *         <Route path="step-3" element={<StepThree />} />
+ *       </Routes>
+ *    </BrowserRouter>
+ *   );
+ * }
+ *
+ * // But can be used with a data router as well if you prefer the JSX notation
+ * const routes = createRoutesFromElements(
+ *   <>
+ *     <Route index loader={step1Loader} Component={StepOne} />
+ *     <Route path="step-2" loader={step2Loader} Component={StepTwo} />
+ *     <Route path="step-3" loader={step3Loader} Component={StepThree} />
+ *   </>
+ * );
+ *
+ * const router = createBrowserRouter(routes);
+ *
+ * function App() {
+ *   return <RouterProvider router={router} />;
+ * }
+ *
+ * @public
+ * @category Components
+ * @param props Props
+ * @param {PathRouteProps.action} props.action n/a
+ * @param {PathRouteProps.caseSensitive} props.caseSensitive n/a
+ * @param {PathRouteProps.Component} props.Component n/a
+ * @param {PathRouteProps.children} props.children n/a
+ * @param {PathRouteProps.element} props.element n/a
+ * @param {PathRouteProps.ErrorBoundary} props.ErrorBoundary n/a
+ * @param {PathRouteProps.errorElement} props.errorElement n/a
+ * @param {PathRouteProps.handle} props.handle n/a
+ * @param {PathRouteProps.HydrateFallback} props.HydrateFallback n/a
+ * @param {PathRouteProps.hydrateFallbackElement} props.hydrateFallbackElement n/a
+ * @param {PathRouteProps.id} props.id n/a
+ * @param {PathRouteProps.index} props.index n/a
+ * @param {PathRouteProps.lazy} props.lazy n/a
+ * @param {PathRouteProps.loader} props.loader n/a
+ * @param {PathRouteProps.path} props.path n/a
+ * @param {PathRouteProps.shouldRevalidate} props.shouldRevalidate n/a
+ * @returns {void}
  */
-declare function createRouter(init: RouterInit): Router$1;
-interface CreateStaticHandlerOptions {
-    basename?: string;
-    mapRouteProperties?: MapRoutePropertiesFunction;
-    future?: {};
-}
-
-declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
-    hasErrorBoundary: boolean;
-};
-declare const hydrationRouteProperties: (keyof RouteObject)[];
+declare function Route(props: RouteProps): React.ReactElement | null;
 /**
- * @category Data Routers
+ * @category Types
  */
-interface MemoryRouterOpts {
+interface RouterProps {
     /**
-     * Basename path for the application.
+     * The base path for the application. This is prepended to all locations
      */
     basename?: string;
     /**
-     * A function that returns an {@link 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.
+     * Nested {@link Route} elements describing the route tree
      */
-    getContext?: RouterInit["getContext"];
+    children?: React.ReactNode;
     /**
-     * Future flags to enable for the router.
+     * The location to match against. Defaults to the current location.
+     * This can be a string or a {@link Location} object.
      */
-    future?: Partial<FutureConfig>;
+    location: Partial<Location> | string;
     /**
-     * Hydration data to initialize the router with if you have already performed
-     * data loading on the server.
+     * The type of navigation that triggered this `location` change.
+     * Defaults to {@link NavigationType.Pop}.
      */
-    hydrationData?: HydrationState;
+    navigationType?: Action;
     /**
-     * Initial entries in the in-memory history stack
+     * The navigator to use for navigation. This is usually a history object
+     * or a custom navigator that implements the {@link Navigator} interface.
      */
-    initialEntries?: InitialEntry[];
+    navigator: Navigator;
     /**
-     * Index of `initialEntries` the application should initialize to
+     * Whether this router is static or not (used for SSR). If `true`, the router
+     * will not be reactive to location changes.
      */
-    initialIndex?: number;
+    static?: boolean;
+}
+/**
+ * Provides location context for the rest of the app.
+ *
+ * Note: You usually won't render a `<Router>` directly. Instead, you'll render a
+ * router that is more specific to your environment such as a {@link BrowserRouter}
+ * in web browsers or a {@link ServerRouter} for server rendering.
+ *
+ * @public
+ * @category Declarative Routers
+ * @mode declarative
+ * @param props Props
+ * @param {RouterProps.basename} props.basename n/a
+ * @param {RouterProps.children} props.children n/a
+ * @param {RouterProps.location} props.location n/a
+ * @param {RouterProps.navigationType} props.navigationType n/a
+ * @param {RouterProps.navigator} props.navigator n/a
+ * @param {RouterProps.static} props.static n/a
+ * @returns React element for the rendered router or `null` if the location does
+ * not match the {@link props.basename}
+ */
+declare function Router$1({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, }: RouterProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface RoutesProps {
     /**
-     * Override the default data strategy of loading in parallel.
-     * Only intended for advanced usage.
+     * Nested {@link Route} elements
      */
-    dataStrategy?: DataStrategyFunction;
+    children?: React.ReactNode;
     /**
-     * Lazily define portions of the route tree on navigations.
+     * The {@link Location} to match against. Defaults to the current location.
      */
-    patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
+    location?: Partial<Location> | string;
 }
 /**
- * Create a new {@link DataRouter} that manages the application path using an
- * in-memory [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
- * stack. Useful for non-browser environments without a DOM API.
+ * Renders a branch of {@link Route | `<Route>`s} that best matches the current
+ * location. Note that these routes do not participate in [data loading](../../start/framework/route-module#loader),
+ * [`action`](../../start/framework/route-module#action), code splitting, or
+ * any other [route module](../../start/framework/route-module) features.
+ *
+ * @example
+ * import { Route, Routes } from "react-router";
+ *
+ * <Routes>
+ *   <Route index element={<StepOne />} />
+ *   <Route path="step-2" element={<StepTwo />} />
+ *   <Route path="step-3" element={<StepThree />} />
+ * </Routes>
  *
  * @public
- * @category Data Routers
- * @mode data
- * @param routes Application routes
- * @param opts Options
- * @param {MemoryRouterOpts.basename} opts.basename n/a
- * @param {MemoryRouterOpts.dataStrategy} opts.dataStrategy n/a
- * @param {MemoryRouterOpts.future} opts.future n/a
- * @param {MemoryRouterOpts.getContext} opts.getContext n/a
- * @param {MemoryRouterOpts.hydrationData} opts.hydrationData n/a
- * @param {MemoryRouterOpts.initialEntries} opts.initialEntries n/a
- * @param {MemoryRouterOpts.initialIndex} opts.initialIndex n/a
- * @param {MemoryRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
- * @returns An initialized {@link DataRouter} to pass to {@link RouterProvider | `<RouterProvider>`}
+ * @category Components
+ * @param props Props
+ * @param {RoutesProps.children} props.children n/a
+ * @param {RoutesProps.location} props.location n/a
+ * @returns React element for the rendered routes or `null` if no route matches
  */
-declare function createMemoryRouter(routes: RouteObject[], opts?: MemoryRouterOpts): Router$1;
+declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
+interface AwaitResolveRenderFunction<Resolve = any> {
+    (data: Awaited<Resolve>): React.ReactNode;
+}
 /**
- * Function signature for client side error handling for loader/actions errors
- * and rendering errors via `componentDidCatch`
+ * @category Types
+ */
+interface AwaitProps<Resolve> {
+    /**
+     * When using a function, the resolved value is provided as the parameter.
+     *
+     * ```tsx [2]
+     * <Await resolve={reviewsPromise}>
+     *   {(resolvedReviews) => <Reviews items={resolvedReviews} />}
+     * </Await>
+     * ```
+     *
+     * When using React elements, {@link useAsyncValue} will provide the
+     * resolved value:
+     *
+     * ```tsx [2]
+     * <Await resolve={reviewsPromise}>
+     *   <Reviews />
+     * </Await>
+     *
+     * function Reviews() {
+     *   const resolvedReviews = useAsyncValue();
+     *   return <div>...</div>;
+     * }
+     * ```
+     */
+    children: React.ReactNode | AwaitResolveRenderFunction<Resolve>;
+    /**
+     * The error element renders instead of the `children` when the [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+     * rejects.
+     *
+     * ```tsx
+     * <Await
+     *   errorElement={<div>Oops</div>}
+     *   resolve={reviewsPromise}
+     * >
+     *   <Reviews />
+     * </Await>
+     * ```
+     *
+     * To provide a more contextual error, you can use the {@link useAsyncError} in a
+     * child component
+     *
+     * ```tsx
+     * <Await
+     *   errorElement={<ReviewsError />}
+     *   resolve={reviewsPromise}
+     * >
+     *   <Reviews />
+     * </Await>
+     *
+     * function ReviewsError() {
+     *   const error = useAsyncError();
+     *   return <div>Error loading reviews: {error.message}</div>;
+     * }
+     * ```
+     *
+     * If you do not provide an `errorElement`, the rejected value will bubble up
+     * to the nearest route-level [`ErrorBoundary`](../../start/framework/route-module#errorboundary)
+     * and be accessible via the {@link useRouteError} hook.
+     */
+    errorElement?: React.ReactNode;
+    /**
+     * Takes a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+     * returned from a [`loader`](../../start/framework/route-module#loader) to be
+     * resolved and rendered.
+     *
+     * ```tsx
+     * import { Await, useLoaderData } from "react-router";
+     *
+     * export async function loader() {
+     *   let reviews = getReviews(); // not awaited
+     *   let book = await getBook();
+     *   return {
+     *     book,
+     *     reviews, // this is a promise
+     *   };
+     * }
+     *
+     * export default function Book() {
+     *   const {
+     *     book,
+     *     reviews, // this is the same promise
+     *   } = useLoaderData();
+     *
+     *   return (
+     *     <div>
+     *       <h1>{book.title}</h1>
+     *       <p>{book.description}</p>
+     *       <React.Suspense fallback={<ReviewsSkeleton />}>
+     *         <Await
+     *           // and is the promise we pass to Await
+     *           resolve={reviews}
+     *         >
+     *           <Reviews />
+     *         </Await>
+     *       </React.Suspense>
+     *     </div>
+     *   );
+     * }
+     * ```
+     */
+    resolve: Resolve;
+}
+/**
+ * Used to render promise values with automatic error handling.
+ *
+ * **Note:** `<Await>` expects to be rendered inside a [`<React.Suspense>`](https://react.dev/reference/react/Suspense)
+ *
+ * @example
+ * import { Await, useLoaderData } from "react-router";
+ *
+ * export async function loader() {
+ *   // not awaited
+ *   const reviews = getReviews();
+ *   // awaited (blocks the transition)
+ *   const book = await fetch("/api/book").then((res) => res.json());
+ *   return { book, reviews };
+ * }
+ *
+ * function Book() {
+ *   const { book, reviews } = useLoaderData();
+ *   return (
+ *     <div>
+ *       <h1>{book.title}</h1>
+ *       <p>{book.description}</p>
+ *       <React.Suspense fallback={<ReviewsSkeleton />}>
+ *         <Await
+ *           resolve={reviews}
+ *           errorElement={
+ *             <div>Could not load reviews 😬</div>
+ *           }
+ *           children={(resolvedReviews) => (
+ *             <Reviews items={resolvedReviews} />
+ *           )}
+ *         />
+ *       </React.Suspense>
+ *     </div>
+ *   );
+ * }
+ *
+ * @public
+ * @category Components
+ * @mode framework
+ * @mode data
+ * @param props Props
+ * @param {AwaitProps.children} props.children n/a
+ * @param {AwaitProps.errorElement} props.errorElement n/a
+ * @param {AwaitProps.resolve} props.resolve n/a
+ * @returns React element for the rendered awaited value
  */
-interface unstable_ClientOnErrorFunction {
-    (error: unknown, errorInfo?: React.ErrorInfo): void;
-}
+declare function Await<Resolve>({ children, errorElement, resolve, }: AwaitProps<Resolve>): React.JSX.Element;
 /**
- * @category Types
+ * Creates a route config from a React "children" object, which is usually
+ * either a `<Route>` element or an array of them. Used internally by
+ * `<Routes>` to create a route config from its children.
+ *
+ * @category Utils
+ * @mode data
+ * @param children The React children to convert into a route config
+ * @param parentPath The path of the parent route, used to generate unique IDs.
+ * @returns An array of {@link RouteObject}s that can be used with a {@link DataRouter}
  */
-interface RouterProviderProps {
-    /**
-     * The {@link DataRouter} instance to use for navigation and data fetching.
-     */
-    router: Router$1;
-    /**
-     * The [`ReactDOM.flushSync`](https://react.dev/reference/react-dom/flushSync)
-     * implementation to use for flushing updates.
-     *
-     * You usually don't have to worry about this:
-     * - The `RouterProvider` exported from `react-router/dom` handles this internally for you
-     * - If you are rendering in a non-DOM environment, you can import
-     *   `RouterProvider` from `react-router` and ignore this prop
-     */
-    flushSync?: (fn: () => unknown) => undefined;
-    /**
-     * An error handler function that will be called for any loader/action/render
-     * errors that are encountered in your application.  This is useful for
-     * logging or reporting errors instead of the `ErrorBoundary` because it's not
-     * subject to re-rendering and will only run one time per error.
-     *
-     * The `errorInfo` parameter is passed along from
-     * [`componentDidCatch`](https://react.dev/reference/react/Component#componentdidcatch)
-     * and is only present for render errors.
-     *
-     * ```tsx
-     * <RouterProvider unstable_onError=(error, errorInfo) => {
-     *   console.error(error, errorInfo);
-     *   reportToErrorService(error, errorInfo);
-     * }} />
-     * ```
-     */
-    unstable_onError?: unstable_ClientOnErrorFunction;
-}
+declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[];
 /**
- * Render the UI for the given {@link DataRouter}. This component should
- * typically be at the top of an app's element tree.
- *
- * ```tsx
- * import { createBrowserRouter } from "react-router";
- * import { RouterProvider } from "react-router/dom";
- * import { createRoot } from "react-dom/client";
+ * Create route objects from JSX elements instead of arrays of objects.
  *
- * const router = createBrowserRouter(routes);
- * createRoot(document.getElementById("root")).render(
- *   <RouterProvider router={router} />
+ * @example
+ * const routes = createRoutesFromElements(
+ *   <>
+ *     <Route index loader={step1Loader} Component={StepOne} />
+ *     <Route path="step-2" loader={step2Loader} Component={StepTwo} />
+ *     <Route path="step-3" loader={step3Loader} Component={StepThree} />
+ *   </>
  * );
- * ```
  *
- * <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>
+ * const router = createBrowserRouter(routes);
  *
+ * function App() {
+ *   return <RouterProvider router={router} />;
+ * }
  *
+ * @name createRoutesFromElements
  * @public
- * @category Data Routers
+ * @category Utils
  * @mode data
- * @param props Props
- * @param {RouterProviderProps.flushSync} props.flushSync n/a
- * @param {RouterProviderProps.unstable_onError} props.unstable_onError n/a
- * @param {RouterProviderProps.router} props.router n/a
- * @returns React element for the rendered router
+ * @param children The React children to convert into a route config
+ * @param parentPath The path of the parent route, used to generate unique IDs.
+ * This is used for internal recursion and is not intended to be used by the
+ * application developer.
+ * @returns An array of {@link RouteObject}s that can be used with a {@link DataRouter}
  */
-declare function RouterProvider({ router, flushSync: reactDomFlushSyncImpl, unstable_onError, }: RouterProviderProps): React.ReactElement;
+declare const createRoutesFromElements: typeof createRoutesFromChildren;
 /**
- * @category Types
+ * Renders the result of {@link matchRoutes} into a React element.
+ *
+ * @public
+ * @category Utils
+ * @param matches The array of {@link RouteMatch | route matches} to render
+ * @returns A React element that renders the matched routes or `null` if no matches
  */
-interface MemoryRouterProps {
+declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
+declare function useRouteComponentProps(): {
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+    matches: UIMatch<unknown, unknown>[];
+};
+type RouteComponentProps = ReturnType<typeof useRouteComponentProps>;
+type RouteComponentType = React.ComponentType<RouteComponentProps>;
+declare function WithComponentProps({ children, }: {
+    children: React.ReactElement;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare function withComponentProps(Component: RouteComponentType): () => React.ReactElement<{
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+    matches: UIMatch<unknown, unknown>[];
+}, string | React.JSXElementConstructor<any>>;
+declare function useHydrateFallbackProps(): {
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+};
+type HydrateFallbackProps = ReturnType<typeof useHydrateFallbackProps>;
+type HydrateFallbackType = React.ComponentType<HydrateFallbackProps>;
+declare function WithHydrateFallbackProps({ children, }: {
+    children: React.ReactElement;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare function withHydrateFallbackProps(HydrateFallback: HydrateFallbackType): () => React.ReactElement<{
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+}, string | React.JSXElementConstructor<any>>;
+declare function useErrorBoundaryProps(): {
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+    error: unknown;
+};
+type ErrorBoundaryProps = ReturnType<typeof useErrorBoundaryProps>;
+type ErrorBoundaryType = React.ComponentType<ErrorBoundaryProps>;
+declare function WithErrorBoundaryProps({ children, }: {
+    children: React.ReactElement;
+}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare function withErrorBoundaryProps(ErrorBoundary: ErrorBoundaryType): () => React.ReactElement<{
+    params: Readonly<Params<string>>;
+    loaderData: any;
+    actionData: any;
+    error: unknown;
+}, string | React.JSXElementConstructor<any>>;
+
+interface IndexRouteObject {
+    caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
+    path?: AgnosticIndexRouteObject["path"];
+    id?: AgnosticIndexRouteObject["id"];
+    middleware?: AgnosticIndexRouteObject["middleware"];
+    loader?: AgnosticIndexRouteObject["loader"];
+    action?: AgnosticIndexRouteObject["action"];
+    hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: AgnosticIndexRouteObject["shouldRevalidate"];
+    handle?: AgnosticIndexRouteObject["handle"];
+    index: true;
+    children?: undefined;
+    element?: React.ReactNode | null;
+    hydrateFallbackElement?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    Component?: React.ComponentType | null;
+    HydrateFallback?: React.ComponentType | null;
+    ErrorBoundary?: React.ComponentType | null;
+    lazy?: LazyRouteDefinition<RouteObject>;
+}
+interface NonIndexRouteObject {
+    caseSensitive?: AgnosticNonIndexRouteObject["caseSensitive"];
+    path?: AgnosticNonIndexRouteObject["path"];
+    id?: AgnosticNonIndexRouteObject["id"];
+    middleware?: AgnosticNonIndexRouteObject["middleware"];
+    loader?: AgnosticNonIndexRouteObject["loader"];
+    action?: AgnosticNonIndexRouteObject["action"];
+    hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: AgnosticNonIndexRouteObject["shouldRevalidate"];
+    handle?: AgnosticNonIndexRouteObject["handle"];
+    index?: false;
+    children?: RouteObject[];
+    element?: React.ReactNode | null;
+    hydrateFallbackElement?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    Component?: React.ComponentType | null;
+    HydrateFallback?: React.ComponentType | null;
+    ErrorBoundary?: React.ComponentType | null;
+    lazy?: LazyRouteDefinition<RouteObject>;
+}
+type RouteObject = IndexRouteObject | NonIndexRouteObject;
+type DataRouteObject = RouteObject & {
+    children?: DataRouteObject[];
+    id: string;
+};
+interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {
+}
+interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
+}
+type PatchRoutesOnNavigationFunctionArgs = AgnosticPatchRoutesOnNavigationFunctionArgs<RouteObject, RouteMatch>;
+type PatchRoutesOnNavigationFunction = AgnosticPatchRoutesOnNavigationFunction<RouteObject, RouteMatch>;
+interface DataRouterContextObject extends Omit<NavigationContextObject, "future"> {
+    router: Router;
+    staticContext?: StaticHandlerContext;
+    unstable_onError?: unstable_ClientOnErrorFunction;
+}
+declare const DataRouterContext: React.Context<DataRouterContextObject | null>;
+declare const DataRouterStateContext: React.Context<RouterState | null>;
+type ViewTransitionContextObject = {
+    isTransitioning: false;
+} | {
+    isTransitioning: true;
+    flushSync: boolean;
+    currentLocation: Location;
+    nextLocation: Location;
+};
+declare const ViewTransitionContext: React.Context<ViewTransitionContextObject>;
+type FetchersContextObject = Map<string, any>;
+declare const FetchersContext: React.Context<FetchersContextObject>;
+declare const AwaitContext: React.Context<TrackedPromise | null>;
+declare const AwaitContextProvider: (props: React.ComponentProps<typeof AwaitContext.Provider>) => React.FunctionComponentElement<React.ProviderProps<TrackedPromise | null>>;
+interface NavigateOptions {
+    /** Replace the current entry in the history stack instead of pushing a new one */
+    replace?: boolean;
+    /** Adds persistent client side routing state to the next location */
+    state?: any;
+    /** If you are using {@link https://api.reactrouter.com/v7/functions/react_router.ScrollRestoration.html <ScrollRestoration>}, prevent the scroll position from being reset to the top of the window when navigating */
+    preventScrollReset?: boolean;
+    /** Defines the relative path behavior for the link. "route" will use the route hierarchy so ".." will remove all URL segments of the current route pattern while "path" will use the URL path so ".." will remove one URL segment. */
+    relative?: RelativeRoutingType;
+    /** Wraps the initial state update for this navigation in a {@link https://react.dev/reference/react-dom/flushSync ReactDOM.flushSync} call instead of the default {@link https://react.dev/reference/react/startTransition React.startTransition} */
+    flushSync?: boolean;
+    /** Enables a {@link https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API View Transition} for this navigation by wrapping the final state update in `document.startViewTransition()`. If you need to apply specific styles for this view transition, you will also need to leverage the {@link https://api.reactrouter.com/v7/functions/react_router.useViewTransitionState.html useViewTransitionState()} hook.  */
+    viewTransition?: boolean;
+}
+/**
+ * A Navigator is a "location changer"; it's how you get to different locations.
+ *
+ * Every history instance conforms to the Navigator interface, but the
+ * distinction is useful primarily when it comes to the low-level `<Router>` API
+ * where both the location and a navigator must be provided separately in order
+ * to avoid "tearing" that may occur in a suspense-enabled app if the action
+ * and/or location were to be read directly from the history instance.
+ */
+interface Navigator {
+    createHref: History["createHref"];
+    encodeLocation?: History["encodeLocation"];
+    go: History["go"];
+    push(to: To, state?: any, opts?: NavigateOptions): void;
+    replace(to: To, state?: any, opts?: NavigateOptions): void;
+}
+interface NavigationContextObject {
+    basename: string;
+    navigator: Navigator;
+    static: boolean;
+    future: {};
+}
+declare const NavigationContext: React.Context<NavigationContextObject>;
+interface LocationContextObject {
+    location: Location;
+    navigationType: Action;
+}
+declare const LocationContext: React.Context<LocationContextObject>;
+interface RouteContextObject {
+    outlet: React.ReactElement | null;
+    matches: RouteMatch[];
+    isDataRoute: boolean;
+}
+declare const RouteContext: React.Context<RouteContextObject>;
+
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+interface HtmlLinkProps {
     /**
-     * Application basename
+     * Address of the hyperlink
      */
-    basename?: string;
+    href?: string;
     /**
-     * Nested {@link Route} elements describing the route tree
+     * How the element handles crossorigin requests
      */
-    children?: React.ReactNode;
+    crossOrigin?: "anonymous" | "use-credentials";
     /**
-     * Initial entries in the in-memory history stack
+     * Relationship between the document containing the hyperlink and the destination resource
      */
-    initialEntries?: InitialEntry[];
+    rel: LiteralUnion<"alternate" | "dns-prefetch" | "icon" | "manifest" | "modulepreload" | "next" | "pingback" | "preconnect" | "prefetch" | "preload" | "prerender" | "search" | "stylesheet", string>;
     /**
-     * Index of `initialEntries` the application should initialize to
+     * Applicable media: "screen", "print", "(max-width: 764px)"
      */
-    initialIndex?: number;
-}
-/**
- * A declarative {@link Router | `<Router>`} that stores all entries in memory.
- *
- * @public
- * @category Declarative Routers
- * @mode declarative
- * @param props Props
- * @param {MemoryRouterProps.basename} props.basename n/a
- * @param {MemoryRouterProps.children} props.children n/a
- * @param {MemoryRouterProps.initialEntries} props.initialEntries n/a
- * @param {MemoryRouterProps.initialIndex} props.initialIndex n/a
- * @returns A declarative in-memory {@link Router | `<Router>`} for client-side
- * routing.
- */
-declare function MemoryRouter({ basename, children, initialEntries, initialIndex, }: MemoryRouterProps): React.ReactElement;
-/**
- * @category Types
- */
-interface NavigateProps {
+    media?: string;
     /**
-     * The path to navigate to. This can be a string or a {@link Path} object
+     * Integrity metadata used in Subresource Integrity checks
      */
-    to: To;
+    integrity?: string;
     /**
-     * Whether to replace the current entry in the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
-     * stack
+     * Language of the linked resource
      */
-    replace?: boolean;
+    hrefLang?: string;
     /**
-     * State to pass to the new {@link Location} to store in [`history.state`](https://developer.mozilla.org/en-US/docs/Web/API/History/state).
+     * Hint for the type of the referenced resource
      */
-    state?: any;
+    type?: string;
     /**
-     * How to interpret relative routing in the `to` prop.
-     * See {@link RelativeRoutingType}.
+     * Referrer policy for fetches initiated by the element
      */
-    relative?: RelativeRoutingType;
-}
-/**
- * A component-based version of {@link useNavigate} to use in a
- * [`React.Component` class](https://react.dev/reference/react/Component) where
- * hooks cannot be used.
- *
- * It's recommended to avoid using this component in favor of {@link useNavigate}.
- *
- * @example
- * <Navigate to="/tasks" />
- *
- * @public
- * @category Components
- * @param props Props
- * @param {NavigateProps.relative} props.relative n/a
- * @param {NavigateProps.replace} props.replace n/a
- * @param {NavigateProps.state} props.state n/a
- * @param {NavigateProps.to} props.to n/a
- * @returns {void}
- *
- */
-declare function Navigate({ to, replace, state, relative, }: NavigateProps): null;
-/**
- * @category Types
- */
-interface OutletProps {
+    referrerPolicy?: "" | "no-referrer" | "no-referrer-when-downgrade" | "same-origin" | "origin" | "strict-origin" | "origin-when-cross-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
     /**
-     * Provides a context value to the element tree below the outlet. Use when
-     * the parent route needs to provide values to child routes.
-     *
-     * ```tsx
-     * <Outlet context={myContextValue} />
-     * ```
-     *
-     * Access the context with {@link useOutletContext}.
+     * Sizes of the icons (for rel="icon")
      */
-    context?: unknown;
-}
-/**
- * Renders the matching child route of a parent route or nothing if no child
- * route matches.
- *
- * @example
- * import { Outlet } from "react-router";
- *
- * export default function SomeParent() {
- *   return (
- *     <div>
- *       <h1>Parent Content</h1>
- *       <Outlet />
- *     </div>
- *   );
- * }
- *
- * @public
- * @category Components
- * @param props Props
- * @param {OutletProps.context} props.context n/a
- * @returns React element for the rendered outlet or `null` if no child route matches.
- */
-declare function Outlet(props: OutletProps): React.ReactElement | null;
-/**
- * @category Types
- */
-interface PathRouteProps {
+    sizes?: string;
     /**
-     * Whether the path should be case-sensitive. Defaults to `false`.
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
      */
-    caseSensitive?: NonIndexRouteObject["caseSensitive"];
+    as?: LiteralUnion<"audio" | "audioworklet" | "document" | "embed" | "fetch" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "serviceworker" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt", string>;
     /**
-     * The path pattern to match. If unspecified or empty, then this becomes a
-     * layout route.
+     * Color to use when customizing a site's icon (for rel="mask-icon")
      */
-    path?: NonIndexRouteObject["path"];
+    color?: string;
     /**
-     * The unique identifier for this route (for use with {@link DataRouter}s)
+     * Whether the link is disabled
      */
-    id?: NonIndexRouteObject["id"];
+    disabled?: boolean;
     /**
-     * A function that returns a promise that resolves to the route object.
-     * Used for code-splitting routes.
-     * See [`lazy`](../../start/data/route-object#lazy).
+     * The title attribute has special semantics on this element: Title of the link; CSS style sheet set name.
      */
-    lazy?: LazyRouteFunction<NonIndexRouteObject>;
+    title?: string;
     /**
-     * The route middleware.
-     * See [`middleware`](../../start/data/route-object#middleware).
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
      */
-    middleware?: NonIndexRouteObject["middleware"];
+    imageSrcSet?: string;
     /**
-     * The route loader.
-     * See [`loader`](../../start/data/route-object#loader).
+     * Image sizes for different page layouts (for rel="preload")
      */
-    loader?: NonIndexRouteObject["loader"];
+    imageSizes?: string;
+}
+interface HtmlLinkPreloadImage extends HtmlLinkProps {
     /**
-     * The route action.
-     * See [`action`](../../start/data/route-object#action).
+     * Relationship between the document containing the hyperlink and the destination resource
      */
-    action?: NonIndexRouteObject["action"];
-    hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"];
+    rel: "preload";
     /**
-     * The route shouldRevalidate function.
-     * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
      */
-    shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"];
+    as: "image";
     /**
-     * The route handle.
+     * Address of the hyperlink
      */
-    handle?: NonIndexRouteObject["handle"];
+    href?: string;
     /**
-     * Whether this is an index route.
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
      */
-    index?: false;
+    imageSrcSet: string;
     /**
-     * Child Route components
+     * Image sizes for different page layouts (for rel="preload")
      */
-    children?: React.ReactNode;
+    imageSizes?: string;
+}
+/**
+ * Represents a `<link>` element.
+ *
+ * WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
+ */
+type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
+    imageSizes?: never;
+});
+interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
     /**
-     * The React element to render when this Route matches.
-     * Mutually exclusive with `Component`.
+     * 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
      */
-    element?: React.ReactNode | null;
+    nonce?: string | undefined;
     /**
-     * The React element to render while this router is loading data.
-     * Mutually exclusive with `HydrateFallback`.
+     * The absolute path of the page to prefetch, e.g. `/absolute/path`.
      */
-    hydrateFallbackElement?: React.ReactNode | null;
+    page: string;
+}
+type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
+
+type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
+    [key: PropertyKey]: Serializable;
+} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
+
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Func = (...args: any[]) => unknown;
+type Pretty<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Normalize<T> = _Normalize<UnionKeys<T>, T>;
+type _Normalize<Key extends keyof any, T> = T extends infer U ? Pretty<{
+    [K in Key as K extends keyof U ? undefined extends U[K] ? never : K : never]: K extends keyof U ? U[K] : never;
+} & {
+    [K in Key as K extends keyof U ? undefined extends U[K] ? K : never : never]?: K extends keyof U ? U[K] : never;
+} & {
+    [K in Key as K extends keyof U ? never : K]?: undefined;
+}> : never;
+type UnionKeys<T> = T extends any ? keyof T : never;
+
+type RouteModule$1 = {
+    meta?: Func;
+    links?: Func;
+    headers?: Func;
+    loader?: Func;
+    clientLoader?: Func;
+    action?: Func;
+    clientAction?: Func;
+    HydrateFallback?: Func;
+    default?: Func;
+    ErrorBoundary?: Func;
+    [key: string]: unknown;
+};
+
+/**
+ * A brand that can be applied to a type to indicate that it will serialize
+ * to a specific type when transported to the client from a loader.
+ * Only use this if you have additional serialization/deserialization logic
+ * in your application.
+ */
+type unstable_SerializesTo<T> = {
+    unstable__ReactRouter_SerializesTo: [T];
+};
+
+type Serialize<T> = T extends unstable_SerializesTo<infer To> ? To : T extends Serializable ? T : T extends (...args: any[]) => unknown ? undefined : T extends Promise<infer U> ? Promise<Serialize<U>> : T extends Map<infer K, infer V> ? Map<Serialize<K>, Serialize<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Serialize<K>, Serialize<V>> : T extends Set<infer U> ? Set<Serialize<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? {
+    [K in keyof T]: Serialize<T[K]>;
+} : undefined;
+type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
+type DataFrom<T> = IsAny<T> extends true ? undefined : T extends Func ? VoidToUndefined<Awaited<ReturnType<T>>> : undefined;
+type ClientData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? U : T;
+type ServerData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? Serialize<U> : Serialize<T>;
+type ServerDataFrom<T> = ServerData<DataFrom<T>>;
+type ClientDataFrom<T> = ClientData<DataFrom<T>>;
+type ClientDataFunctionArgs<Params> = {
+    /**
+     * A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the URL, the method, the "content-type" header, and the request body from the request.
+     *
+     * @note Because client data functions are called before a network request is made, the Request object does not include the headers which the browser automatically adds. React Router infers the "content-type" header from the enc-type of the form that performed the submission.
+     **/
+    request: Request;
     /**
-     * The React element to render at this route if an error occurs.
-     * Mutually exclusive with `ErrorBoundary`.
+     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+     * @example
+     * // app/routes.ts
+     * route("teams/:teamId", "./team.tsx"),
+     *
+     * // app/team.tsx
+     * export function clientLoader({
+     *   params,
+     * }: Route.ClientLoaderArgs) {
+     *   params.teamId;
+     *   //        ^ string
+     * }
+     **/
+    params: Params;
+    /**
+     * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+     * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
      */
-    errorElement?: React.ReactNode | null;
+    unstable_pattern: string;
     /**
-     * The React Component to render when this route matches.
-     * Mutually exclusive with `element`.
+     * When `future.v8_middleware` is not enabled, this is undefined.
+     *
+     * When `future.v8_middleware` is enabled, this is an instance of
+     * `RouterContextProvider` and can be used to access context values
+     * from your route middlewares.  You may pass in initial context values in your
+     * `<HydratedRouter getContext>` prop
      */
-    Component?: React.ComponentType | null;
+    context: Readonly<RouterContextProvider>;
+};
+type ServerDataFunctionArgs<Params> = {
+    /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the url, method, headers (such as cookies), and request body from the request. */
+    request: Request;
     /**
-     * The React Component to render while this router is loading data.
-     * Mutually exclusive with `hydrateFallbackElement`.
+     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+     * @example
+     * // app/routes.ts
+     * route("teams/:teamId", "./team.tsx"),
+     *
+     * // app/team.tsx
+     * export function loader({
+     *   params,
+     * }: Route.LoaderArgs) {
+     *   params.teamId;
+     *   //        ^ string
+     * }
+     **/
+    params: Params;
+    /**
+     * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+     * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
      */
-    HydrateFallback?: React.ComponentType | null;
+    unstable_pattern: string;
     /**
-     * The React Component to render at this route if an error occurs.
-     * Mutually exclusive with `errorElement`.
+     * Without `future.v8_middleware` enabled, this is the context passed in
+     * to your server adapter's `getLoadContext` function. It's a way to bridge the
+     * gap between the adapter's request/response API with your React Router app.
+     * It is only applicable if you are using a custom server adapter.
+     *
+     * With `future.v8_middleware` enabled, this is an instance of
+     * `RouterContextProvider` and can be used for type-safe access to
+     * context value set in your route middlewares.  If you are using a custom
+     * server adapter, you may provide an initial set of context values from your
+     * `getLoadContext` function.
      */
-    ErrorBoundary?: React.ComponentType | null;
+    context: MiddlewareEnabled extends true ? Readonly<RouterContextProvider> : AppLoadContext;
+};
+type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
+    ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
+] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
+type IsDefined<T> = Equal<T, undefined> extends true ? false : true;
+type IsHydrate<ClientLoader> = ClientLoader extends {
+    hydrate: true;
+} ? true : ClientLoader extends {
+    hydrate: false;
+} ? false : false;
+type GetLoaderData<T extends RouteModule$1> = _DataLoaderData<ServerDataFrom<T["loader"]>, ClientDataFrom<T["clientLoader"]>, IsHydrate<T["clientLoader"]>, T extends {
+    HydrateFallback: Func;
+} ? true : false>;
+type _DataLoaderData<ServerLoaderData, ClientLoaderData, ClientLoaderHydrate extends boolean, HasHydrateFallback> = [
+    HasHydrateFallback,
+    ClientLoaderHydrate
+] extends [true, true] ? IsDefined<ClientLoaderData> extends true ? ClientLoaderData : undefined : [
+    IsDefined<ClientLoaderData>,
+    IsDefined<ServerLoaderData>
+] extends [true, true] ? ServerLoaderData | ClientLoaderData : IsDefined<ClientLoaderData> extends true ? ClientLoaderData : IsDefined<ServerLoaderData> extends true ? ServerLoaderData : undefined;
+type GetActionData<T extends RouteModule$1> = _DataActionData<ServerDataFrom<T["action"]>, ClientDataFrom<T["clientAction"]>>;
+type _DataActionData<ServerActionData, ClientActionData> = Awaited<[
+    IsDefined<ServerActionData>,
+    IsDefined<ClientActionData>
+] extends [true, true] ? ServerActionData | ClientActionData : IsDefined<ClientActionData> extends true ? ClientActionData : IsDefined<ServerActionData> extends true ? ServerActionData : undefined>;
+
+interface RouteModules {
+    [routeId: string]: RouteModule | undefined;
+}
+/**
+ * The shape of a route module shipped to the client
+ */
+interface RouteModule {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    clientMiddleware?: MiddlewareFunction<Record<string, DataStrategyResult>>[];
+    ErrorBoundary?: ErrorBoundaryComponent;
+    HydrateFallback?: HydrateFallbackComponent;
+    Layout?: LayoutComponent;
+    default: RouteComponent;
+    handle?: RouteHandle;
+    links?: LinksFunction;
+    meta?: MetaFunction;
+    shouldRevalidate?: ShouldRevalidateFunction;
+}
+/**
+ * The shape of a route module on the server
+ */
+interface ServerRouteModule extends RouteModule {
+    action?: ActionFunction;
+    headers?: HeadersFunction | {
+        [name: string]: string;
+    };
+    loader?: LoaderFunction;
+    middleware?: MiddlewareFunction<Response>[];
+}
+/**
+ * A function that handles data mutations for a route on the client
+ */
+type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<ActionFunction>;
+/**
+ * Arguments passed to a route `clientAction` function
+ */
+type ClientActionFunctionArgs = ActionFunctionArgs & {
+    serverAction: <T = unknown>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * A function that loads data for a route on the client
+ */
+type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<LoaderFunction>) & {
+    hydrate?: boolean;
+};
+/**
+ * Arguments passed to a route `clientLoader` function
+ */
+type ClientLoaderFunctionArgs = LoaderFunctionArgs & {
+    serverLoader: <T = unknown>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * ErrorBoundary to display for this route
+ */
+type ErrorBoundaryComponent = ComponentType;
+type HeadersArgs = {
+    loaderHeaders: Headers;
+    parentHeaders: Headers;
+    actionHeaders: Headers;
+    errorHeaders: Headers | undefined;
+};
+/**
+ * A function that returns HTTP headers to be used for a route. These headers
+ * will be merged with (and take precedence over) headers from parent routes.
+ */
+interface HeadersFunction {
+    (args: HeadersArgs): Headers | HeadersInit;
 }
 /**
- * @category Types
+ * `<Route HydrateFallback>` component to render on initial loads
+ * when client loaders are present
+ */
+type HydrateFallbackComponent = ComponentType;
+/**
+ * Optional, root-only `<Route Layout>` component to wrap the root content in.
+ * Useful for defining the <html>/<head>/<body> document shell shared by the
+ * Component, HydrateFallback, and ErrorBoundary
+ */
+type LayoutComponent = ComponentType<{
+    children: ReactElement<unknown, ErrorBoundaryComponent | HydrateFallbackComponent | RouteComponent>;
+}>;
+/**
+ * A function that defines `<link>` tags to be inserted into the `<head>` of
+ * the document on route transitions.
+ *
+ * @see https://reactrouter.com/start/framework/route-module#meta
+ */
+interface LinksFunction {
+    (): LinkDescriptor[];
+}
+interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
+    id: RouteId;
+    pathname: DataRouteMatch["pathname"];
+    /** @deprecated Use `MetaMatch.loaderData` instead */
+    data: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
+    loaderData: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
+    handle?: RouteHandle;
+    params: DataRouteMatch["params"];
+    meta: MetaDescriptor[];
+    error?: unknown;
+}
+type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> = Array<{
+    [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
+}[keyof MatchLoaders]>;
+interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
+    /** @deprecated Use `MetaArgs.loaderData` instead */
+    data: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
+    loaderData: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
+    params: Params;
+    location: Location;
+    matches: MetaMatches<MatchLoaders>;
+    error?: unknown;
+}
+/**
+ * A function that returns an array of data objects to use for rendering
+ * metadata HTML tags in a route. These tags are not rendered on descendant
+ * routes in the route hierarchy. In other words, they will only be rendered on
+ * the route in which they are exported.
+ *
+ * @param Loader - The type of the current route's loader function
+ * @param MatchLoaders - Mapping from a parent route's filepath to its loader
+ * function type
+ *
+ * Note that parent route filepaths are relative to the `app/` directory.
+ *
+ * For example, if this meta function is for `/sales/customers/$customerId`:
+ *
+ * ```ts
+ * // app/root.tsx
+ * const loader = () => ({ hello: "world" })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales.tsx
+ * const loader = () => ({ salesCount: 1074 })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers.tsx
+ * const loader = () => ({ customerCount: 74 })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers/$customersId.tsx
+ * import type { Loader as RootLoader } from "../../../root"
+ * import type { Loader as SalesLoader } from "../../sales"
+ * import type { Loader as CustomersLoader } from "../../sales/customers"
+ *
+ * const loader = () => ({ name: "Customer name" })
+ *
+ * const meta: MetaFunction<typeof loader, {
+ *  "root": RootLoader,
+ *  "routes/sales": SalesLoader,
+ *  "routes/sales/customers": CustomersLoader,
+ * }> = ({ data, matches }) => {
+ *   const { name } = data
+ *   //      ^? string
+ *   const { customerCount } = matches.find((match) => match.id === "routes/sales/customers").data
+ *   //      ^? number
+ *   const { salesCount } = matches.find((match) => match.id === "routes/sales").data
+ *   //      ^? number
+ *   const { hello } = matches.find((match) => match.id === "root").data
+ *   //      ^? "world"
+ * }
+ * ```
+ */
+interface MetaFunction<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
+    (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
+}
+type MetaDescriptor = {
+    charSet: "utf-8";
+} | {
+    title: string;
+} | {
+    name: string;
+    content: string;
+} | {
+    property: string;
+    content: string;
+} | {
+    httpEquiv: string;
+    content: string;
+} | {
+    "script:ld+json": LdJsonObject;
+} | {
+    tagName: "meta" | "link";
+    [name: string]: string;
+} | {
+    [name: string]: unknown;
+};
+type LdJsonObject = {
+    [Key in string]: LdJsonValue;
+} & {
+    [Key in string]?: LdJsonValue | undefined;
+};
+type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
+type LdJsonPrimitive = string | number | boolean | null;
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
+/**
+ * A React component that is rendered for a route.
  */
-interface LayoutRouteProps extends PathRouteProps {
-}
+type RouteComponent = ComponentType<{}>;
 /**
- * @category Types
+ * An arbitrary object that is associated with a route.
+ *
+ * @see https://reactrouter.com/how-to/using-handle
  */
-interface IndexRouteProps {
+type RouteHandle = unknown;
+
+type unstable_ServerInstrumentation = {
+    handler?: unstable_InstrumentRequestHandlerFunction;
+    route?: unstable_InstrumentRouteFunction;
+};
+type unstable_ClientInstrumentation = {
+    router?: unstable_InstrumentRouterFunction;
+    route?: unstable_InstrumentRouteFunction;
+};
+type unstable_InstrumentRequestHandlerFunction = (handler: InstrumentableRequestHandler) => void;
+type unstable_InstrumentRouterFunction = (router: InstrumentableRouter) => void;
+type unstable_InstrumentRouteFunction = (route: InstrumentableRoute) => void;
+type unstable_InstrumentationHandlerResult = {
+    status: "success";
+    error: undefined;
+} | {
+    status: "error";
+    error: Error;
+};
+type InstrumentFunction<T> = (handler: () => Promise<unstable_InstrumentationHandlerResult>, info: T) => Promise<void>;
+type ReadonlyRequest = {
+    method: string;
+    url: string;
+    headers: Pick<Headers, "get">;
+};
+type ReadonlyContext = MiddlewareEnabled extends true ? Pick<RouterContextProvider, "get"> : Readonly<AppLoadContext>;
+type InstrumentableRoute = {
+    id: string;
+    index: boolean | undefined;
+    path: string | undefined;
+    instrument(instrumentations: RouteInstrumentations): void;
+};
+type RouteInstrumentations = {
+    lazy?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+    "lazy.loader"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+    "lazy.action"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+    "lazy.middleware"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
+    middleware?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+    loader?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+    action?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
+};
+type RouteLazyInstrumentationInfo = undefined;
+type RouteHandlerInstrumentationInfo = Readonly<{
+    request: ReadonlyRequest;
+    params: LoaderFunctionArgs["params"];
+    unstable_pattern: string;
+    context: ReadonlyContext;
+}>;
+type InstrumentableRouter = {
+    instrument(instrumentations: RouterInstrumentations): void;
+};
+type RouterInstrumentations = {
+    navigate?: InstrumentFunction<RouterNavigationInstrumentationInfo>;
+    fetch?: InstrumentFunction<RouterFetchInstrumentationInfo>;
+};
+type RouterNavigationInstrumentationInfo = Readonly<{
+    to: string | number;
+    currentUrl: string;
+    formMethod?: HTMLFormMethod;
+    formEncType?: FormEncType;
+    formData?: FormData;
+    body?: any;
+}>;
+type RouterFetchInstrumentationInfo = Readonly<{
+    href: string;
+    currentUrl: string;
+    fetcherKey: string;
+    formMethod?: HTMLFormMethod;
+    formEncType?: FormEncType;
+    formData?: FormData;
+    body?: any;
+}>;
+type InstrumentableRequestHandler = {
+    instrument(instrumentations: RequestHandlerInstrumentations): void;
+};
+type RequestHandlerInstrumentations = {
+    request?: InstrumentFunction<RequestHandlerInstrumentationInfo>;
+};
+type RequestHandlerInstrumentationInfo = Readonly<{
+    request: ReadonlyRequest;
+    context: ReadonlyContext | undefined;
+}>;
+
+/**
+ * A Router instance manages all navigation and data loading/mutations
+ */
+interface Router {
     /**
-     * Whether the path should be case-sensitive. Defaults to `false`.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the basename for the router
      */
-    caseSensitive?: IndexRouteObject["caseSensitive"];
+    get basename(): RouterInit["basename"];
     /**
-     * The path pattern to match. If unspecified or empty, then this becomes a
-     * layout route.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the future config for the router
      */
-    path?: IndexRouteObject["path"];
+    get future(): FutureConfig;
     /**
-     * The unique identifier for this route (for use with {@link DataRouter}s)
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the current state of the router
      */
-    id?: IndexRouteObject["id"];
+    get state(): RouterState;
     /**
-     * A function that returns a promise that resolves to the route object.
-     * Used for code-splitting routes.
-     * See [`lazy`](../../start/data/route-object#lazy).
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the routes for this router instance
      */
-    lazy?: LazyRouteFunction<IndexRouteObject>;
+    get routes(): AgnosticDataRouteObject[];
     /**
-     * The route middleware.
-     * See [`middleware`](../../start/data/route-object#middleware).
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the window associated with the router
      */
-    middleware?: IndexRouteObject["middleware"];
+    get window(): RouterInit["window"];
     /**
-     * The route loader.
-     * See [`loader`](../../start/data/route-object#loader).
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Initialize the router, including adding history listeners and kicking off
+     * initial data fetches.  Returns a function to cleanup listeners and abort
+     * any in-progress loads
      */
-    loader?: IndexRouteObject["loader"];
+    initialize(): Router;
     /**
-     * The route action.
-     * See [`action`](../../start/data/route-object#action).
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Subscribe to router.state updates
+     *
+     * @param fn function to call with the new state
      */
-    action?: IndexRouteObject["action"];
-    hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"];
+    subscribe(fn: RouterSubscriber): () => void;
     /**
-     * The route shouldRevalidate function.
-     * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Enable scroll restoration behavior in the router
+     *
+     * @param savedScrollPositions Object that will manage positions, in case
+     *                             it's being restored from sessionStorage
+     * @param getScrollPosition    Function to get the active Y scroll position
+     * @param getKey               Function to get the key to use for restoration
      */
-    shouldRevalidate?: IndexRouteObject["shouldRevalidate"];
+    enableScrollRestoration(savedScrollPositions: Record<string, number>, getScrollPosition: GetScrollPositionFunction, getKey?: GetScrollRestorationKeyFunction): () => void;
     /**
-     * The route handle.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Navigate forward/backward in the history stack
+     * @param to Delta to move in the history stack
      */
-    handle?: IndexRouteObject["handle"];
+    navigate(to: number): Promise<void>;
     /**
-     * Whether this is an index route.
+     * Navigate to the given path
+     * @param to Path to navigate to
+     * @param opts Navigation options (method, submission, etc.)
      */
-    index: true;
+    navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;
     /**
-     * Child Route components
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Trigger a fetcher load/submission
+     *
+     * @param key     Fetcher key
+     * @param routeId Route that owns the fetcher
+     * @param href    href to fetch
+     * @param opts    Fetcher options, (method, submission, etc.)
      */
-    children?: undefined;
+    fetch(key: string, routeId: string, href: string | null, opts?: RouterFetchOptions): Promise<void>;
     /**
-     * The React element to render when this Route matches.
-     * Mutually exclusive with `Component`.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Trigger a revalidation of all current route loaders and fetcher loads
      */
-    element?: React.ReactNode | null;
+    revalidate(): Promise<void>;
     /**
-     * The React element to render while this router is loading data.
-     * Mutually exclusive with `HydrateFallback`.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Utility function to create an href for the given location
+     * @param location
      */
-    hydrateFallbackElement?: React.ReactNode | null;
+    createHref(location: Location | URL): string;
     /**
-     * The React element to render at this route if an error occurs.
-     * Mutually exclusive with `ErrorBoundary`.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Utility function to URL encode a destination path according to the internal
+     * history implementation
+     * @param to
      */
-    errorElement?: React.ReactNode | null;
+    encodeLocation(to: To): Path;
     /**
-     * The React Component to render when this route matches.
-     * Mutually exclusive with `element`.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Get/create a fetcher for the given key
+     * @param key
      */
-    Component?: React.ComponentType | null;
+    getFetcher<TData = any>(key: string): Fetcher<TData>;
     /**
-     * The React Component to render while this router is loading data.
-     * Mutually exclusive with `hydrateFallbackElement`.
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Reset the fetcher for a given key
+     * @param key
      */
-    HydrateFallback?: React.ComponentType | null;
+    resetFetcher(key: string, opts?: {
+        reason?: unknown;
+    }): void;
     /**
-     * The React Component to render at this route if an error occurs.
-     * Mutually exclusive with `errorElement`.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Delete the fetcher for a given key
+     * @param key
      */
-    ErrorBoundary?: React.ComponentType | null;
-}
-type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;
-/**
- * Configures an element to render when a pattern matches the current location.
- * It must be rendered within a {@link Routes} element. Note that these routes
- * do not participate in data loading, actions, code splitting, or any other
- * route module features.
- *
- * @example
- * // Usually used in a declarative router
- * function App() {
- *   return (
- *     <BrowserRouter>
- *       <Routes>
- *         <Route index element={<StepOne />} />
- *         <Route path="step-2" element={<StepTwo />} />
- *         <Route path="step-3" element={<StepThree />} />
- *       </Routes>
- *    </BrowserRouter>
- *   );
- * }
- *
- * // But can be used with a data router as well if you prefer the JSX notation
- * const routes = createRoutesFromElements(
- *   <>
- *     <Route index loader={step1Loader} Component={StepOne} />
- *     <Route path="step-2" loader={step2Loader} Component={StepTwo} />
- *     <Route path="step-3" loader={step3Loader} Component={StepThree} />
- *   </>
- * );
- *
- * const router = createBrowserRouter(routes);
- *
- * function App() {
- *   return <RouterProvider router={router} />;
- * }
- *
- * @public
- * @category Components
- * @param props Props
- * @param {PathRouteProps.action} props.action n/a
- * @param {PathRouteProps.caseSensitive} props.caseSensitive n/a
- * @param {PathRouteProps.Component} props.Component n/a
- * @param {PathRouteProps.children} props.children n/a
- * @param {PathRouteProps.element} props.element n/a
- * @param {PathRouteProps.ErrorBoundary} props.ErrorBoundary n/a
- * @param {PathRouteProps.errorElement} props.errorElement n/a
- * @param {PathRouteProps.handle} props.handle n/a
- * @param {PathRouteProps.HydrateFallback} props.HydrateFallback n/a
- * @param {PathRouteProps.hydrateFallbackElement} props.hydrateFallbackElement n/a
- * @param {PathRouteProps.id} props.id n/a
- * @param {PathRouteProps.index} props.index n/a
- * @param {PathRouteProps.lazy} props.lazy n/a
- * @param {PathRouteProps.loader} props.loader n/a
- * @param {PathRouteProps.path} props.path n/a
- * @param {PathRouteProps.shouldRevalidate} props.shouldRevalidate n/a
- * @returns {void}
- */
-declare function Route(props: RouteProps): React.ReactElement | null;
-/**
- * @category Types
- */
-interface RouterProps {
+    deleteFetcher(key: string): void;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Cleanup listeners and abort any in-progress loads
+     */
+    dispose(): void;
     /**
-     * The base path for the application. This is prepended to all locations
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Get a navigation blocker
+     * @param key The identifier for the blocker
+     * @param fn The blocker function implementation
      */
-    basename?: string;
+    getBlocker(key: string, fn: BlockerFunction): Blocker;
     /**
-     * Nested {@link Route} elements describing the route tree
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Delete a navigation blocker
+     * @param key The identifier for the blocker
      */
-    children?: React.ReactNode;
+    deleteBlocker(key: string): void;
     /**
-     * The location to match against. Defaults to the current location.
-     * This can be a string or a {@link Location} object.
+     * @private
+     * PRIVATE DO NOT USE
+     *
+     * Patch additional children routes into an existing parent route
+     * @param routeId The parent route id or a callback function accepting `patch`
+     *                to perform batch patching
+     * @param children The additional children routes
+     * @param unstable_allowElementMutations Allow mutation or route elements on
+     *                                       existing routes. Intended for RSC-usage
+     *                                       only.
      */
-    location: Partial<Location> | string;
+    patchRoutes(routeId: string | null, children: AgnosticRouteObject[], unstable_allowElementMutations?: boolean): void;
     /**
-     * The type of navigation that triggered this `location` change.
-     * Defaults to {@link NavigationType.Pop}.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * HMR needs to pass in-flight route updates to React Router
+     * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)
      */
-    navigationType?: Action;
+    _internalSetRoutes(routes: AgnosticRouteObject[]): void;
     /**
-     * The navigator to use for navigation. This is usually a history object
-     * or a custom navigator that implements the {@link Navigator} interface.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Cause subscribers to re-render.  This is used to force a re-render.
      */
-    navigator: Navigator;
+    _internalSetStateDoNotUseOrYouWillBreakYourApp(state: Partial<RouterState>): void;
     /**
-     * Whether this router is static or not (used for SSR). If `true`, the router
-     * will not be reactive to location changes.
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Internal fetch AbortControllers accessed by unit tests
      */
-    static?: boolean;
+    _internalFetchControllers: Map<string, AbortController>;
 }
 /**
- * Provides location context for the rest of the app.
- *
- * Note: You usually won't render a `<Router>` directly. Instead, you'll render a
- * router that is more specific to your environment such as a {@link BrowserRouter}
- * in web browsers or a {@link ServerRouter} for server rendering.
- *
- * @public
- * @category Declarative Routers
- * @mode declarative
- * @param props Props
- * @param {RouterProps.basename} props.basename n/a
- * @param {RouterProps.children} props.children n/a
- * @param {RouterProps.location} props.location n/a
- * @param {RouterProps.navigationType} props.navigationType n/a
- * @param {RouterProps.navigator} props.navigator n/a
- * @param {RouterProps.static} props.static n/a
- * @returns React element for the rendered router or `null` if the location does
- * not match the {@link props.basename}
- */
-declare function Router({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, }: RouterProps): React.ReactElement | null;
-/**
- * @category Types
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the "old" location unless otherwise noted.
  */
-interface RoutesProps {
+interface RouterState {
     /**
-     * Nested {@link Route} elements
+     * The action of the most recent navigation
      */
-    children?: React.ReactNode;
+    historyAction: Action;
     /**
-     * The {@link Location} to match against. Defaults to the current location.
+     * The current location reflected by the router
      */
-    location?: Partial<Location> | string;
-}
-/**
- * Renders a branch of {@link Route | `<Route>`s} that best matches the current
- * location. Note that these routes do not participate in [data loading](../../start/framework/route-module#loader),
- * [`action`](../../start/framework/route-module#action), code splitting, or
- * any other [route module](../../start/framework/route-module) features.
- *
- * @example
- * import { Route, Routes } from "react-router";
- *
- * <Routes>
- *   <Route index element={<StepOne />} />
- *   <Route path="step-2" element={<StepTwo />} />
- *   <Route path="step-3" element={<StepThree />} />
- * </Routes>
- *
- * @public
- * @category Components
- * @param props Props
- * @param {RoutesProps.children} props.children n/a
- * @param {RoutesProps.location} props.location n/a
- * @returns React element for the rendered routes or `null` if no route matches
- */
-declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
-interface AwaitResolveRenderFunction<Resolve = any> {
-    (data: Awaited<Resolve>): React.ReactNode;
-}
-/**
- * @category Types
- */
-interface AwaitProps<Resolve> {
+    location: Location;
     /**
-     * When using a function, the resolved value is provided as the parameter.
-     *
-     * ```tsx [2]
-     * <Await resolve={reviewsPromise}>
-     *   {(resolvedReviews) => <Reviews items={resolvedReviews} />}
-     * </Await>
-     * ```
-     *
-     * When using React elements, {@link useAsyncValue} will provide the
-     * resolved value:
-     *
-     * ```tsx [2]
-     * <Await resolve={reviewsPromise}>
-     *   <Reviews />
-     * </Await>
-     *
-     * function Reviews() {
-     *   const resolvedReviews = useAsyncValue();
-     *   return <div>...</div>;
-     * }
-     * ```
+     * The current set of route matches
      */
-    children: React.ReactNode | AwaitResolveRenderFunction<Resolve>;
+    matches: AgnosticDataRouteMatch[];
     /**
-     * The error element renders instead of the `children` when the [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-     * rejects.
-     *
-     * ```tsx
-     * <Await
-     *   errorElement={<div>Oops</div>}
-     *   resolve={reviewsPromise}
-     * >
-     *   <Reviews />
-     * </Await>
-     * ```
-     *
-     * To provide a more contextual error, you can use the {@link useAsyncError} in a
-     * child component
-     *
-     * ```tsx
-     * <Await
-     *   errorElement={<ReviewsError />}
-     *   resolve={reviewsPromise}
-     * >
-     *   <Reviews />
-     * </Await>
-     *
-     * function ReviewsError() {
-     *   const error = useAsyncError();
-     *   return <div>Error loading reviews: {error.message}</div>;
-     * }
-     * ```
-     *
-     * If you do not provide an `errorElement`, the rejected value will bubble up
-     * to the nearest route-level [`ErrorBoundary`](../../start/framework/route-module#errorboundary)
-     * and be accessible via the {@link useRouteError} hook.
+     * Tracks whether we've completed our initial data load
      */
-    errorElement?: React.ReactNode;
+    initialized: boolean;
     /**
-     * Takes a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
-     * returned from a [`loader`](../../start/framework/route-module#loader) to be
-     * resolved and rendered.
-     *
-     * ```tsx
-     * import { Await, useLoaderData } from "react-router";
-     *
-     * export async function loader() {
-     *   let reviews = getReviews(); // not awaited
-     *   let book = await getBook();
-     *   return {
-     *     book,
-     *     reviews, // this is a promise
-     *   };
-     * }
-     *
-     * export default function Book() {
-     *   const {
-     *     book,
-     *     reviews, // this is the same promise
-     *   } = useLoaderData();
-     *
-     *   return (
-     *     <div>
-     *       <h1>{book.title}</h1>
-     *       <p>{book.description}</p>
-     *       <React.Suspense fallback={<ReviewsSkeleton />}>
-     *         <Await
-     *           // and is the promise we pass to Await
-     *           resolve={reviews}
-     *         >
-     *           <Reviews />
-     *         </Await>
-     *       </React.Suspense>
-     *     </div>
-     *   );
-     * }
-     * ```
+     * Current scroll position we should start at for a new view
+     *  - number -> scroll position to restore to
+     *  - false -> do not restore scroll at all (used during submissions/revalidations)
+     *  - null -> don't have a saved position, scroll to hash or top of page
+     */
+    restoreScrollPosition: number | false | null;
+    /**
+     * Indicate whether this navigation should skip resetting the scroll position
+     * if we are unable to restore the scroll position
+     */
+    preventScrollReset: boolean;
+    /**
+     * Tracks the state of the current navigation
+     */
+    navigation: Navigation;
+    /**
+     * Tracks any in-progress revalidations
+     */
+    revalidation: RevalidationState;
+    /**
+     * Data from the loaders for the current matches
+     */
+    loaderData: RouteData;
+    /**
+     * Data from the action for the current matches
+     */
+    actionData: RouteData | null;
+    /**
+     * Errors caught from loaders for the current matches
+     */
+    errors: RouteData | null;
+    /**
+     * Map of current fetchers
+     */
+    fetchers: Map<string, Fetcher>;
+    /**
+     * Map of current blockers
      */
-    resolve: Resolve;
+    blockers: Map<string, Blocker>;
 }
 /**
- * Used to render promise values with automatic error handling.
- *
- * **Note:** `<Await>` expects to be rendered inside a [`<React.Suspense>`](https://react.dev/reference/react/Suspense)
- *
- * @example
- * import { Await, useLoaderData } from "react-router";
- *
- * export async function loader() {
- *   // not awaited
- *   const reviews = getReviews();
- *   // awaited (blocks the transition)
- *   const book = await fetch("/api/book").then((res) => res.json());
- *   return { book, reviews };
- * }
- *
- * function Book() {
- *   const { book, reviews } = useLoaderData();
- *   return (
- *     <div>
- *       <h1>{book.title}</h1>
- *       <p>{book.description}</p>
- *       <React.Suspense fallback={<ReviewsSkeleton />}>
- *         <Await
- *           resolve={reviews}
- *           errorElement={
- *             <div>Could not load reviews 😬</div>
- *           }
- *           children={(resolvedReviews) => (
- *             <Reviews items={resolvedReviews} />
- *           )}
- *         />
- *       </React.Suspense>
- *     </div>
- *   );
- * }
- *
- * @public
- * @category Components
- * @mode framework
- * @mode data
- * @param props Props
- * @param {AwaitProps.children} props.children n/a
- * @param {AwaitProps.errorElement} props.errorElement n/a
- * @param {AwaitProps.resolve} props.resolve n/a
- * @returns React element for the rendered awaited value
+ * Data that can be passed into hydrate a Router from SSR
  */
-declare function Await<Resolve>({ children, errorElement, resolve, }: AwaitProps<Resolve>): React.JSX.Element;
+type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
 /**
- * Creates a route config from a React "children" object, which is usually
- * either a `<Route>` element or an array of them. Used internally by
- * `<Routes>` to create a route config from its children.
- *
- * @category Utils
- * @mode data
- * @param children The React children to convert into a route config
- * @param parentPath The path of the parent route, used to generate unique IDs.
- * @returns An array of {@link RouteObject}s that can be used with a {@link DataRouter}
+ * Future flags to toggle new feature behavior
  */
-declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[];
+interface FutureConfig {
+}
 /**
- * Create route objects from JSX elements instead of arrays of objects.
- *
- * @example
- * const routes = createRoutesFromElements(
- *   <>
- *     <Route index loader={step1Loader} Component={StepOne} />
- *     <Route path="step-2" loader={step2Loader} Component={StepTwo} />
- *     <Route path="step-3" loader={step3Loader} Component={StepThree} />
- *   </>
- * );
- *
- * const router = createBrowserRouter(routes);
- *
- * function App() {
- *   return <RouterProvider router={router} />;
- * }
- *
- * @name createRoutesFromElements
- * @public
- * @category Utils
- * @mode data
- * @param children The React children to convert into a route config
- * @param parentPath The path of the parent route, used to generate unique IDs.
- * This is used for internal recursion and is not intended to be used by the
- * application developer.
- * @returns An array of {@link RouteObject}s that can be used with a {@link DataRouter}
+ * Initialization options for createRouter
  */
-declare const createRoutesFromElements: typeof createRoutesFromChildren;
+interface RouterInit {
+    routes: AgnosticRouteObject[];
+    history: History;
+    basename?: string;
+    getContext?: () => MaybePromise<RouterContextProvider>;
+    unstable_instrumentations?: unstable_ClientInstrumentation[];
+    mapRouteProperties?: MapRoutePropertiesFunction;
+    future?: Partial<FutureConfig>;
+    hydrationRouteProperties?: string[];
+    hydrationData?: HydrationState;
+    window?: Window;
+    dataStrategy?: DataStrategyFunction;
+    patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;
+}
 /**
- * Renders the result of {@link matchRoutes} into a React element.
- *
- * @public
- * @category Utils
- * @param matches The array of {@link RouteMatch | route matches} to render
- * @returns A React element that renders the matched routes or `null` if no matches
+ * State returned from a server-side query() call
  */
-declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
-declare function useRouteComponentProps(): {
-    params: Readonly<Params<string>>;
-    loaderData: any;
-    actionData: any;
-    matches: UIMatch<unknown, unknown>[];
-};
-type RouteComponentProps = ReturnType<typeof useRouteComponentProps>;
-type RouteComponentType = React.ComponentType<RouteComponentProps>;
-declare function WithComponentProps({ children, }: {
-    children: React.ReactElement;
-}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
-declare function withComponentProps(Component: RouteComponentType): () => React.ReactElement<{
-    params: Readonly<Params<string>>;
-    loaderData: any;
-    actionData: any;
-    matches: UIMatch<unknown, unknown>[];
-}, string | React.JSXElementConstructor<any>>;
-declare function useHydrateFallbackProps(): {
-    params: Readonly<Params<string>>;
-    loaderData: any;
-    actionData: any;
-};
-type HydrateFallbackProps = ReturnType<typeof useHydrateFallbackProps>;
-type HydrateFallbackType = React.ComponentType<HydrateFallbackProps>;
-declare function WithHydrateFallbackProps({ children, }: {
-    children: React.ReactElement;
-}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
-declare function withHydrateFallbackProps(HydrateFallback: HydrateFallbackType): () => React.ReactElement<{
-    params: Readonly<Params<string>>;
-    loaderData: any;
-    actionData: any;
-}, string | React.JSXElementConstructor<any>>;
-declare function useErrorBoundaryProps(): {
-    params: Readonly<Params<string>>;
-    loaderData: any;
-    actionData: any;
-    error: unknown;
-};
-type ErrorBoundaryProps = ReturnType<typeof useErrorBoundaryProps>;
-type ErrorBoundaryType = React.ComponentType<ErrorBoundaryProps>;
-declare function WithErrorBoundaryProps({ children, }: {
-    children: React.ReactElement;
-}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
-declare function withErrorBoundaryProps(ErrorBoundary: ErrorBoundaryType): () => React.ReactElement<{
-    params: Readonly<Params<string>>;
-    loaderData: any;
-    actionData: any;
-    error: unknown;
-}, string | React.JSXElementConstructor<any>>;
-
-interface IndexRouteObject {
-    caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
-    path?: AgnosticIndexRouteObject["path"];
-    id?: AgnosticIndexRouteObject["id"];
-    middleware?: AgnosticIndexRouteObject["middleware"];
-    loader?: AgnosticIndexRouteObject["loader"];
-    action?: AgnosticIndexRouteObject["action"];
-    hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
-    shouldRevalidate?: AgnosticIndexRouteObject["shouldRevalidate"];
-    handle?: AgnosticIndexRouteObject["handle"];
-    index: true;
-    children?: undefined;
-    element?: React.ReactNode | null;
-    hydrateFallbackElement?: React.ReactNode | null;
-    errorElement?: React.ReactNode | null;
-    Component?: React.ComponentType | null;
-    HydrateFallback?: React.ComponentType | null;
-    ErrorBoundary?: React.ComponentType | null;
-    lazy?: LazyRouteDefinition<RouteObject>;
-}
-interface NonIndexRouteObject {
-    caseSensitive?: AgnosticNonIndexRouteObject["caseSensitive"];
-    path?: AgnosticNonIndexRouteObject["path"];
-    id?: AgnosticNonIndexRouteObject["id"];
-    middleware?: AgnosticNonIndexRouteObject["middleware"];
-    loader?: AgnosticNonIndexRouteObject["loader"];
-    action?: AgnosticNonIndexRouteObject["action"];
-    hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];
-    shouldRevalidate?: AgnosticNonIndexRouteObject["shouldRevalidate"];
-    handle?: AgnosticNonIndexRouteObject["handle"];
-    index?: false;
-    children?: RouteObject[];
-    element?: React.ReactNode | null;
-    hydrateFallbackElement?: React.ReactNode | null;
-    errorElement?: React.ReactNode | null;
-    Component?: React.ComponentType | null;
-    HydrateFallback?: React.ComponentType | null;
-    ErrorBoundary?: React.ComponentType | null;
-    lazy?: LazyRouteDefinition<RouteObject>;
-}
-type RouteObject = IndexRouteObject | NonIndexRouteObject;
-type DataRouteObject = RouteObject & {
-    children?: DataRouteObject[];
-    id: string;
-};
-interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {
-}
-interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
+interface StaticHandlerContext {
+    basename: Router["basename"];
+    location: RouterState["location"];
+    matches: RouterState["matches"];
+    loaderData: RouterState["loaderData"];
+    actionData: RouterState["actionData"];
+    errors: RouterState["errors"];
+    statusCode: number;
+    loaderHeaders: Record<string, Headers>;
+    actionHeaders: Record<string, Headers>;
+    _deepestRenderedBoundaryId?: string | null;
 }
-type PatchRoutesOnNavigationFunctionArgs = AgnosticPatchRoutesOnNavigationFunctionArgs<RouteObject, RouteMatch>;
-type PatchRoutesOnNavigationFunction = AgnosticPatchRoutesOnNavigationFunction<RouteObject, RouteMatch>;
-interface DataRouterContextObject extends Omit<NavigationContextObject, "future"> {
-    router: Router$1;
-    staticContext?: StaticHandlerContext;
-    unstable_onError?: unstable_ClientOnErrorFunction;
+/**
+ * A StaticHandler instance manages a singular SSR navigation/fetch event
+ */
+interface StaticHandler {
+    dataRoutes: AgnosticDataRouteObject[];
+    query(request: Request, opts?: {
+        requestContext?: unknown;
+        filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
+        skipLoaderErrorBubbling?: boolean;
+        skipRevalidation?: boolean;
+        dataStrategy?: DataStrategyFunction<unknown>;
+        generateMiddlewareResponse?: (query: (r: Request, args?: {
+            filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
+        }) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
+    }): Promise<StaticHandlerContext | Response>;
+    queryRoute(request: Request, opts?: {
+        routeId?: string;
+        requestContext?: unknown;
+        dataStrategy?: DataStrategyFunction<unknown>;
+        generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>;
+    }): Promise<any>;
 }
-declare const DataRouterContext: React.Context<DataRouterContextObject | null>;
-declare const DataRouterStateContext: React.Context<RouterState | null>;
-type ViewTransitionContextObject = {
-    isTransitioning: false;
-} | {
-    isTransitioning: true;
-    flushSync: boolean;
+type ViewTransitionOpts = {
     currentLocation: Location;
     nextLocation: Location;
 };
-declare const ViewTransitionContext: React.Context<ViewTransitionContextObject>;
-type FetchersContextObject = Map<string, any>;
-declare const FetchersContext: React.Context<FetchersContextObject>;
-declare const AwaitContext: React.Context<TrackedPromise | null>;
-declare const AwaitContextProvider: (props: React.ComponentProps<typeof AwaitContext.Provider>) => React.FunctionComponentElement<React.ProviderProps<TrackedPromise | null>>;
-interface NavigateOptions {
-    /** Replace the current entry in the history stack instead of pushing a new one */
-    replace?: boolean;
-    /** Adds persistent client side routing state to the next location */
-    state?: any;
-    /** If you are using {@link https://api.reactrouter.com/v7/functions/react_router.ScrollRestoration.html <ScrollRestoration>}, prevent the scroll position from being reset to the top of the window when navigating */
+/**
+ * Subscriber function signature for changes to router state
+ */
+interface RouterSubscriber {
+    (state: RouterState, opts: {
+        deletedFetchers: string[];
+        viewTransitionOpts?: ViewTransitionOpts;
+        flushSync: boolean;
+    }): void;
+}
+/**
+ * Function signature for determining the key to be used in scroll restoration
+ * for a given location
+ */
+interface GetScrollRestorationKeyFunction {
+    (location: Location, matches: UIMatch[]): string | null;
+}
+/**
+ * Function signature for determining the current scroll position
+ */
+interface GetScrollPositionFunction {
+    (): number;
+}
+/**
+ * - "route": relative to the route hierarchy so `..` means remove all segments
+ * of the current route even if it has many. For example, a `route("posts/:id")`
+ * would have both `:id` and `posts` removed from the url.
+ * - "path": relative to the pathname so `..` means remove one segment of the
+ * pathname. For example, a `route("posts/:id")` would have only `:id` removed
+ * from the url.
+ */
+type RelativeRoutingType = "route" | "path";
+type BaseNavigateOrFetchOptions = {
     preventScrollReset?: boolean;
-    /** Defines the relative path behavior for the link. "route" will use the route hierarchy so ".." will remove all URL segments of the current route pattern while "path" will use the URL path so ".." will remove one URL segment. */
     relative?: RelativeRoutingType;
-    /** Wraps the initial state update for this navigation in a {@link https://react.dev/reference/react-dom/flushSync ReactDOM.flushSync} call instead of the default {@link https://react.dev/reference/react/startTransition React.startTransition} */
     flushSync?: boolean;
-    /** Enables a {@link https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API View Transition} for this navigation by wrapping the final state update in `document.startViewTransition()`. If you need to apply specific styles for this view transition, you will also need to leverage the {@link https://api.reactrouter.com/v7/functions/react_router.useViewTransitionState.html useViewTransitionState()} hook.  */
+};
+type BaseNavigateOptions = BaseNavigateOrFetchOptions & {
+    replace?: boolean;
+    state?: any;
+    fromRouteId?: string;
     viewTransition?: boolean;
-}
+};
+type BaseSubmissionOptions = {
+    formMethod?: HTMLFormMethod;
+    formEncType?: FormEncType;
+} & ({
+    formData: FormData;
+    body?: undefined;
+} | {
+    formData?: undefined;
+    body: any;
+});
 /**
- * A Navigator is a "location changer"; it's how you get to different locations.
- *
- * Every history instance conforms to the Navigator interface, but the
- * distinction is useful primarily when it comes to the low-level `<Router>` API
- * where both the location and a navigator must be provided separately in order
- * to avoid "tearing" that may occur in a suspense-enabled app if the action
- * and/or location were to be read directly from the history instance.
+ * Options for a navigate() call for a normal (non-submission) navigation
  */
-interface Navigator {
-    createHref: History["createHref"];
-    encodeLocation?: History["encodeLocation"];
-    go: History["go"];
-    push(to: To, state?: any, opts?: NavigateOptions): void;
-    replace(to: To, state?: any, opts?: NavigateOptions): void;
+type LinkNavigateOptions = BaseNavigateOptions;
+/**
+ * Options for a navigate() call for a submission navigation
+ */
+type SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;
+/**
+ * Options to pass to navigate() for a navigation
+ */
+type RouterNavigateOptions = LinkNavigateOptions | SubmissionNavigateOptions;
+/**
+ * Options for a fetch() load
+ */
+type LoadFetchOptions = BaseNavigateOrFetchOptions;
+/**
+ * Options for a fetch() submission
+ */
+type SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;
+/**
+ * Options to pass to fetch()
+ */
+type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;
+/**
+ * Potential states for state.navigation
+ */
+type NavigationStates = {
+    Idle: {
+        state: "idle";
+        location: undefined;
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        formData: undefined;
+        json: undefined;
+        text: undefined;
+    };
+    Loading: {
+        state: "loading";
+        location: Location;
+        formMethod: Submission["formMethod"] | undefined;
+        formAction: Submission["formAction"] | undefined;
+        formEncType: Submission["formEncType"] | undefined;
+        formData: Submission["formData"] | undefined;
+        json: Submission["json"] | undefined;
+        text: Submission["text"] | undefined;
+    };
+    Submitting: {
+        state: "submitting";
+        location: Location;
+        formMethod: Submission["formMethod"];
+        formAction: Submission["formAction"];
+        formEncType: Submission["formEncType"];
+        formData: Submission["formData"];
+        json: Submission["json"];
+        text: Submission["text"];
+    };
+};
+type Navigation = NavigationStates[keyof NavigationStates];
+type RevalidationState = "idle" | "loading";
+/**
+ * Potential states for fetchers
+ */
+type FetcherStates<TData = any> = {
+    /**
+     * The fetcher is not calling a loader or action
+     *
+     * ```tsx
+     * fetcher.state === "idle"
+     * ```
+     */
+    Idle: {
+        state: "idle";
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        text: undefined;
+        formData: undefined;
+        json: undefined;
+        /**
+         * If the fetcher has never been called, this will be undefined.
+         */
+        data: TData | undefined;
+    };
+    /**
+     * The fetcher is loading data from a {@link LoaderFunction | loader} from a
+     * call to {@link FetcherWithComponents.load | `fetcher.load`}.
+     *
+     * ```tsx
+     * // somewhere
+     * <button onClick={() => fetcher.load("/some/route") }>Load</button>
+     *
+     * // the state will update
+     * fetcher.state === "loading"
+     * ```
+     */
+    Loading: {
+        state: "loading";
+        formMethod: Submission["formMethod"] | undefined;
+        formAction: Submission["formAction"] | undefined;
+        formEncType: Submission["formEncType"] | undefined;
+        text: Submission["text"] | undefined;
+        formData: Submission["formData"] | undefined;
+        json: Submission["json"] | undefined;
+        data: TData | undefined;
+    };
+    /**
+      The fetcher is submitting to a {@link LoaderFunction} (GET) or {@link ActionFunction} (POST) from a {@link FetcherWithComponents.Form | `fetcher.Form`} or {@link FetcherWithComponents.submit | `fetcher.submit`}.
+  
+      ```tsx
+      // somewhere
+      <input
+        onChange={e => {
+          fetcher.submit(event.currentTarget.form, { method: "post" });
+        }}
+      />
+  
+      // the state will update
+      fetcher.state === "submitting"
+  
+      // and formData will be available
+      fetcher.formData
+      ```
+     */
+    Submitting: {
+        state: "submitting";
+        formMethod: Submission["formMethod"];
+        formAction: Submission["formAction"];
+        formEncType: Submission["formEncType"];
+        text: Submission["text"];
+        formData: Submission["formData"];
+        json: Submission["json"];
+        data: TData | undefined;
+    };
+};
+type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
+interface BlockerBlocked {
+    state: "blocked";
+    reset: () => void;
+    proceed: () => void;
+    location: Location;
 }
-interface NavigationContextObject {
-    basename: string;
-    navigator: Navigator;
-    static: boolean;
-    future: {};
+interface BlockerUnblocked {
+    state: "unblocked";
+    reset: undefined;
+    proceed: undefined;
+    location: undefined;
 }
-declare const NavigationContext: React.Context<NavigationContextObject>;
-interface LocationContextObject {
+interface BlockerProceeding {
+    state: "proceeding";
+    reset: undefined;
+    proceed: undefined;
     location: Location;
-    navigationType: Action;
 }
-declare const LocationContext: React.Context<LocationContextObject>;
-interface RouteContextObject {
-    outlet: React.ReactElement | null;
-    matches: RouteMatch[];
-    isDataRoute: boolean;
+type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
+type BlockerFunction = (args: {
+    currentLocation: Location;
+    nextLocation: Location;
+    historyAction: Action;
+}) => boolean;
+declare const IDLE_NAVIGATION: NavigationStates["Idle"];
+declare const IDLE_FETCHER: FetcherStates["Idle"];
+declare const IDLE_BLOCKER: BlockerUnblocked;
+/**
+ * Create a router and listen to history POP navigations
+ */
+declare function createRouter(init: RouterInit): Router;
+interface CreateStaticHandlerOptions {
+    basename?: string;
+    mapRouteProperties?: MapRoutePropertiesFunction;
+    unstable_instrumentations?: Pick<unstable_ServerInstrumentation, "route">[];
+    future?: {};
 }
-declare const RouteContext: React.Context<RouteContextObject>;
 
-export { type DataStrategyMatch as $, type ActionFunctionArgs as A, type BlockerFunction as B, type PatchRoutesOnNavigationFunction as C, type DataStrategyResult as D, type ErrorBoundaryType as E, type DataRouteObject as F, type StaticHandler as G, type HydrationState as H, type InitialEntry as I, type GetScrollPositionFunction as J, type GetScrollRestorationKeyFunction as K, type Location as L, type MiddlewareNextFunction as M, type NavigateOptions as N, type StaticHandlerContext as O, type Params as P, type Fetcher as Q, type RouterProviderProps as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type NavigationStates as V, type RouterSubscriber as W, type RouterNavigateOptions as X, type RouterFetchOptions as Y, type RevalidationState as Z, type DataStrategyFunctionArgs as _, type RouterInit as a, hydrationRouteProperties as a$, type ErrorResponse as a0, type FormEncType as a1, type FormMethod as a2, type HTMLFormMethod as a3, type LazyRouteFunction as a4, type PathParam as a5, type RedirectFunction as a6, type RouterContext as a7, type ShouldRevalidateFunctionArgs as a8, createContext as a9, type RouteProps as aA, type RouterProps as aB, type RoutesProps as aC, Await as aD, MemoryRouter as aE, Navigate as aF, Outlet as aG, Route as aH, Router as aI, RouterProvider as aJ, Routes as aK, createMemoryRouter as aL, createRoutesFromChildren as aM, createRoutesFromElements as aN, renderMatches as aO, type Future as aP, createBrowserHistory as aQ, invariant as aR, createRouter as aS, ErrorResponseImpl as aT, DataRouterContext as aU, DataRouterStateContext as aV, FetchersContext as aW, LocationContext as aX, NavigationContext as aY, RouteContext as aZ, ViewTransitionContext as a_, createPath as aa, parsePath as ab, IDLE_NAVIGATION as ac, IDLE_FETCHER as ad, IDLE_BLOCKER as ae, data as af, generatePath as ag, isRouteErrorResponse as ah, matchPath as ai, matchRoutes as aj, redirect as ak, redirectDocument as al, replace as am, resolvePath as an, type Navigator as ao, type PatchRoutesOnNavigationFunctionArgs as ap, type RouteMatch as aq, AwaitContextProvider as ar, type AwaitProps as as, type IndexRouteProps as at, type LayoutRouteProps as au, type MemoryRouterOpts as av, type MemoryRouterProps as aw, type NavigateProps as ax, type OutletProps as ay, type PathRouteProps as az, type LoaderFunctionArgs as b, mapRouteProperties as b0, WithComponentProps as b1, withComponentProps as b2, WithHydrateFallbackProps as b3, withHydrateFallbackProps as b4, WithErrorBoundaryProps as b5, withErrorBoundaryProps as b6, type RouteManifest as b7, type History as b8, type FutureConfig as b9, type CreateStaticHandlerOptions as ba, type ActionFunction as c, type LoaderFunction as d, type DataRouteMatch as e, type MiddlewareFunction as f, RouterContextProvider as g, DataWithResponseInit as h, type MiddlewareEnabled as i, type Router$1 as j, type DataStrategyFunction as k, type Blocker as l, type RelativeRoutingType as m, type ParamParseKey as n, type Path as o, type PathPattern as p, type PathMatch as q, type Navigation as r, Action as s, type RouteObject as t, type unstable_ClientOnErrorFunction as u, type IndexRouteObject as v, type RouteComponentType as w, type HydrateFallbackType as x, type NonIndexRouteObject as y, type RouterState as z };
+export { type NonIndexRouteObject as $, type ActionFunction as A, type BlockerFunction as B, type ClientActionFunction as C, type DataStrategyResult as D, type Path as E, type Func as F, type GetLoaderData as G, type HeadersFunction as H, type PathPattern as I, type PathMatch as J, type Navigation as K, type Location as L, type MetaFunction as M, type Normalize as N, Action as O, type Params as P, type RouteObject as Q, type RouteModule$1 as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type InitialEntry as V, type HydrationState as W, type IndexRouteObject as X, type RouteComponentType as Y, type HydrateFallbackType as Z, type ErrorBoundaryType as _, type ClientLoaderFunction as a, type RouterProps as a$, type Equal as a0, type RouterState as a1, type PatchRoutesOnNavigationFunction as a2, type DataRouteObject as a3, type StaticHandler as a4, type GetScrollPositionFunction as a5, type GetScrollRestorationKeyFunction as a6, type StaticHandlerContext as a7, type Fetcher as a8, type NavigationStates as a9, type unstable_InstrumentationHandlerResult as aA, IDLE_NAVIGATION as aB, IDLE_FETCHER as aC, IDLE_BLOCKER as aD, data as aE, generatePath as aF, isRouteErrorResponse as aG, matchPath as aH, matchRoutes as aI, redirect as aJ, redirectDocument as aK, replace as aL, resolvePath as aM, type DataRouteMatch as aN, type Navigator as aO, type PatchRoutesOnNavigationFunctionArgs as aP, type RouteMatch as aQ, AwaitContextProvider as aR, type AwaitProps as aS, type IndexRouteProps as aT, type LayoutRouteProps as aU, type MemoryRouterOpts as aV, type MemoryRouterProps as aW, type NavigateProps as aX, type OutletProps as aY, type PathRouteProps as aZ, type RouteProps as a_, type RouterSubscriber as aa, type RouterNavigateOptions as ab, type RouterFetchOptions as ac, type RevalidationState as ad, type ActionFunctionArgs as ae, type DataStrategyFunctionArgs as af, type DataStrategyMatch as ag, DataWithResponseInit as ah, type ErrorResponse as ai, type FormEncType as aj, type FormMethod as ak, type HTMLFormMethod as al, type LazyRouteFunction as am, type LoaderFunctionArgs as an, type MiddlewareFunction as ao, type PathParam as ap, type RedirectFunction as aq, type RouterContext as ar, type ShouldRevalidateFunctionArgs as as, createContext as at, createPath as au, parsePath as av, type unstable_ServerInstrumentation as aw, type unstable_InstrumentRequestHandlerFunction as ax, type unstable_InstrumentRouterFunction as ay, type unstable_InstrumentRouteFunction as az, type LinksFunction as b, type RoutesProps as b0, Await as b1, MemoryRouter as b2, Navigate as b3, Outlet as b4, Route as b5, Router$1 as b6, RouterProvider as b7, Routes as b8, createMemoryRouter as b9, WithHydrateFallbackProps as bA, withHydrateFallbackProps as bB, WithErrorBoundaryProps as bC, withErrorBoundaryProps as bD, type RouteManifest as bE, type ServerRouteModule as bF, type History as bG, type FutureConfig as bH, type CreateStaticHandlerOptions as bI, createRoutesFromChildren as ba, createRoutesFromElements as bb, renderMatches as bc, type ClientActionFunctionArgs as bd, type ClientLoaderFunctionArgs as be, type HeadersArgs as bf, type MetaArgs as bg, type PageLinkDescriptor as bh, type HtmlLinkDescriptor as bi, type Future as bj, type unstable_SerializesTo as bk, createBrowserHistory as bl, invariant as bm, createRouter as bn, ErrorResponseImpl as bo, DataRouterContext as bp, DataRouterStateContext as bq, FetchersContext as br, LocationContext as bs, NavigationContext as bt, RouteContext as bu, ViewTransitionContext as bv, hydrationRouteProperties as bw, mapRouteProperties as bx, WithComponentProps as by, withComponentProps as bz, RouterContextProvider as c, type LoaderFunction as d, type RouterInit as e, type RouterProviderProps as f, type unstable_ClientOnErrorFunction as g, type LinkDescriptor as h, type Pretty as i, type MetaDescriptor as j, type ServerDataFunctionArgs as k, type MiddlewareNextFunction as l, type ClientDataFunctionArgs as m, type ServerDataFrom as n, type GetActionData as o, type Router as p, type RouteModules as q, type DataStrategyFunction as r, type MiddlewareEnabled as s, type AppLoadContext as t, type unstable_ClientInstrumentation as u, type NavigateOptions as v, type Blocker as w, type SerializeFrom as x, type RelativeRoutingType as y, type ParamParseKey as z };