react-router 7.6.0 → 7.6.1-pre.0

package/dist/development/index.d.mts

@@ -1,394 +1,3864 @@
-import { a as Router, b as RouteModules, D as DataStrategyFunction, T as To, c as RelativeRoutingType, L as Location, A as Action, P as ParamParseKey, d as Path, e as PathPattern, f as PathMatch, N as NavigateOptions, g as Params$1, h as RouteObject, i as Navigation, U as UIMatch, S as SerializeFrom, B as BlockerFunction, j as Blocker, k as StaticHandlerContext, l as StaticHandler, F as FutureConfig, C as CreateStaticHandlerOptions$1, I as InitialEntry, H as HydrationState, u as unstable_InitialContext, m as IndexRouteObject, n as NonIndexRouteObject, o as LoaderFunction, p as ActionFunction, M as MetaFunction, q as LinksFunction, r as MiddlewareEnabled, s as AppLoadContext, E as Equal, t as RouterState, v as PatchRoutesOnNavigationFunction, w as DataRouteObject, x as ClientLoaderFunction } from './route-data-C6QaL0wu.mjs';
-export { W as ActionFunctionArgs, av as ClientActionFunction, aw as ClientActionFunctionArgs, ax as ClientLoaderFunctionArgs, ar as DataRouteMatch, X as DataStrategyFunctionArgs, Y as DataStrategyMatch, Z as DataStrategyResult, $ as ErrorResponse, z as Fetcher, a0 as FormEncType, a1 as FormMethod, aF as Future, G as GetScrollPositionFunction, y as GetScrollRestorationKeyFunction, a2 as HTMLFormMethod, ay as HeadersArgs, az as HeadersFunction, aD as HtmlLinkDescriptor, ah as IDLE_BLOCKER, ag as IDLE_FETCHER, af as IDLE_NAVIGATION, a3 as LazyRouteFunction, aE as LinkDescriptor, a4 as LoaderFunctionArgs, aA as MetaArgs, aB as MetaDescriptor, J as NavigationStates, as as Navigator, aC as PageLinkDescriptor, at as PatchRoutesOnNavigationFunctionArgs, a6 as PathParam, a7 as RedirectFunction, V as RevalidationState, au as RouteMatch, Q as RouterFetchOptions, R as RouterInit, O as RouterNavigateOptions, K as RouterSubscriber, a9 as ShouldRevalidateFunction, aa as ShouldRevalidateFunctionArgs, aL as UNSAFE_DataRouterContext, aM as UNSAFE_DataRouterStateContext, _ as UNSAFE_DataWithResponseInit, aK as UNSAFE_ErrorResponseImpl, aN as UNSAFE_FetchersContext, aO as UNSAFE_LocationContext, aP as UNSAFE_NavigationContext, aQ as UNSAFE_RouteContext, aR as UNSAFE_ViewTransitionContext, aH as UNSAFE_createBrowserHistory, aJ as UNSAFE_createRouter, aI as UNSAFE_invariant, ad as createPath, ai as data, aj as generatePath, ak as isRouteErrorResponse, al as matchPath, am as matchRoutes, ae as parsePath, an as redirect, ao as redirectDocument, ap as replace, aq as resolvePath, a5 as unstable_MiddlewareFunction, a8 as unstable_RouterContext, ac as unstable_RouterContextProvider, aG as unstable_SerializesTo, ab as unstable_createContext } from './route-data-C6QaL0wu.mjs';
-import { A as AssetsManifest, E as EntryContext, F as FutureConfig$1, S as ServerBuild } from './lib-CCSAGgcP.mjs';
-export { f as Await, a as AwaitProps, Q as BrowserRouter, B as BrowserRouterProps, D as DOMRouterOpts, v as FetcherFormProps, C as FetcherSubmitFunction, a6 as FetcherSubmitOptions, G as FetcherWithComponents, X as Form, w as FormProps, ah as HandleDataRequestFunction, ai as HandleDocumentRequestFunction, aj as HandleErrorFunction, T as HashRouter, H as HashRouterProps, q as HistoryRouterProps, I as IndexRouteProps, L as LayoutRouteProps, U as Link, s as LinkProps, ad as Links, g as MemoryRouter, M as MemoryRouterOpts, b as MemoryRouterProps, ac as Meta, W as NavLink, t as NavLinkProps, u as NavLinkRenderProps, h as Navigate, N as NavigateProps, i as Outlet, O as OutletProps, a7 as ParamKeyValuePair, P as PathRouteProps, af as PrefetchPageLinks, j as Route, c as RouteProps, k as Router, d as RouterProps, l as RouterProvider, R as RouterProviderProps, m as Routes, e as RoutesProps, ae as Scripts, ag as ScriptsProps, Y as ScrollRestoration, x as ScrollRestorationProps, ak as ServerEntryModule, y as SetURLSearchParams, z as SubmitFunction, a8 as SubmitOptions, aa as SubmitTarget, an as UNSAFE_FrameworkContext, ao as UNSAFE_createClientRoutes, ap as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, al as UNSAFE_hydrationRouteProperties, am as UNSAFE_mapRouteProperties, aq as UNSAFE_shouldHydrateRouteLoader, ar as UNSAFE_useScrollRestoration, a9 as URLSearchParamsInit, J as createBrowserRouter, K as createHashRouter, n as createMemoryRouter, o as createRoutesFromChildren, p as createRoutesFromElements, ab as createSearchParams, r as renderMatches, V as unstable_HistoryRouter, a4 as unstable_usePrompt, a3 as useBeforeUnload, a1 as useFetcher, a2 as useFetchers, a0 as useFormAction, Z as useLinkClickHandler, _ as useSearchParams, $ as useSubmit, a5 as useViewTransitionState } from './lib-CCSAGgcP.mjs';
 import * as React from 'react';
-import { ReactElement } from 'react';
+import { ComponentType, ReactElement } from 'react';
 import { ParseOptions, SerializeOptions } from 'cookie';
 export { ParseOptions as CookieParseOptions, SerializeOptions as CookieSerializeOptions } from 'cookie';
 
+/**
+ * Actions represent the type of change to a location value.
+ */
+declare enum Action {
+    /**
+     * A POP indicates a change to an arbitrary index in the history stack, such
+     * as a back or forward navigation. It does not describe the direction of the
+     * navigation, only that the current index changed.
+     *
+     * Note: This is the default action for newly created history objects.
+     */
+    Pop = "POP",
+    /**
+     * A PUSH indicates a new entry being added to the history stack, such as when
+     * a link is clicked and a new page loads. When this happens, all subsequent
+     * entries in the stack are lost.
+     */
+    Push = "PUSH",
+    /**
+     * A REPLACE indicates the entry at the current index in the history stack
+     * being replaced by a new one.
+     */
+    Replace = "REPLACE"
+}
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+interface Path {
+    /**
+     * A URL pathname, beginning with a /.
+     */
+    pathname: string;
+    /**
+     * A URL search string, beginning with a ?.
+     */
+    search: string;
+    /**
+     * A URL fragment identifier, beginning with a #.
+     */
+    hash: string;
+}
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+interface Location<State = any> extends Path {
+    /**
+     * A value of arbitrary data associated with this location.
+     */
+    state: State;
+    /**
+     * A unique string associated with this location. May be used to safely store
+     * and retrieve data in some other storage API, like `localStorage`.
+     *
+     * Note: This value is always "default" on the initial location.
+     */
+    key: string;
+}
+/**
+ * A change to the current location.
+ */
+interface Update {
+    /**
+     * The action that triggered the change.
+     */
+    action: Action;
+    /**
+     * The new location.
+     */
+    location: Location;
+    /**
+     * The delta between this location and the former location in the history stack
+     */
+    delta: number | null;
+}
+/**
+ * A function that receives notifications about location changes.
+ */
+interface Listener {
+    (update: Update): void;
+}
+/**
+ * Describes a location that is the destination of some navigation used in
+ * {@link Link}, {@link useNavigate}, etc.
+ */
+type To = string | Partial<Path>;
+/**
+ * A history is an interface to the navigation stack. The history serves as the
+ * source of truth for the current location, as well as provides a set of
+ * methods that may be used to change it.
+ *
+ * It is similar to the DOM's `window.history` object, but with a smaller, more
+ * focused API.
+ */
+interface History {
+    /**
+     * The last action that modified the current location. This will always be
+     * Action.Pop when a history instance is first created. This value is mutable.
+     */
+    readonly action: Action;
+    /**
+     * The current location. This value is mutable.
+     */
+    readonly location: Location;
+    /**
+     * Returns a valid href for the given `to` value that may be used as
+     * the value of an <a href> attribute.
+     *
+     * @param to - The destination URL
+     */
+    createHref(to: To): string;
+    /**
+     * Returns a URL for the given `to` value
+     *
+     * @param to - The destination URL
+     */
+    createURL(to: To): URL;
+    /**
+     * Encode a location the same way window.history would do (no-op for memory
+     * history) so we ensure our PUSH/REPLACE navigations for data routers
+     * behave the same as POP
+     *
+     * @param to Unencoded path
+     */
+    encodeLocation(to: To): Path;
+    /**
+     * Pushes a new location onto the history stack, increasing its length by one.
+     * If there were any entries in the stack after the current one, they are
+     * lost.
+     *
+     * @param to - The new URL
+     * @param state - Data to associate with the new location
+     */
+    push(to: To, state?: any): void;
+    /**
+     * Replaces the current location in the history stack with a new one.  The
+     * location that was replaced will no longer be available.
+     *
+     * @param to - The new URL
+     * @param state - Data to associate with the new location
+     */
+    replace(to: To, state?: any): void;
+    /**
+     * Navigates `n` entries backward/forward in the history stack relative to the
+     * current index. For example, a "back" navigation would use go(-1).
+     *
+     * @param delta - The delta in the stack index
+     */
+    go(delta: number): void;
+    /**
+     * Sets up a listener that will be called whenever the current location
+     * changes.
+     *
+     * @param listener - A function that will be called when the location changes
+     * @returns unlisten - A function that may be used to stop listening
+     */
+    listen(listener: Listener): () => void;
+}
+/**
+ * A user-supplied object that describes a location. Used when providing
+ * entries to `createMemoryHistory` via its `initialEntries` option.
+ */
+type InitialEntry = string | Partial<Location>;
+/**
+ * A browser history stores the current location in regular URLs in a web
+ * browser environment. This is the standard for most web apps and provides the
+ * cleanest URLs the browser's address bar.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
+ */
+interface BrowserHistory extends UrlHistory {
+}
+type BrowserHistoryOptions = UrlHistoryOptions;
+/**
+ * Browser history stores the location in regular URLs. This is the standard for
+ * most web apps, but it requires some configuration on the server to ensure you
+ * serve the same app at multiple URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+ */
+declare function createBrowserHistory(options?: BrowserHistoryOptions): BrowserHistory;
+/**
+ * @private
+ */
+declare function invariant(value: boolean, message?: string): asserts value;
+declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ *
+ * @category Utils
+ */
+declare function createPath({ pathname, search, hash, }: Partial<Path>): string;
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ *
+ * @category Utils
+ */
+declare function parsePath(path: string): Partial<Path>;
+interface UrlHistory extends History {
+}
+type UrlHistoryOptions = {
+    window?: Window;
+    v5Compat?: boolean;
+};
+
+/**
+ * An augmentable interface users can modify in their app-code to opt into
+ * future-flag-specific types
+ */
+interface Future {
+}
+type MiddlewareEnabled = Future extends {
+    unstable_middleware: infer T extends boolean;
+} ? T : false;
+
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+interface RouteData {
+    [routeId: string]: any;
+}
+type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
+type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
+/**
+ * Users can specify either lowercase or uppercase form methods on `<Form>`,
+ * useSubmit(), `<fetcher.Form>`, etc.
+ */
+type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
+/**
+ * Active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState. This is to align with the normalization done via fetch().
+ */
+type FormMethod = UpperCaseFormMethod;
+type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
+type JsonObject$1 = {
+    [Key in string]: JsonValue$1;
+} & {
+    [Key in string]?: JsonValue$1 | undefined;
+};
+type JsonArray$1 = JsonValue$1[] | readonly JsonValue$1[];
+type JsonPrimitive$1 = string | number | boolean | null;
+type JsonValue$1 = JsonPrimitive$1 | JsonObject$1 | JsonArray$1;
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+type Submission = {
+    formMethod: FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: FormData;
+    json: undefined;
+    text: undefined;
+} | {
+    formMethod: FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: JsonValue$1;
+    text: undefined;
+} | {
+    formMethod: FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: undefined;
+    text: string;
+};
+interface unstable_RouterContext<T = unknown> {
+    defaultValue?: T;
+}
+/**
+ * Creates a context object that may be used to store and retrieve arbitrary values.
+ *
+ * If a `defaultValue` is provided, it will be returned from `context.get()` when no value has been
+ * set for the context. Otherwise reading this context when no value has been set will throw an
+ * error.
+ *
+ * @param defaultValue The default value for the context
+ * @returns A context object
+ */
+declare function unstable_createContext<T>(defaultValue?: T): unstable_RouterContext<T>;
+/**
+ * A Map of RouterContext objects to their initial values - used to populate a
+ * fresh `context` value per request/navigation/fetch
+ */
+type unstable_InitialContext = Map<unstable_RouterContext, unknown>;
+/**
+ * Provides methods for writing/reading values in application context in a typesafe way.
+ */
+declare class unstable_RouterContextProvider {
+    #private;
+    constructor(init?: unstable_InitialContext);
+    get<T>(context: unstable_RouterContext<T>): T;
+    set<C extends unstable_RouterContext>(context: C, value: C extends unstable_RouterContext<infer T> ? T : never): void;
+}
+type DefaultContext = MiddlewareEnabled extends true ? unstable_RouterContextProvider : any;
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+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;
+    /**
+     * {@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;
+    /**
+     * 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.
+     */
+    context: Context;
+}
+/**
+ * Route middleware `next` function to call downstream handlers and then complete
+ * middlewares from the bottom-up
+ */
+interface unstable_MiddlewareNextFunction<Result = unknown> {
+    (): MaybePromise<Result>;
+}
+/**
+ * Route middleware function signature.  Receives the same "data" arguments as a
+ * `loader`/`action` (`request`, `params`, `context`) as the first parameter and
+ * a `next` function as the second parameter which will call downstream handlers
+ * and then complete middlewares from the bottom-up
+ */
+type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
+/**
+ * Arguments passed to loader functions
+ */
+interface LoaderFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
+}
+/**
+ * Arguments passed to action functions
+ */
+interface ActionFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
+}
+/**
+ * Loaders and actions can return anything
+ */
+type DataFunctionValue = unknown;
+type DataFunctionReturnValue = MaybePromise<DataFunctionValue>;
+/**
+ * Route loader function signature
+ */
+type LoaderFunction<Context = DefaultContext> = {
+    (args: LoaderFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
+} & {
+    hydrate?: boolean;
+};
+/**
+ * Route action function signature
+ */
+interface ActionFunction<Context = DefaultContext> {
+    (args: ActionFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
+}
+/**
+ * Arguments passed to shouldRevalidate function
+ */
+interface ShouldRevalidateFunctionArgs {
+    /** This is the url the navigation started from. You can compare it with `nextUrl` to decide if you need to revalidate this route's data. */
+    currentUrl: URL;
+    /** These are the {@link https://reactrouter.com/start/framework/routing#dynamic-segments dynamic route params} from the URL that can be compared to the `nextParams` to decide if you need to reload or not. Perhaps you're using only a partial piece of the param for data loading, you don't need to revalidate if a superfluous part of the param changed. */
+    currentParams: AgnosticDataRouteMatch["params"];
+    /** In the case of navigation, this the URL the user is requesting. Some revalidations are not navigation, so it will simply be the same as currentUrl. */
+    nextUrl: URL;
+    /** In the case of navigation, these are the {@link https://reactrouter.com/start/framework/routing#dynamic-segments dynamic route params}  from the next location the user is requesting. Some revalidations are not navigation, so it will simply be the same as currentParams. */
+    nextParams: AgnosticDataRouteMatch["params"];
+    /** The method (probably `"GET"` or `"POST"`) used in the form submission that triggered the revalidation. */
+    formMethod?: Submission["formMethod"];
+    /** The form action (`<Form action="/somewhere">`) that triggered the revalidation. */
+    formAction?: Submission["formAction"];
+    /** The form encType (`<Form encType="application/x-www-form-urlencoded">) used in the form submission that triggered the revalidation*/
+    formEncType?: Submission["formEncType"];
+    /** The form submission data when the form's encType is `text/plain` */
+    text?: Submission["text"];
+    /** The form submission data when the form's encType is `application/x-www-form-urlencoded` or `multipart/form-data` */
+    formData?: Submission["formData"];
+    /** The form submission data when the form's encType is `application/json` */
+    json?: Submission["json"];
+    /** The status code of the action response */
+    actionStatus?: number;
+    /**
+     * When a submission causes the revalidation this will be the result of the action—either action data or an error if the action failed. It's common to include some information in the action result to instruct shouldRevalidate to revalidate or not.
+     *
+     * @example
+     * export async function action() {
+     *   await saveSomeStuff();
+     *   return { ok: true };
+     * }
+     *
+     * export function shouldRevalidate({
+     *   actionResult,
+     * }) {
+     *   if (actionResult?.ok) {
+     *     return false;
+     *   }
+     *   return true;
+     * }
+     */
+    actionResult?: any;
+    /**
+     * By default, React Router doesn't call every loader all the time. There are reliable optimizations it can make by default. For example, only loaders with changing params are called. Consider navigating from the following URL to the one below it:
+     *
+     * /projects/123/tasks/abc
+     * /projects/123/tasks/def
+     * React Router will only call the loader for tasks/def because the param for projects/123 didn't change.
+     *
+     * It's safest to always return defaultShouldRevalidate after you've done your specific optimizations that return false, otherwise your UI might get out of sync with your data on the server.
+     */
+    defaultShouldRevalidate: boolean;
+}
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+interface ShouldRevalidateFunction {
+    (args: ShouldRevalidateFunctionArgs): boolean;
+}
+interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+    /**
+     * @private
+     */
+    _lazyPromises?: {
+        middleware: Promise<void> | undefined;
+        handler: Promise<void> | undefined;
+        route: Promise<void> | undefined;
+    };
+    shouldLoad: boolean;
+    unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
+    unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
+    resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
+}
+interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
+    matches: DataStrategyMatch[];
+    unstable_runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
+    fetcherKey: string | null;
+}
+/**
+ * Result from a loader or action called via dataStrategy
+ */
+interface DataStrategyResult {
+    type: "data" | "error";
+    result: unknown;
+}
+interface DataStrategyFunction<Context = DefaultContext> {
+    (args: DataStrategyFunctionArgs<Context>): Promise<Record<string, DataStrategyResult>>;
+}
+type AgnosticPatchRoutesOnNavigationFunctionArgs<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = {
+    signal: AbortSignal;
+    path: string;
+    matches: M[];
+    fetcherKey: string | undefined;
+    patch: (routeId: string | null, children: O[]) => void;
+};
+type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = (opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>) => MaybePromise<void>;
+/**
+ * Function provided by the framework-aware layers to set any framework-specific
+ * properties from framework-agnostic properties
+ */
+interface MapRoutePropertiesFunction {
+    (route: AgnosticRouteObject): {
+        hasErrorBoundary: boolean;
+    } & Record<string, any>;
+}
+/**
+ * Keys we cannot change from within a lazy object. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+type UnsupportedLazyRouteObjectKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+type UnsupportedLazyRouteFunctionKey = UnsupportedLazyRouteObjectKey | "unstable_middleware";
+/**
+ * lazy object to load route properties, which can add non-matching
+ * related properties to a route
+ */
+type LazyRouteObject<R extends AgnosticRouteObject> = {
+    [K in keyof R as K extends UnsupportedLazyRouteObjectKey ? never : K]?: () => Promise<R[K] | null | undefined>;
+};
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+interface LazyRouteFunction<R extends AgnosticRouteObject> {
+    (): Promise<Omit<R, UnsupportedLazyRouteFunctionKey> & Partial<Record<UnsupportedLazyRouteFunctionKey, never>>>;
+}
+type LazyRouteDefinition<R extends AgnosticRouteObject> = LazyRouteObject<R> | LazyRouteFunction<R>;
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+type AgnosticBaseRouteObject = {
+    caseSensitive?: boolean;
+    path?: string;
+    id?: string;
+    unstable_middleware?: unstable_MiddlewareFunction[];
+    loader?: LoaderFunction | boolean;
+    action?: ActionFunction | boolean;
+    hasErrorBoundary?: boolean;
+    shouldRevalidate?: ShouldRevalidateFunction;
+    handle?: any;
+    lazy?: LazyRouteDefinition<AgnosticBaseRouteObject>;
+};
+/**
+ * Index routes must not have children
+ */
+type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: undefined;
+    index: true;
+};
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: AgnosticRouteObject[];
+    index?: false;
+};
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
+type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
+    id: string;
+};
+type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
+    children?: AgnosticDataRouteObject[];
+    id: string;
+};
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
+type RouteManifest<R = AgnosticDataRouteObject> = Record<string, R | undefined>;
+type Regex_az = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
+type Regez_AZ = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z";
+type Regex_09 = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+type Regex_w = Regex_az | Regez_AZ | Regex_09 | "_";
+type ParamChar = Regex_w | "-";
+type RegexMatchPlus<CharPattern extends string, T extends string> = T extends `${infer First}${infer Rest}` ? First extends CharPattern ? RegexMatchPlus<CharPattern, Rest> extends never ? First : `${First}${RegexMatchPlus<CharPattern, Rest>}` : never : never;
+type _PathParam<Path extends string> = Path extends `${infer L}/${infer R}` ? _PathParam<L> | _PathParam<R> : Path extends `:${infer Param}` ? Param extends `${infer Optional}?${string}` ? RegexMatchPlus<ParamChar, Optional> : RegexMatchPlus<ParamChar, Param> : never;
+type PathParam<Path extends string> = Path extends "*" | "/*" ? "*" : Path extends `${infer Rest}/*` ? "*" | _PathParam<Rest> : _PathParam<Path>;
+type ParamParseKey<Segment extends string> = [
+    PathParam<Segment>
+] extends [never] ? string : PathParam<Segment>;
+/**
+ * The parameters that were parsed from the URL path.
+ */
+type Params<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The route object that was used to match.
+     */
+    route: RouteObjectType;
+}
+interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+}
+/**
+ * Matches the given routes to a location and returns the match data.
+ *
+ * @category Utils
+ */
+declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
+interface UIMatch<Data = unknown, Handle = unknown> {
+    id: string;
+    pathname: string;
+    /**
+     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the matched route.
+     **/
+    params: AgnosticRouteMatch["params"];
+    /** The return value from the matched route's loader or clientLoader */
+    data: Data;
+    /** The {@link https://reactrouter.com/start/framework/route-module#handle handle object} exported from the matched route module */
+    handle: Handle;
+}
+/**
+ * Returns a path with params interpolated.
+ *
+ * @category Utils
+ */
+declare function generatePath<Path extends string>(originalPath: Path, params?: {
+    [key in PathParam<Path>]: string | null;
+}): string;
+/**
+ * A PathPattern is used to match on some portion of a URL pathname.
+ */
+interface PathPattern<Path extends string = string> {
+    /**
+     * A string to match against a URL pathname. May contain `:id`-style segments
+     * to indicate placeholders for dynamic parameters. May also end with `/*` to
+     * indicate matching the rest of the URL pathname.
+     */
+    path: Path;
+    /**
+     * Should be `true` if the static portions of the `path` should be matched in
+     * the same case.
+     */
+    caseSensitive?: boolean;
+    /**
+     * Should be `true` if this pattern should match the entire URL pathname.
+     */
+    end?: boolean;
+}
+/**
+ * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+ */
+interface PathMatch<ParamKey extends string = string> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The pattern that was used to match.
+     */
+    pattern: PathPattern;
+}
+/**
+ * Performs pattern matching on a URL pathname and returns information about
+ * the match.
+ *
+ * @category Utils
+ */
+declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
+/**
+ * Returns a resolved path object relative to the given pathname.
+ *
+ * @category Utils
+ */
+declare function resolvePath(to: To, fromPathname?: string): Path;
+declare class DataWithResponseInit<D> {
+    type: string;
+    data: D;
+    init: ResponseInit | null;
+    constructor(data: D, init?: ResponseInit);
+}
+/**
+ * Create "responses" that contain `status`/`headers` without forcing
+ * serialization into an actual `Response` - used by Remix single fetch
+ *
+ * @category Utils
+ */
+declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
+type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @category Utils
+ */
+declare const redirect: RedirectFunction;
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @category Utils
+ */
+declare const redirectDocument: RedirectFunction;
+/**
+ * A redirect response that will perform a `history.replaceState` instead of a
+ * `history.pushState` for client-side navigation redirects.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @category Utils
+ */
+declare const replace: RedirectFunction;
+type ErrorResponse = {
+    status: number;
+    statusText: string;
+    data: any;
+};
+/**
+ * @private
+ * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
+ *
+ * We don't export the class for public use since it's an implementation
+ * detail, but we export the interface above so folks can build their own
+ * abstractions around instances via isRouteErrorResponse()
+ */
+declare class ErrorResponseImpl implements ErrorResponse {
+    status: number;
+    statusText: string;
+    data: any;
+    private error?;
+    private internal;
+    constructor(status: number, statusText: string | undefined, data: any, internal?: boolean);
+}
+/**
+ * Check if the given error is an ErrorResponse generated from a 4xx/5xx
+ * Response thrown from an action/loader
+ *
+ * @category Utils
+ */
+declare function isRouteErrorResponse(error: any): error is ErrorResponse;
+
+/**
+ * A Router instance manages all navigation and data loading/mutations
+ */
+interface Router$1 {
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the basename for the router
+     */
+    get basename(): RouterInit["basename"];
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the future config for the router
+     */
+    get future(): FutureConfig$1;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the current state of the router
+     */
+    get state(): RouterState;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the routes for this router instance
+     */
+    get routes(): AgnosticDataRouteObject[];
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Return the window associated with the router
+     */
+    get window(): RouterInit["window"];
+    /**
+     * @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
+     */
+    initialize(): Router$1;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Subscribe to router.state updates
+     *
+     * @param fn function to call with the new state
+     */
+    subscribe(fn: RouterSubscriber): () => void;
+    /**
+     * @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
+     */
+    enableScrollRestoration(savedScrollPositions: Record<string, number>, getScrollPosition: GetScrollPositionFunction, getKey?: GetScrollRestorationKeyFunction): () => void;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Navigate forward/backward in the history stack
+     * @param to Delta to move in the history stack
+     */
+    navigate(to: number): Promise<void>;
+    /**
+     * Navigate to the given path
+     * @param to Path to navigate to
+     * @param opts Navigation options (method, submission, etc.)
+     */
+    navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;
+    /**
+     * @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.)
+     */
+    fetch(key: string, routeId: string, href: string | null, opts?: RouterFetchOptions): Promise<void>;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Trigger a revalidation of all current route loaders and fetcher loads
+     */
+    revalidate(): Promise<void>;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Utility function to create an href for the given location
+     * @param location
+     */
+    createHref(location: Location | URL): string;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Utility function to URL encode a destination path according to the internal
+     * history implementation
+     * @param to
+     */
+    encodeLocation(to: To): Path;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Get/create a fetcher for the given key
+     * @param key
+     */
+    getFetcher<TData = any>(key: string): Fetcher<TData>;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Delete the fetcher for a given key
+     * @param key
+     */
+    deleteFetcher(key: string): void;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Cleanup listeners and abort any in-progress loads
+     */
+    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;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Delete a navigation blocker
+     * @param key The identifier for the blocker
+     */
+    deleteBlocker(key: string): void;
+    /**
+     * @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
+     */
+    patchRoutes(routeId: string | null, children: AgnosticRouteObject[]): void;
+    /**
+     * @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)
+     */
+    _internalSetRoutes(routes: AgnosticRouteObject[]): void;
+    /**
+     * @private
+     * PRIVATE - DO NOT USE
+     *
+     * Internal fetch AbortControllers accessed by unit tests
+     */
+    _internalFetchControllers: Map<string, AbortController>;
+}
+/**
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the "old" location unless otherwise noted.
+ */
+interface RouterState {
+    /**
+     * The action of the most recent navigation
+     */
+    historyAction: Action;
+    /**
+     * The current location reflected by the router
+     */
+    location: Location;
+    /**
+     * The current set of route matches
+     */
+    matches: AgnosticDataRouteMatch[];
+    /**
+     * Tracks whether we've completed our initial data load
+     */
+    initialized: boolean;
+    /**
+     * 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)
+     *  - 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
+     */
+    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$1 {
+    unstable_middleware: boolean;
+}
+/**
+ * Initialization options for createRouter
+ */
+interface RouterInit {
+    routes: AgnosticRouteObject[];
+    history: History;
+    basename?: string;
+    unstable_getContext?: () => MaybePromise<unstable_InitialContext>;
+    mapRouteProperties?: MapRoutePropertiesFunction;
+    future?: Partial<FutureConfig$1>;
+    hydrationRouteProperties?: string[];
+    hydrationData?: HydrationState;
+    window?: Window;
+    dataStrategy?: DataStrategyFunction;
+    patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;
+}
+/**
+ * State returned from a server-side query() call
+ */
+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;
+}
+/**
+ * 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>;
+        unstable_respond?: (staticContext: StaticHandlerContext) => MaybePromise<Response>;
+    }): Promise<StaticHandlerContext | Response>;
+    queryRoute(request: Request, opts?: {
+        routeId?: string;
+        requestContext?: unknown;
+        dataStrategy?: DataStrategyFunction<unknown>;
+        unstable_respond?: (res: 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> = {
+    /**
+     * 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 BlockerUnblocked {
+    state: "unblocked";
+    reset: undefined;
+    proceed: undefined;
+    location: undefined;
+}
+interface BlockerProceeding {
+    state: "proceeding";
+    reset: undefined;
+    proceed: undefined;
+    location: Location;
+}
+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$1;
+interface CreateStaticHandlerOptions$1 {
+    basename?: string;
+    mapRouteProperties?: MapRoutePropertiesFunction;
+    future?: {};
+}
+
+interface IndexRouteObject {
+    caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
+    path?: AgnosticIndexRouteObject["path"];
+    id?: AgnosticIndexRouteObject["id"];
+    unstable_middleware?: AgnosticIndexRouteObject["unstable_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"];
+    unstable_middleware?: AgnosticNonIndexRouteObject["unstable_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$1;
+    staticContext?: StaticHandlerContext;
+}
+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>;
+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>;
+
+/**
+ * @private
+ */
+declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
+    hasErrorBoundary: boolean;
+};
+declare const hydrationRouteProperties: (keyof RouteObject)[];
+interface MemoryRouterOpts {
+    /**
+     * Basename path for the application.
+     */
+    basename?: string;
+    /**
+     * Function to provide the initial context values for all client side navigations/fetches
+     */
+    unstable_getContext?: RouterInit["unstable_getContext"];
+    /**
+     * Future flags to enable for the router.
+     */
+    future?: Partial<FutureConfig$1>;
+    /**
+     * Hydration data to initialize the router with if you have already performed
+     * data loading on the server.
+     */
+    hydrationData?: HydrationState;
+    /**
+     * Initial entires in the in-memory history stack
+     */
+    initialEntries?: InitialEntry[];
+    /**
+     * Index of `initialEntries` the application should initialize to
+     */
+    initialIndex?: number;
+    /**
+     * Override the default data strategy of loading in parallel.
+     * Only intended for advanced usage.
+     */
+    dataStrategy?: DataStrategyFunction;
+    /**
+     * Lazily define portions of the route tree on navigations.
+     */
+    patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
+}
+/**
+ * Create a new data router that manages the application path using an in-memory
+ * history stack.  Useful for non-browser environments without a DOM API.
+ *
+ * @category Data Routers
+ */
+declare function createMemoryRouter(
+/**
+ * Application routes
+ */
+routes: RouteObject[], 
+/**
+ * Router options
+ */
+opts?: MemoryRouterOpts): Router$1;
+interface RouterProviderProps {
+    router: Router$1;
+    flushSync?: (fn: () => unknown) => undefined;
+}
+/**
+ * Given a Remix Router instance, render the appropriate UI
+ */
+declare function RouterProvider({ router, flushSync: reactDomFlushSyncImpl, }: RouterProviderProps): React.ReactElement;
+/**
+ * @category Types
+ */
+interface MemoryRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    initialEntries?: InitialEntry[];
+    initialIndex?: number;
+}
+/**
+ * A `<Router>` that stores all entries in memory.
+ *
+ * @category Component Routers
+ */
+declare function MemoryRouter({ basename, children, initialEntries, initialIndex, }: MemoryRouterProps): React.ReactElement;
+/**
+ * @category Types
+ */
+interface NavigateProps {
+    to: To;
+    replace?: boolean;
+    state?: any;
+    relative?: RelativeRoutingType;
+}
+/**
+ * A component-based version of {@link useNavigate} to use in a [`React.Component
+ * Class`](https://reactjs.org/docs/react-component.html) where hooks are not
+ * able to be used.
+ *
+ * It's recommended to avoid using this component in favor of {@link useNavigate}
+ *
+ * @category Components
+ */
+declare function Navigate({ to, replace, state, relative, }: NavigateProps): null;
+/**
+ * @category Types
+ */
+interface OutletProps {
+    /**
+      Provides a context value to the element tree below the outlet. Use when the parent route needs to provide values to child routes.
+  
+      ```tsx
+      <Outlet context={myContextValue} />
+      ```
+  
+      Access the context with {@link useOutletContext}.
+     */
+    context?: unknown;
+}
+/**
+  Renders the matching child route of a parent route or nothing if no child route matches.
+
+  ```tsx
+  import { Outlet } from "react-router"
+
+  export default function SomeParent() {
+    return (
+      <div>
+        <h1>Parent Content</h1>
+        <Outlet />
+      </div>
+    );
+  }
+  ```
+
+  @category Components
+ */
+declare function Outlet(props: OutletProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface PathRouteProps {
+    caseSensitive?: NonIndexRouteObject["caseSensitive"];
+    path?: NonIndexRouteObject["path"];
+    id?: NonIndexRouteObject["id"];
+    lazy?: LazyRouteFunction<NonIndexRouteObject>;
+    loader?: NonIndexRouteObject["loader"];
+    action?: NonIndexRouteObject["action"];
+    hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"];
+    handle?: NonIndexRouteObject["handle"];
+    index?: false;
+    children?: React.ReactNode;
+    element?: React.ReactNode | null;
+    hydrateFallbackElement?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    Component?: React.ComponentType | null;
+    HydrateFallback?: React.ComponentType | null;
+    ErrorBoundary?: React.ComponentType | null;
+}
+/**
+ * @category Types
+ */
+interface LayoutRouteProps extends PathRouteProps {
+}
+/**
+ * @category Types
+ */
+interface IndexRouteProps {
+    caseSensitive?: IndexRouteObject["caseSensitive"];
+    path?: IndexRouteObject["path"];
+    id?: IndexRouteObject["id"];
+    lazy?: LazyRouteFunction<IndexRouteObject>;
+    loader?: IndexRouteObject["loader"];
+    action?: IndexRouteObject["action"];
+    hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: IndexRouteObject["shouldRevalidate"];
+    handle?: IndexRouteObject["handle"];
+    index: true;
+    children?: undefined;
+    element?: React.ReactNode | null;
+    hydrateFallbackElement?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    Component?: React.ComponentType | null;
+    HydrateFallback?: React.ComponentType | null;
+    ErrorBoundary?: React.ComponentType | null;
+}
+type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;
+/**
+ * Configures an element to render when a pattern matches the current location.
+ * It must be rendered within a {@link Routes} element. Note that these routes
+ * do not participate in data loading, actions, code splitting, or any other
+ * route module features.
+ *
+ * @category Components
+ */
+declare function Route$1(_props: RouteProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface RouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    location: Partial<Location> | string;
+    navigationType?: Action;
+    navigator: Navigator;
+    static?: boolean;
+}
+/**
+ * Provides location context for the rest of the app.
+ *
+ * Note: You usually won't render a `<Router>` directly. Instead, you'll render a
+ * router that is more specific to your environment such as a `<BrowserRouter>`
+ * in web browsers or a `<StaticRouter>` for server rendering.
+ *
+ * @category Components
+ */
+declare function Router({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, }: RouterProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface RoutesProps {
+    /**
+     * Nested {@link Route} elements
+     */
+    children?: React.ReactNode;
+    /**
+     * The location to match against. Defaults to the current location.
+     */
+    location?: Partial<Location> | string;
+}
+/**
+ Renders a branch of {@link Route | `<Routes>`} that best matches the current
+ location. Note that these routes do not participate in data loading, actions,
+ code splitting, or any other route module features.
+
+ ```tsx
+ import { Routes, Route } from "react-router"
+
+<Routes>
+  <Route index element={<StepOne />} />
+  <Route path="step-2" element={<StepTwo />} />
+  <Route path="step-3" element={<StepThree />}>
+</Routes>
+ ```
+
+ @category Components
+ */
+declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
+interface AwaitResolveRenderFunction<Resolve = any> {
+    (data: Awaited<Resolve>): React.ReactNode;
+}
+/**
+ * @category Types
+ */
+interface AwaitProps<Resolve> {
+    /**
+    When using a function, the resolved value is provided as the parameter.
+  
+    ```tsx [2]
+    <Await resolve={reviewsPromise}>
+      {(resolvedReviews) => <Reviews items={resolvedReviews} />}
+    </Await>
+    ```
+  
+    When using React elements, {@link useAsyncValue} will provide the
+    resolved value:
+  
+    ```tsx [2]
+    <Await resolve={reviewsPromise}>
+      <Reviews />
+    </Await>
+  
+    function Reviews() {
+      const resolvedReviews = useAsyncValue()
+      return <div>...</div>
+    }
+    ```
+    */
+    children: React.ReactNode | AwaitResolveRenderFunction<Resolve>;
+    /**
+    The error element renders instead of the children when the promise rejects.
+  
+    ```tsx
+    <Await
+      errorElement={<div>Oops</div>}
+      resolve={reviewsPromise}
+    >
+      <Reviews />
+    </Await>
+    ```
+  
+    To provide a more contextual error, you can use the {@link useAsyncError} in a
+    child component
+  
+    ```tsx
+    <Await
+      errorElement={<ReviewsError />}
+      resolve={reviewsPromise}
+    >
+      <Reviews />
+    </Await>
+  
+    function ReviewsError() {
+      const error = useAsyncError()
+      return <div>Error loading reviews: {error.message}</div>
+    }
+    ```
+  
+    If you do not provide an errorElement, the rejected value will bubble up to
+    the nearest route-level {@link NonIndexRouteObject#ErrorBoundary | ErrorBoundary} and be accessible
+    via {@link useRouteError} hook.
+    */
+    errorElement?: React.ReactNode;
+    /**
+    Takes a promise returned from a {@link LoaderFunction | loader} value to be resolved and rendered.
+  
+    ```jsx
+    import { useLoaderData, Await } from "react-router"
+  
+    export async function loader() {
+      let reviews = getReviews() // not awaited
+      let book = await getBook()
+      return {
+        book,
+        reviews, // this is a promise
+      }
+    }
+  
+    export default function Book() {
+      const {
+        book,
+        reviews, // this is the same promise
+      } = useLoaderData()
+  
+      return (
+        <div>
+          <h1>{book.title}</h1>
+          <p>{book.description}</p>
+          <React.Suspense fallback={<ReviewsSkeleton />}>
+            <Await
+              // and is the promise we pass to Await
+              resolve={reviews}
+            >
+              <Reviews />
+            </Await>
+          </React.Suspense>
+        </div>
+      );
+    }
+    ```
+     */
+    resolve: Resolve;
+}
+/**
+Used to render promise values with automatic error handling.
+
+```tsx
+import { Await, useLoaderData } from "react-router";
+
+export function loader() {
+  // not awaited
+  const reviews = getReviews()
+  // awaited (blocks the transition)
+  const book = await fetch("/api/book").then((res) => res.json())
+  return { book, reviews }
+}
+
+function Book() {
+  const { book, reviews } = useLoaderData();
+  return (
+    <div>
+      <h1>{book.title}</h1>
+      <p>{book.description}</p>
+      <React.Suspense fallback={<ReviewsSkeleton />}>
+        <Await
+          resolve={reviews}
+          errorElement={
+            <div>Could not load reviews 😬</div>
+          }
+          children={(resolvedReviews) => (
+            <Reviews items={resolvedReviews} />
+          )}
+        />
+      </React.Suspense>
+    </div>
+  );
+}
+```
+
+**Note:** `<Await>` expects to be rendered inside of a `<React.Suspense>`
+
+@category Components
+
+*/
+declare function Await<Resolve>({ children, errorElement, resolve, }: AwaitProps<Resolve>): React.JSX.Element;
+/**
+ * Creates a route config from a React "children" object, which is usually
+ * either a `<Route>` element or an array of them. Used internally by
+ * `<Routes>` to create a route config from its children.
+ *
+ * @category Utils
+ */
+declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[];
+/**
+ * Create route objects from JSX elements instead of arrays of objects
+ */
+declare let createRoutesFromElements: typeof createRoutesFromChildren;
+/**
+ * Renders the result of `matchRoutes()` into a React element.
+ *
+ * @category Utils
+ */
+declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
+
+type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
+interface ServerRoute extends Route {
+    children: ServerRoute[];
+    module: ServerRouteModule;
+}
+
+/**
+ * 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 AppLoadContext {
+    [key: string]: unknown;
+}
+
+type OptionalCriticalCss = CriticalCss | undefined;
+/**
+ * The output of the compiler for the server build.
+ */
+interface ServerBuild {
+    entry: {
+        module: ServerEntryModule;
+    };
+    routes: ServerRouteManifest;
+    assets: AssetsManifest;
+    basename?: string;
+    publicPath: string;
+    assetsBuildDirectory: string;
+    future: FutureConfig;
+    ssr: boolean;
+    unstable_getCriticalCss?: (args: {
+        pathname: string;
+    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
+    /**
+     * @deprecated This is now done via a custom header during prerendering
+     */
+    isSpaMode: boolean;
+    prerender: string[];
+    routeDiscovery: {
+        mode: "lazy" | "initial";
+        manifestPath: string;
+    };
+}
+interface HandleDocumentRequestFunction {
+    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext): Promise<Response> | Response;
+}
+interface HandleDataRequestFunction {
+    (response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
+}
+interface HandleErrorFunction {
+    (error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
+}
+/**
+ * A module that serves as the entry point for a Remix app during server
+ * rendering.
+ */
+interface ServerEntryModule {
+    default: HandleDocumentRequestFunction;
+    handleDataRequest?: HandleDataRequestFunction;
+    handleError?: HandleErrorFunction;
+    streamTimeout?: number;
+}
+
+type SerializedError = {
+    message: string;
+    stack?: string;
+};
+interface FrameworkContextObject {
+    manifest: AssetsManifest;
+    routeModules: RouteModules;
+    criticalCss?: CriticalCss;
+    serverHandoffString?: string;
+    future: FutureConfig;
+    ssr: boolean;
+    isSpaMode: boolean;
+    routeDiscovery: ServerBuild["routeDiscovery"];
+    serializeError?(error: Error): SerializedError;
+    renderMeta?: {
+        didRenderScripts?: boolean;
+        streamCache?: Record<number, Promise<void> & {
+            result?: {
+                done: boolean;
+                value: string;
+            };
+            error?: unknown;
+        }>;
+    };
+}
+interface EntryContext extends FrameworkContextObject {
+    staticHandlerContext: StaticHandlerContext;
+    serverHandoffStream?: ReadableStream<Uint8Array>;
+}
+interface FutureConfig {
+    unstable_subResourceIntegrity: boolean;
+    unstable_middleware: boolean;
+}
+type CriticalCss = string | {
+    rel: "stylesheet";
+    href: string;
+};
+interface AssetsManifest {
+    entry: {
+        imports: string[];
+        module: string;
+    };
+    routes: RouteManifest<EntryRoute>;
+    url: string;
+    version: string;
+    hmr?: {
+        timestamp?: number;
+        runtime: string;
+    };
+    sri?: Record<string, string> | true;
+}
+
+interface Route {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
+}
+interface EntryRoute extends Route {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasClientMiddleware: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    clientActionModule: string | undefined;
+    clientLoaderModule: string | undefined;
+    clientMiddlewareModule: string | undefined;
+    hydrateFallbackModule: string | undefined;
+    parentId?: string;
+}
+declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
+declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
+declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
+
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+interface HtmlLinkProps {
+    /**
+     * Address of the hyperlink
+     */
+    href?: string;
+    /**
+     * How the element handles crossorigin requests
+     */
+    crossOrigin?: "anonymous" | "use-credentials";
+    /**
+     * Relationship between the document containing the hyperlink and the destination resource
+     */
+    rel: LiteralUnion<"alternate" | "dns-prefetch" | "icon" | "manifest" | "modulepreload" | "next" | "pingback" | "preconnect" | "prefetch" | "preload" | "prerender" | "search" | "stylesheet", string>;
+    /**
+     * Applicable media: "screen", "print", "(max-width: 764px)"
+     */
+    media?: string;
+    /**
+     * Integrity metadata used in Subresource Integrity checks
+     */
+    integrity?: string;
+    /**
+     * Language of the linked resource
+     */
+    hrefLang?: string;
+    /**
+     * Hint for the type of the referenced resource
+     */
+    type?: string;
+    /**
+     * Referrer policy for fetches initiated by the element
+     */
+    referrerPolicy?: "" | "no-referrer" | "no-referrer-when-downgrade" | "same-origin" | "origin" | "strict-origin" | "origin-when-cross-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
+    /**
+     * Sizes of the icons (for rel="icon")
+     */
+    sizes?: string;
+    /**
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+     */
+    as?: LiteralUnion<"audio" | "audioworklet" | "document" | "embed" | "fetch" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "serviceworker" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt", string>;
+    /**
+     * Color to use when customizing a site's icon (for rel="mask-icon")
+     */
+    color?: string;
+    /**
+     * Whether the link is disabled
+     */
+    disabled?: boolean;
+    /**
+     * The title attribute has special semantics on this element: Title of the link; CSS style sheet set name.
+     */
+    title?: string;
+    /**
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
+     */
+    imageSrcSet?: string;
+    /**
+     * Image sizes for different page layouts (for rel="preload")
+     */
+    imageSizes?: string;
+}
+interface HtmlLinkPreloadImage extends HtmlLinkProps {
+    /**
+     * Relationship between the document containing the hyperlink and the destination resource
+     */
+    rel: "preload";
+    /**
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+     */
+    as: "image";
+    /**
+     * Address of the hyperlink
+     */
+    href?: string;
+    /**
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
+     */
+    imageSrcSet: string;
+    /**
+     * Image sizes for different page layouts (for rel="preload")
+     */
+    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 absolute path of the page to prefetch.
+     */
+    page: string;
+}
+type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
+
+interface RouteModules {
+    [routeId: string]: RouteModule | undefined;
+}
+/**
+ * The shape of a route module shipped to the client
+ */
+interface RouteModule {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    unstable_clientMiddleware?: unstable_MiddlewareFunction<undefined>[];
+    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;
+    unstable_middleware?: unstable_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;
+}
+/**
+ * `<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://remix.run/route/meta
+ */
+interface LinksFunction {
+    (): LinkDescriptor[];
+}
+interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
+    id: RouteId;
+    pathname: DataRouteMatch["pathname"];
+    data: 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>> {
+    data: (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.
+ */
+type RouteComponent = ComponentType<{}>;
+/**
+ * An arbitrary object that is associated with a route.
+ *
+ * @see https://remix.run/route/handle
+ */
+type RouteHandle = unknown;
+
 declare const SingleFetchRedirectSymbol: unique symbol;
-declare function getTurboStreamSingleFetchDataStrategy(getRouter: () => Router, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, basename: string | undefined): DataStrategyFunction;
+declare function getTurboStreamSingleFetchDataStrategy(getRouter: () => Router$1, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, basename: string | undefined): DataStrategyFunction;
 declare function decodeViaTurboStream(body: ReadableStream<Uint8Array>, global: Window | typeof globalThis): Promise<{
     done: Promise<undefined>;
     value: unknown;
 }>;
 
 /**
- * The mode to use when running the server.
+ * The mode to use when running the server.
+ */
+declare enum ServerMode {
+    Development = "development",
+    Production = "production",
+    Test = "test"
+}
+
+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>;
+
+/**
+ * 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 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 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 Set<infer U> ? Set<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 SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [ClientLoaderFunctionArgs | ClientActionFunctionArgs] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
+
+/**
+  Resolves a URL against the current location.
+
+  ```tsx
+  import { useHref } from "react-router"
+
+  function SomeComponent() {
+    let href = useHref("some/where");
+    // "/resolved/some/where"
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useHref(to: To, { relative }?: {
+    relative?: RelativeRoutingType;
+}): string;
+/**
+ * Returns true if this component is a descendant of a Router, useful to ensure
+ * a component is used within a Router.
+ *
+ * @category Hooks
+ */
+declare function useInRouterContext(): boolean;
+/**
+  Returns the current {@link Location}. This can be useful if you'd like to perform some side effect whenever it changes.
+
+  ```tsx
+  import * as React from 'react'
+  import { useLocation } from 'react-router'
+
+  function SomeComponent() {
+    let location = useLocation()
+
+    React.useEffect(() => {
+      // Google Analytics
+      ga('send', 'pageview')
+    }, [location]);
+
+    return (
+      // ...
+    );
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useLocation(): Location;
+/**
+ * Returns the current navigation action which describes how the router came to
+ * the current location, either by a pop, push, or replace on the history stack.
+ *
+ * @category Hooks
+ */
+declare function useNavigationType(): Action;
+/**
+ * Returns a PathMatch object if the given pattern matches the current URL.
+ * This is useful for components that need to know "active" state, e.g.
+ * `<NavLink>`.
+ *
+ * @category Hooks
+ */
+declare function useMatch<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null;
+/**
+ * The interface for the navigate() function returned from useNavigate().
+ */
+interface NavigateFunction {
+    (to: To, options?: NavigateOptions): void | Promise<void>;
+    (delta: number): void | Promise<void>;
+}
+/**
+  Returns a function that lets you navigate programmatically in the browser in response to user interactions or effects.
+
+  ```tsx
+  import { useNavigate } from "react-router";
+
+  function SomeComponent() {
+    let navigate = useNavigate();
+    return (
+      <button
+        onClick={() => {
+          navigate(-1);
+        }}
+      />
+    );
+  }
+  ```
+
+  It's often better to use {@link redirect} in {@link ActionFunction | actions} and {@link LoaderFunction | loaders} than this hook.
+
+  @category Hooks
+ */
+declare function useNavigate(): NavigateFunction;
+/**
+ * Returns the parent route {@link OutletProps.context | `<Outlet context>`}.
+ *
+ * @category Hooks
+ */
+declare function useOutletContext<Context = unknown>(): Context;
+/**
+ * Returns the element for the child route at this level of the route
+ * hierarchy. Used internally by `<Outlet>` to render child routes.
+ *
+ * @category Hooks
+ */
+declare function useOutlet(context?: unknown): React.ReactElement | null;
+/**
+  Returns an object of key/value pairs of the dynamic params from the current URL that were matched by the routes. Child routes inherit all params from their parent routes.
+
+  ```tsx
+  import { useParams } from "react-router"
+
+  function SomeComponent() {
+    let params = useParams()
+    params.postId
+  }
+  ```
+
+  Assuming a route pattern like `/posts/:postId` is matched by `/posts/123` then `params.postId` will be `"123"`.
+
+  @category Hooks
+ */
+declare function useParams<ParamsOrKey extends string | Record<string, string | undefined> = string>(): Readonly<[
+    ParamsOrKey
+] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>>;
+/**
+  Resolves the pathname of the given `to` value against the current location. Similar to {@link useHref}, but returns a {@link Path} instead of a string.
+
+  ```tsx
+  import { useResolvedPath } from "react-router"
+
+  function SomeComponent() {
+    // if the user is at /dashboard/profile
+    let path = useResolvedPath("../accounts")
+    path.pathname // "/dashboard/accounts"
+    path.search // ""
+    path.hash // ""
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useResolvedPath(to: To, { relative }?: {
+    relative?: RelativeRoutingType;
+}): Path;
+/**
+  Hook version of {@link Routes | `<Routes>`} that uses objects instead of components. These objects have the same properties as the component props.
+
+  The return value of `useRoutes` is either a valid React element you can use to render the route tree, or `null` if nothing matched.
+
+  ```tsx
+  import * as React from "react";
+  import { useRoutes } from "react-router";
+
+  function App() {
+    let element = useRoutes([
+      {
+        path: "/",
+        element: <Dashboard />,
+        children: [
+          {
+            path: "messages",
+            element: <DashboardMessages />,
+          },
+          { path: "tasks", element: <DashboardTasks /> },
+        ],
+      },
+      { path: "team", element: <AboutPage /> },
+    ]);
+
+    return element;
+  }
+  ```
+
+ @category Hooks
+ */
+declare function useRoutes(routes: RouteObject[], locationArg?: Partial<Location> | string): React.ReactElement | null;
+/**
+  Returns the current navigation, defaulting to an "idle" navigation when no navigation is in progress. You can use this to render pending UI (like a global spinner) or read FormData from a form navigation.
+
+  ```tsx
+  import { useNavigation } from "react-router"
+
+  function SomeComponent() {
+    let navigation = useNavigation();
+    navigation.state
+    navigation.formData
+    // etc.
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useNavigation(): Navigation;
+/**
+  Revalidate the data on the page for reasons outside of normal data mutations like window focus or polling on an interval.
+
+  ```tsx
+  import { useRevalidator } from "react-router";
+
+  function WindowFocusRevalidator() {
+    const revalidator = useRevalidator();
+
+    useFakeWindowFocus(() => {
+      revalidator.revalidate();
+    });
+
+    return (
+      <div hidden={revalidator.state === "idle"}>
+        Revalidating...
+      </div>
+    );
+  }
+  ```
+
+  Note that page data is already revalidated automatically after actions. If you find yourself using this for normal CRUD operations on your data in response to user interactions, you're probably not taking advantage of the other APIs like {@link useFetcher}, {@link Form}, {@link useSubmit} that do this automatically.
+
+  @category Hooks
+ */
+declare function useRevalidator(): {
+    revalidate: () => Promise<void>;
+    state: Router$1["state"]["revalidation"];
+};
+/**
+ * Returns the active route matches, useful for accessing loaderData for
+ * parent/child routes or the route "handle" property
+ *
+ * @category Hooks
+ */
+declare function useMatches(): UIMatch[];
+/**
+  Returns the data from the closest route {@link LoaderFunction | loader} or {@link ClientLoaderFunction | client loader}.
+
+  ```tsx
+  import { useLoaderData } from "react-router"
+
+  export async function loader() {
+    return await fakeDb.invoices.findAll();
+  }
+
+  export default function Invoices() {
+    let invoices = useLoaderData<typeof loader>();
+    // ...
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useLoaderData<T = any>(): SerializeFrom<T>;
+/**
+  Returns the loader data for a given route by route ID.
+
+  ```tsx
+  import { useRouteLoaderData } from "react-router";
+
+  function SomeComponent() {
+    const { user } = useRouteLoaderData("root");
+  }
+  ```
+
+  Route IDs are created automatically. They are simply the path of the route file relative to the app folder without the extension.
+
+  | Route Filename             | Route ID             |
+  | -------------------------- | -------------------- |
+  | `app/root.tsx`             | `"root"`             |
+  | `app/routes/teams.tsx`     | `"routes/teams"`     |
+  | `app/whatever/teams.$id.tsx` | `"whatever/teams.$id"` |
+
+  If you created an ID manually, you can use that instead:
+
+  ```tsx
+  route("/", "containers/app.tsx", { id: "app" }})
+  ```
+
+  @category Hooks
+ */
+declare function useRouteLoaderData<T = any>(routeId: string): SerializeFrom<T> | undefined;
+/**
+  Returns the action data from the most recent POST navigation form submission or `undefined` if there hasn't been one.
+
+  ```tsx
+  import { Form, useActionData } from "react-router"
+
+  export async function action({ request }) {
+    const body = await request.formData()
+    const name = body.get("visitorsName")
+    return { message: `Hello, ${name}` }
+  }
+
+  export default function Invoices() {
+    const data = useActionData()
+    return (
+      <Form method="post">
+        <input type="text" name="visitorsName" />
+        {data ? data.message : "Waiting..."}
+      </Form>
+    )
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useActionData<T = any>(): SerializeFrom<T> | undefined;
+/**
+  Accesses the error thrown during an {@link ActionFunction | action}, {@link LoaderFunction | loader}, or component render to be used in a route module Error Boundary.
+
+  ```tsx
+  export function ErrorBoundary() {
+    const error = useRouteError();
+    return <div>{error.message}</div>;
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useRouteError(): unknown;
+/**
+  Returns the resolved promise value from the closest {@link Await | `<Await>`}.
+
+  ```tsx
+  function SomeDescendant() {
+    const value = useAsyncValue();
+    // ...
+  }
+
+  // somewhere in your app
+  <Await resolve={somePromise}>
+    <SomeDescendant />
+  </Await>
+  ```
+
+  @category Hooks
+ */
+declare function useAsyncValue(): unknown;
+/**
+  Returns the rejection value from the closest {@link Await | `<Await>`}.
+
+  ```tsx
+  import { Await, useAsyncError } from "react-router"
+
+  function ErrorElement() {
+    const error = useAsyncError();
+    return (
+      <p>Uh Oh, something went wrong! {error.message}</p>
+    );
+  }
+
+  // somewhere in your app
+  <Await
+    resolve={promiseThatRejects}
+    errorElement={<ErrorElement />}
+  />
+  ```
+
+  @category Hooks
+ */
+declare function useAsyncError(): unknown;
+/**
+ * Allow the application to block navigations within the SPA and present the
+ * user a confirmation dialog to confirm the navigation.  Mostly used to avoid
+ * using half-filled form data.  This does not handle hard-reloads or
+ * cross-origin navigations.
+ *
+ * @category Hooks
+ */
+declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
+
+type ParamKeyValuePair = [string, string];
+type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
+/**
+  Creates a URLSearchParams object using the given initializer.
+
+  This is identical to `new URLSearchParams(init)` except it also
+  supports arrays as values in the object form of the initializer
+  instead of just strings. This is convenient when you need multiple
+  values for a given key, but don't want to use an array initializer.
+
+  For example, instead of:
+
+  ```tsx
+  let searchParams = new URLSearchParams([
+    ['sort', 'name'],
+    ['sort', 'price']
+  ]);
+  ```
+  you can do:
+
+  ```
+  let searchParams = createSearchParams({
+    sort: ['name', 'price']
+  });
+  ```
+
+  @category Utils
+ */
+declare function createSearchParams(init?: URLSearchParamsInit): URLSearchParams;
+type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+type SubmitTarget = HTMLFormElement | HTMLButtonElement | HTMLInputElement | FormData | URLSearchParams | JsonValue | null;
+/**
+ * Submit options shared by both navigations and fetchers
+ */
+interface SharedSubmitOptions {
+    /**
+     * The HTTP method used to submit the form. Overrides `<form method>`.
+     * Defaults to "GET".
+     */
+    method?: HTMLFormMethod;
+    /**
+     * The action URL path used to submit the form. Overrides `<form action>`.
+     * Defaults to the path of the current route.
+     */
+    action?: string;
+    /**
+     * The encoding used to submit the form. Overrides `<form encType>`.
+     * Defaults to "application/x-www-form-urlencoded".
+     */
+    encType?: FormEncType;
+    /**
+     * Determines whether the form action is relative to the route hierarchy or
+     * the pathname.  Use this if you want to opt out of navigating the route
+     * hierarchy and want to instead route based on /-delimited URL segments
+     */
+    relative?: RelativeRoutingType;
+    /**
+     * In browser-based environments, prevent resetting scroll after this
+     * navigation when using the <ScrollRestoration> component
+     */
+    preventScrollReset?: boolean;
+    /**
+     * Enable flushSync for this submission's state updates
+     */
+    flushSync?: boolean;
+}
+/**
+ * Submit options available to fetchers
+ */
+interface FetcherSubmitOptions extends SharedSubmitOptions {
+}
+/**
+ * Submit options available to navigations
+ */
+interface SubmitOptions extends FetcherSubmitOptions {
+    /**
+     * Set `true` to replace the current entry in the browser's history stack
+     * instead of creating a new one (i.e. stay on "the same page"). Defaults
+     * to `false`.
+     */
+    replace?: boolean;
+    /**
+     * State object to add to the history stack entry for this navigation
+     */
+    state?: any;
+    /**
+     * Indicate a specific fetcherKey to use when using navigate=false
+     */
+    fetcherKey?: string;
+    /**
+     * navigate=false will use a fetcher instead of a navigation
+     */
+    navigate?: boolean;
+    /**
+     * Enable view transitions on this submission navigation
+     */
+    viewTransition?: boolean;
+}
+
+declare const FrameworkContext: React.Context<FrameworkContextObject | undefined>;
+/**
+ * Defines the discovery behavior of the link:
+ *
+ * - "render" - default, discover the route when the link renders
+ * - "none" - don't eagerly discover, only discover if the link is clicked
  */
-declare enum ServerMode {
-    Development = "development",
-    Production = "production",
-    Test = "test"
-}
-
+type DiscoverBehavior = "render" | "none";
 /**
-  Resolves a URL against the current location.
+ * Defines the prefetching behavior of the link:
+ *
+ * - "none": Never fetched
+ * - "intent": Fetched when the user focuses or hovers the link
+ * - "render": Fetched when the link is rendered
+ * - "viewport": Fetched when the link is in the viewport
+ */
+type PrefetchBehavior = "intent" | "render" | "none" | "viewport";
+/**
+  Renders all of the `<link>` tags created by route module {@link LinksFunction} export. You should render it inside the `<head>` of your document.
 
   ```tsx
-  import { useHref } from "react-router"
+  import { Links } from "react-router";
 
-  function SomeComponent() {
-    let href = useHref("some/where");
-    // "/resolved/some/where"
+  export default function Root() {
+    return (
+      <html>
+        <head>
+          <Links />
+        </head>
+        <body></body>
+      </html>
+    );
   }
   ```
 
-  @category Hooks
+  @category Components
  */
-declare function useHref(to: To, { relative }?: {
-    relative?: RelativeRoutingType;
-}): string;
+declare function Links(): React.JSX.Element;
 /**
- * Returns true if this component is a descendant of a Router, useful to ensure
- * a component is used within a Router.
- *
- * @category Hooks
+  Renders `<link rel=prefetch|modulepreload>` tags for modules and data of another page to enable an instant navigation to that page. {@link LinkProps.prefetch | `<Link prefetch>`} uses this internally, but you can render it to prefetch a page for any other reason.
+
+  ```tsx
+  import { PrefetchPageLinks } from "react-router"
+
+  <PrefetchPageLinks page="/absolute/path" />
+  ```
+
+  For example, you may render one of this as the user types into a search field to prefetch search results before they click through to their selection.
+
+  @category Components
  */
-declare function useInRouterContext(): boolean;
+declare function PrefetchPageLinks({ page, ...dataLinkProps }: PageLinkDescriptor): React.JSX.Element | null;
 /**
-  Returns the current {@link Location}. This can be useful if you'd like to perform some side effect whenever it changes.
+  Renders all the `<meta>` tags created by route module {@link MetaFunction} exports. You should render it inside the `<head>` of your HTML.
 
   ```tsx
-  import * as React from 'react'
-  import { useLocation } from 'react-router'
+  import { Meta } from "react-router";
 
-  function SomeComponent() {
-    let location = useLocation()
+  export default function Root() {
+    return (
+      <html>
+        <head>
+          <Meta />
+        </head>
+      </html>
+    );
+  }
+  ```
 
-    React.useEffect(() => {
-      // Google Analytics
-      ga('send', 'pageview')
-    }, [location]);
+  @category Components
+ */
+declare function Meta(): React.JSX.Element;
+/**
+  A couple common attributes:
+
+  - `<Scripts crossOrigin>` for hosting your static assets on a different server than your app.
+  - `<Scripts nonce>` to support a [content security policy for scripts](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src) with [nonce-sources](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/Sources#sources) for your `<script>` tags.
 
+  You cannot pass through attributes such as `async`, `defer`, `src`, `type`, `noModule` because they are managed by React Router internally.
+
+  @category Types
+ */
+type ScriptsProps = Omit<React.HTMLProps<HTMLScriptElement>, "children" | "async" | "defer" | "src" | "type" | "noModule" | "dangerouslySetInnerHTML" | "suppressHydrationWarning">;
+/**
+  Renders the client runtime of your app. It should be rendered inside the `<body>` of the document.
+
+  ```tsx
+  import { Scripts } from "react-router";
+
+  export default function Root() {
     return (
-      // ...
+      <html>
+        <head />
+        <body>
+          <Scripts />
+        </body>
+      </html>
     );
   }
   ```
 
-  @category Hooks
+  If server rendering, you can omit `<Scripts/>` and the app will work as a traditional web app without JavaScript, relying solely on HTML and browser behaviors.
+
+  @category Components
  */
-declare function useLocation(): Location;
+declare function Scripts(props: ScriptsProps): React.JSX.Element | null;
+
+declare global {
+    const REACT_ROUTER_VERSION: string;
+}
 /**
- * Returns the current navigation action which describes how the router came to
- * the current location, either by a pop, push, or replace on the history stack.
+ * @category Routers
+ */
+interface DOMRouterOpts {
+    /**
+     * Basename path for the application.
+     */
+    basename?: string;
+    /**
+     * Function to provide the initial context values for all client side navigations/fetches
+     */
+    unstable_getContext?: RouterInit["unstable_getContext"];
+    /**
+     * Future flags to enable for the router.
+     */
+    future?: Partial<FutureConfig$1>;
+    /**
+     * Hydration data to initialize the router with if you have already performed
+     * data loading on the server.
+     */
+    hydrationData?: HydrationState;
+    /**
+     * Override the default data strategy of loading in parallel.
+     * Only intended for advanced usage.
+     */
+    dataStrategy?: DataStrategyFunction;
+    /**
+     * Lazily define portions of the route tree on navigations.
+     */
+    patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
+    /**
+     * Window object override - defaults to the global `window` instance.
+     */
+    window?: Window;
+}
+/**
+ * Create a new data router that manages the application path via `history.pushState`
+ * and `history.replaceState`.
  *
- * @category Hooks
+ * @category Data Routers
  */
-declare function useNavigationType(): Action;
+declare function createBrowserRouter(
 /**
- * Returns a PathMatch object if the given pattern matches the current URL.
- * This is useful for components that need to know "active" state, e.g.
- * `<NavLink>`.
+ * Application routes
+ */
+routes: RouteObject[], 
+/**
+ * Router options
+ */
+opts?: DOMRouterOpts): Router$1;
+/**
+ * Create a new data router that manages the application path via the URL hash
  *
- * @category Hooks
+ * @category Data Routers
  */
-declare function useMatch<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null;
+declare function createHashRouter(routes: RouteObject[], opts?: DOMRouterOpts): Router$1;
 /**
- * The interface for the navigate() function returned from useNavigate().
+ * @category Types
  */
-interface NavigateFunction {
-    (to: To, options?: NavigateOptions): void | Promise<void>;
-    (delta: number): void | Promise<void>;
+interface BrowserRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    window?: Window;
 }
 /**
-  Returns a function that lets you navigate programmatically in the browser in response to user interactions or effects.
+ * A `<Router>` for use in web browsers. Provides the cleanest URLs.
+ *
+ * @category Component Routers
+ */
+declare function BrowserRouter({ basename, children, window, }: BrowserRouterProps): React.JSX.Element;
+/**
+ * @category Types
+ */
+interface HashRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    window?: Window;
+}
+/**
+ * A `<Router>` for use in web browsers. Stores the location in the hash
+ * portion of the URL so it is not sent to the server.
+ *
+ * @category Component Routers
+ */
+declare function HashRouter({ basename, children, window }: HashRouterProps): React.JSX.Element;
+/**
+ * @category Types
+ */
+interface HistoryRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    history: History;
+}
+/**
+ * A `<Router>` that accepts a pre-instantiated history object. It's important
+ * to note that using your own history object is highly discouraged and may add
+ * two versions of the history library to your bundles unless you use the same
+ * version of the history library that React Router uses internally.
+ *
+ * @name unstable_HistoryRouter
+ * @category Component Routers
+ */
+declare function HistoryRouter({ basename, children, history, }: HistoryRouterProps): React.JSX.Element;
+declare namespace HistoryRouter {
+    var displayName: string;
+}
+/**
+ * @category Types
+ */
+interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+    /**
+      Defines the link discovery behavior
+  
+      ```tsx
+      <Link /> // default ("render")
+      <Link discover="render" />
+      <Link discover="none" />
+      ```
+  
+      - **render** - default, discover the route when the link renders
+      - **none** - don't eagerly discover, only discover if the link is clicked
+    */
+    discover?: DiscoverBehavior;
+    /**
+      Defines the data and module prefetching behavior for the link.
+  
+      ```tsx
+      <Link /> // default
+      <Link prefetch="none" />
+      <Link prefetch="intent" />
+      <Link prefetch="render" />
+      <Link prefetch="viewport" />
+      ```
+  
+      - **none** - default, no prefetching
+      - **intent** - prefetches when the user hovers or focuses the link
+      - **render** - prefetches when the link renders
+      - **viewport** - prefetches when the link is in the viewport, very useful for mobile
+  
+      Prefetching is done with HTML `<link rel="prefetch">` tags. They are inserted after the link.
+  
+      ```tsx
+      <a href="..." />
+      <a href="..." />
+      <link rel="prefetch" /> // might conditionally render
+      ```
+  
+      Because of this, if you are using `nav :last-child` you will need to use `nav :last-of-type` so the styles don't conditionally fall off your last link (and any other similar selectors).
+     */
+    prefetch?: PrefetchBehavior;
+    /**
+      Will use document navigation instead of client side routing when the link is clicked: the browser will handle the transition normally (as if it were an `<a href>`).
+  
+      ```tsx
+      <Link to="/logout" reloadDocument />
+      ```
+     */
+    reloadDocument?: boolean;
+    /**
+      Replaces the current entry in the history stack instead of pushing a new one onto it.
+  
+      ```tsx
+      <Link replace />
+      ```
+  
+      ```
+      # with a history stack like this
+      A -> B
+  
+      # normal link click pushes a new entry
+      A -> B -> C
+  
+      # but with `replace`, B is replaced by C
+      A -> C
+      ```
+     */
+    replace?: boolean;
+    /**
+      Adds persistent client side routing state to the next location.
+  
+      ```tsx
+      <Link to="/somewhere/else" state={{ some: "value" }} />
+      ```
+  
+      The location state is accessed from the `location`.
+  
+      ```tsx
+      function SomeComp() {
+        const location = useLocation()
+        location.state; // { some: "value" }
+      }
+      ```
+  
+      This state is inaccessible on the server as it is implemented on top of [`history.state`](https://developer.mozilla.org/en-US/docs/Web/API/History/state)
+     */
+    state?: any;
+    /**
+      Prevents the scroll position from being reset to the top of the window when the link is clicked and the app is using {@link ScrollRestoration}. This only prevents new locations reseting scroll to the top, scroll position will be restored for back/forward button navigation.
+  
+      ```tsx
+      <Link to="?tab=one" preventScrollReset />
+      ```
+     */
+    preventScrollReset?: boolean;
+    /**
+      Defines the relative path behavior for the link.
+  
+      ```tsx
+      <Link to=".." /> // default: "route"
+      <Link relative="route" />
+      <Link relative="path" />
+      ```
+  
+      Consider a route hierarchy where a parent route pattern is "blog" and a child route pattern is "blog/:slug/edit".
+  
+      - **route** - default, resolves the link relative to the route pattern. In the example above a relative link of `".."` will remove both `:slug/edit` segments back to "/blog".
+      - **path** - relative to the path so `..` will only remove one URL segment up to "/blog/:slug"
+     */
+    relative?: RelativeRoutingType;
+    /**
+      Can be a string or a partial {@link Path}:
+  
+      ```tsx
+      <Link to="/some/path" />
+  
+      <Link
+        to={{
+          pathname: "/some/path",
+          search: "?query=string",
+          hash: "#hash",
+        }}
+      />
+      ```
+     */
+    to: To;
+    /**
+      Enables a [View Transition](https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API) for this navigation.
+  
+      ```jsx
+      <Link to={to} viewTransition>
+        Click me
+      </Link>
+      ```
+  
+      To apply specific styles for the transition, see {@link useViewTransitionState}
+     */
+    viewTransition?: boolean;
+}
+/**
+  A progressively enhanced `<a href>` wrapper to enable navigation with client-side routing.
 
   ```tsx
-  import { useNavigate } from "react-router";
+  import { Link } from "react-router";
 
-  function SomeComponent() {
-    let navigate = useNavigate();
-    return (
-      <button
-        onClick={() => {
-          navigate(-1);
-        }}
-      />
-    );
-  }
+  <Link to="/dashboard">Dashboard</Link>;
+
+  <Link
+    to={{
+      pathname: "/some/path",
+      search: "?query=string",
+      hash: "#hash",
+    }}
+  />
   ```
 
-  It's often better to use {@link redirect} in {@link ActionFunction | actions} and {@link LoaderFunction | loaders} than this hook.
+  @category Components
+ */
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+/**
+  The object passed to {@link NavLink} `children`, `className`, and `style` prop callbacks to render and style the link based on its state.
+
+  ```
+  // className
+  <NavLink
+    to="/messages"
+    className={({ isActive, isPending }) =>
+      isPending ? "pending" : isActive ? "active" : ""
+    }
+  >
+    Messages
+  </NavLink>
+
+  // style
+  <NavLink
+    to="/messages"
+    style={({ isActive, isPending }) => {
+      return {
+        fontWeight: isActive ? "bold" : "",
+        color: isPending ? "red" : "black",
+      }
+    )}
+  />
+
+  // children
+  <NavLink to="/tasks">
+    {({ isActive, isPending }) => (
+      <span className={isActive ? "active" : ""}>Tasks</span>
+    )}
+  </NavLink>
+  ```
 
-  @category Hooks
  */
-declare function useNavigate(): NavigateFunction;
+type NavLinkRenderProps = {
+    /**
+     * Indicates if the link's URL matches the current location.
+     */
+    isActive: boolean;
+    /**
+     * Indicates if the pending location matches the link's URL.
+     */
+    isPending: boolean;
+    /**
+     * Indicates if a view transition to the link's URL is in progress. See {@link useViewTransitionState}
+     */
+    isTransitioning: boolean;
+};
 /**
- * Returns the parent route {@link OutletProps.context | `<Outlet context>`}.
- *
- * @category Hooks
+ * @category Types
  */
-declare function useOutletContext<Context = unknown>(): Context;
+interface NavLinkProps extends Omit<LinkProps, "className" | "style" | "children"> {
+    /**
+      Can be regular React children or a function that receives an object with the active and pending states of the link.
+  
+      ```tsx
+      <NavLink to="/tasks">
+        {({ isActive }) => (
+          <span className={isActive ? "active" : ""}>Tasks</span>
+        )}
+      </NavLink>
+      ```
+     */
+    children?: React.ReactNode | ((props: NavLinkRenderProps) => React.ReactNode);
+    /**
+      Changes the matching logic to make it case-sensitive:
+  
+      | Link                                         | URL           | isActive |
+      | -------------------------------------------- | ------------- | -------- |
+      | `<NavLink to="/SpOnGe-bOB" />`               | `/sponge-bob` | true     |
+      | `<NavLink to="/SpOnGe-bOB" caseSensitive />` | `/sponge-bob` | false    |
+     */
+    caseSensitive?: boolean;
+    /**
+      Classes are automatically applied to NavLink that correspond to {@link NavLinkRenderProps}.
+  
+      ```css
+      a.active { color: red; }
+      a.pending { color: blue; }
+      a.transitioning {
+        view-transition-name: my-transition;
+      }
+      ```
+     */
+    className?: string | ((props: NavLinkRenderProps) => string | undefined);
+    /**
+      Changes the matching logic for the `active` and `pending` states to only match to the "end" of the {@link NavLinkProps.to}. If the URL is longer, it will no longer be considered active.
+  
+      | Link                          | URL          | isActive |
+      | ----------------------------- | ------------ | -------- |
+      | `<NavLink to="/tasks" />`     | `/tasks`     | true     |
+      | `<NavLink to="/tasks" />`     | `/tasks/123` | true     |
+      | `<NavLink to="/tasks" end />` | `/tasks`     | true     |
+      | `<NavLink to="/tasks" end />` | `/tasks/123` | false    |
+  
+      `<NavLink to="/">` is an exceptional case because _every_ URL matches `/`. To avoid this matching every single route by default, it effectively ignores the `end` prop and only matches when you're at the root route.
+     */
+    end?: boolean;
+    style?: React.CSSProperties | ((props: NavLinkRenderProps) => React.CSSProperties | undefined);
+}
 /**
- * Returns the element for the child route at this level of the route
- * hierarchy. Used internally by `<Outlet>` to render child routes.
- *
- * @category Hooks
+  Wraps {@link Link | `<Link>`} with additional props for styling active and pending states.
+
+  - Automatically applies classes to the link based on its active and pending states, see {@link NavLinkProps.className}.
+  - Automatically applies `aria-current="page"` to the link when the link is active. See [`aria-current`](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-current) on MDN.
+
+  ```tsx
+  import { NavLink } from "react-router"
+  <NavLink to="/message" />
+  ```
+
+  States are available through the className, style, and children render props. See {@link NavLinkRenderProps}.
+
+  ```tsx
+  <NavLink
+    to="/messages"
+    className={({ isActive, isPending }) =>
+      isPending ? "pending" : isActive ? "active" : ""
+    }
+  >
+    Messages
+  </NavLink>
+  ```
+
+  @category Components
  */
-declare function useOutlet(context?: unknown): React.ReactElement | null;
+declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+/**
+ * Form props shared by navigations and fetchers
+ */
+interface SharedFormProps extends React.FormHTMLAttributes<HTMLFormElement> {
+    /**
+     * The HTTP verb to use when the form is submitted. Supports "get", "post",
+     * "put", "delete", and "patch".
+     *
+     * Native `<form>` only supports `get` and `post`, avoid the other verbs if
+     * you'd like to support progressive enhancement
+     */
+    method?: HTMLFormMethod;
+    /**
+     * The encoding type to use for the form submission.
+     */
+    encType?: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain";
+    /**
+     * The URL to submit the form data to.  If `undefined`, this defaults to the closest route in context.
+     */
+    action?: string;
+    /**
+     * Determines whether the form action is relative to the route hierarchy or
+     * the pathname.  Use this if you want to opt out of navigating the route
+     * hierarchy and want to instead route based on /-delimited URL segments
+     */
+    relative?: RelativeRoutingType;
+    /**
+     * Prevent the scroll position from resetting to the top of the viewport on
+     * completion of the navigation when using the <ScrollRestoration> component
+     */
+    preventScrollReset?: boolean;
+    /**
+     * A function to call when the form is submitted. If you call
+     * `event.preventDefault()` then this form will not do anything.
+     */
+    onSubmit?: React.FormEventHandler<HTMLFormElement>;
+}
+/**
+ * Form props available to fetchers
+ * @category Types
+ */
+interface FetcherFormProps extends SharedFormProps {
+}
+/**
+ * Form props available to navigations
+ * @category Types
+ */
+interface FormProps extends SharedFormProps {
+    discover?: DiscoverBehavior;
+    /**
+     * Indicates a specific fetcherKey to use when using `navigate={false}` so you
+     * can pick up the fetcher's state in a different component in a {@link
+     * useFetcher}.
+     */
+    fetcherKey?: string;
+    /**
+     * Skips the navigation and uses a {@link useFetcher | fetcher} internally
+     * when `false`. This is essentially a shorthand for `useFetcher()` +
+     * `<fetcher.Form>` where you don't care about the resulting data in this
+     * component.
+     */
+    navigate?: boolean;
+    /**
+     * Forces a full document navigation instead of client side routing + data
+     * fetch.
+     */
+    reloadDocument?: boolean;
+    /**
+     * Replaces the current entry in the browser history stack when the form
+     * navigates. Use this if you don't want the user to be able to click "back"
+     * to the page with the form on it.
+     */
+    replace?: boolean;
+    /**
+     * State object to add to the history stack entry for this navigation
+     */
+    state?: any;
+    /**
+     * Enables a [View
+     * Transition](https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API)
+     * for this navigation. To apply specific styles during the transition see
+     * {@link useViewTransitionState}.
+     */
+    viewTransition?: boolean;
+}
+/**
+
+A progressively enhanced HTML [`<form>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/form) that submits data to actions via `fetch`, activating pending states in `useNavigation` which enables advanced user interfaces beyond a basic HTML form. After a form's action completes, all data on the page is automatically revalidated to keep the UI in sync with the data.
+
+Because it uses the HTML form API, server rendered pages are interactive at a basic level before JavaScript loads. Instead of React Router managing the submission, the browser manages the submission as well as the pending states (like the spinning favicon). After JavaScript loads, React Router takes over enabling web application user experiences.
+
+Form is most useful for submissions that should also change the URL or otherwise add an entry to the browser history stack. For forms that shouldn't manipulate the browser history stack, use [`<fetcher.Form>`][fetcher_form].
+
+```tsx
+import { Form } from "react-router";
+
+function NewEvent() {
+  return (
+    <Form action="/events" method="post">
+      <input name="title" type="text" />
+      <input name="description" type="text" />
+    </Form>
+  )
+}
+```
+
+@category Components
+*/
+declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
+type ScrollRestorationProps = ScriptsProps & {
+    /**
+      Defines the key used to restore scroll positions.
+  
+      ```tsx
+      <ScrollRestoration
+        getKey={(location, matches) => {
+          // default behavior
+          return location.key
+        }}
+      />
+      ```
+     */
+    getKey?: GetScrollRestorationKeyFunction;
+    storageKey?: string;
+};
 /**
-  Returns an object of key/value pairs of the dynamic params from the current URL that were matched by the routes. Child routes inherit all params from their parent routes.
+  Emulates the browser's scroll restoration on location changes. Apps should only render one of these, right before the {@link Scripts} component.
 
   ```tsx
-  import { useParams } from "react-router"
+  import { ScrollRestoration } from "react-router";
 
-  function SomeComponent() {
-    let params = useParams()
-    params.postId
+  export default function Root() {
+    return (
+      <html>
+        <body>
+          <ScrollRestoration />
+          <Scripts />
+        </body>
+      </html>
+    );
   }
   ```
 
-  Assuming a route pattern like `/posts/:postId` is matched by `/posts/123` then `params.postId` will be `"123"`.
-
-  @category Hooks
- */
-declare function useParams<ParamsOrKey extends string | Record<string, string | undefined> = string>(): Readonly<[
-    ParamsOrKey
-] extends [string] ? Params$1<ParamsOrKey> : Partial<ParamsOrKey>>;
-/**
-  Resolves the pathname of the given `to` value against the current location. Similar to {@link useHref}, but returns a {@link Path} instead of a string.
+  This component renders an inline `<script>` to prevent scroll flashing. The `nonce` prop will be passed down to the script tag to allow CSP nonce usage.
 
   ```tsx
-  import { useResolvedPath } from "react-router"
-
-  function SomeComponent() {
-    // if the user is at /dashboard/profile
-    let path = useResolvedPath("../accounts")
-    path.pathname // "/dashboard/accounts"
-    path.search // ""
-    path.hash // ""
-  }
+  <ScrollRestoration nonce={cspNonce} />
   ```
 
-  @category Hooks
+  @category Components
  */
-declare function useResolvedPath(to: To, { relative }?: {
+declare function ScrollRestoration({ getKey, storageKey, ...props }: ScrollRestorationProps): React.JSX.Element | null;
+declare namespace ScrollRestoration {
+    var displayName: string;
+}
+/**
+ * Handles the click behavior for router `<Link>` components. This is useful if
+ * you need to create custom `<Link>` components with the same click behavior we
+ * use in our exported `<Link>`.
+ *
+ * @category Hooks
+ */
+declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to: To, { target, replace: replaceProp, state, preventScrollReset, relative, viewTransition, }?: {
+    target?: React.HTMLAttributeAnchorTarget;
+    replace?: boolean;
+    state?: any;
+    preventScrollReset?: boolean;
     relative?: RelativeRoutingType;
-}): Path;
+    viewTransition?: boolean;
+}): (event: React.MouseEvent<E, MouseEvent>) => void;
 /**
-  Hook version of {@link Routes | `<Routes>`} that uses objects instead of components. These objects have the same properties as the component props.
-
-  The return value of `useRoutes` is either a valid React element you can use to render the route tree, or `null` if nothing matched.
+  Returns a tuple of the current URL's {@link URLSearchParams} and a function to update them. Setting the search params causes a navigation.
 
   ```tsx
-  import * as React from "react";
-  import { useRoutes } from "react-router";
-
-  function App() {
-    let element = useRoutes([
-      {
-        path: "/",
-        element: <Dashboard />,
-        children: [
-          {
-            path: "messages",
-            element: <DashboardMessages />,
-          },
-          { path: "tasks", element: <DashboardTasks /> },
-        ],
-      },
-      { path: "team", element: <AboutPage /> },
-    ]);
+  import { useSearchParams } from "react-router";
 
-    return element;
+  export function SomeComponent() {
+    const [searchParams, setSearchParams] = useSearchParams();
+    // ...
   }
   ```
 
  @category Hooks
  */
-declare function useRoutes(routes: RouteObject[], locationArg?: Partial<Location> | string): React.ReactElement | null;
+declare function useSearchParams(defaultInit?: URLSearchParamsInit): [URLSearchParams, SetURLSearchParams];
 /**
-  Returns the current navigation, defaulting to an "idle" navigation when no navigation is in progress. You can use this to render pending UI (like a global spinner) or read FormData from a form navigation.
+  Sets new search params and causes a navigation when called.
 
   ```tsx
-  import { useNavigation } from "react-router"
-
-  function SomeComponent() {
-    let navigation = useNavigation();
-    navigation.state
-    navigation.formData
-    // etc.
-  }
+  <button
+    onClick={() => {
+      const params = new URLSearchParams();
+      params.set("someKey", "someValue");
+      setSearchParams(params, {
+        preventScrollReset: true,
+      });
+    }}
+  />
   ```
 
-  @category Hooks
+  It also supports a function for setting new search params.
+
+  ```tsx
+  <button
+    onClick={() => {
+      setSearchParams((prev) => {
+        prev.set("someKey", "someValue");
+        return prev;
+      });
+    }}
+  />
+  ```
  */
-declare function useNavigation(): Navigation;
+type SetURLSearchParams = (nextInit?: URLSearchParamsInit | ((prev: URLSearchParams) => URLSearchParamsInit), navigateOpts?: NavigateOptions) => void;
 /**
-  Revalidate the data on the page for reasons outside of normal data mutations like window focus or polling on an interval.
+ * Submits a HTML `<form>` to the server without reloading the page.
+ */
+interface SubmitFunction {
+    (
+    /**
+      Can be multiple types of elements and objects
 
-  ```tsx
-  import { useRevalidator } from "react-router";
+      **`HTMLFormElement`**
 
-  function WindowFocusRevalidator() {
-    const revalidator = useRevalidator();
+      ```tsx
+      <Form
+        onSubmit={(event) => {
+          submit(event.currentTarget);
+        }}
+      />
+      ```
 
-    useFakeWindowFocus(() => {
-      revalidator.revalidate();
-    });
+      **`FormData`**
 
-    return (
-      <div hidden={revalidator.state === "idle"}>
-        Revalidating...
-      </div>
-    );
-  }
-  ```
+      ```tsx
+      const formData = new FormData();
+      formData.append("myKey", "myValue");
+      submit(formData, { method: "post" });
+      ```
 
-  Note that page data is already revalidated automatically after actions. If you find yourself using this for normal CRUD operations on your data in response to user interactions, you're probably not taking advantage of the other APIs like {@link useFetcher}, {@link Form}, {@link useSubmit} that do this automatically.
+      **Plain object that will be serialized as `FormData`**
 
-  @category Hooks
- */
-declare function useRevalidator(): {
-    revalidate: () => Promise<void>;
-    state: Router["state"]["revalidation"];
-};
+      ```tsx
+      submit({ myKey: "myValue" }, { method: "post" });
+      ```
+
+      **Plain object that will be serialized as JSON**
+
+      ```tsx
+      submit(
+        { myKey: "myValue" },
+        { method: "post", encType: "application/json" }
+      );
+      ```
+     */
+    target: SubmitTarget, 
+    /**
+     * Options that override the `<form>`'s own attributes. Required when
+     * submitting arbitrary data without a backing `<form>`.
+     */
+    options?: SubmitOptions): Promise<void>;
+}
 /**
- * Returns the active route matches, useful for accessing loaderData for
- * parent/child routes or the route "handle" property
- *
- * @category Hooks
+ * Submits a fetcher `<form>` to the server without reloading the page.
  */
-declare function useMatches(): UIMatch[];
-/**
-  Returns the data from the closest route {@link LoaderFunction | loader} or {@link ClientLoaderFunction | client loader}.
+interface FetcherSubmitFunction {
+    (
+    /**
+      Can be multiple types of elements and objects
 
-  ```tsx
-  import { useLoaderData } from "react-router"
+      **`HTMLFormElement`**
 
-  export async function loader() {
-    return await fakeDb.invoices.findAll();
-  }
+      ```tsx
+      <fetcher.Form
+        onSubmit={(event) => {
+          fetcher.submit(event.currentTarget);
+        }}
+      />
+      ```
 
-  export default function Invoices() {
-    let invoices = useLoaderData<typeof loader>();
-    // ...
-  }
-  ```
+      **`FormData`**
 
-  @category Hooks
- */
-declare function useLoaderData<T = any>(): SerializeFrom<T>;
-/**
-  Returns the loader data for a given route by route ID.
+      ```tsx
+      const formData = new FormData();
+      formData.append("myKey", "myValue");
+      fetcher.submit(formData, { method: "post" });
+      ```
 
-  ```tsx
-  import { useRouteLoaderData } from "react-router";
+      **Plain object that will be serialized as `FormData`**
 
-  function SomeComponent() {
-    const { user } = useRouteLoaderData("root");
-  }
-  ```
+      ```tsx
+      fetcher.submit({ myKey: "myValue" }, { method: "post" });
+      ```
 
-  Route IDs are created automatically. They are simply the path of the route file relative to the app folder without the extension.
+      **Plain object that will be serialized as JSON**
 
-  | Route Filename             | Route ID             |
-  | -------------------------- | -------------------- |
-  | `app/root.tsx`             | `"root"`             |
-  | `app/routes/teams.tsx`     | `"routes/teams"`     |
-  | `app/whatever/teams.$id.tsx` | `"whatever/teams.$id"` |
+      ```tsx
+      fetcher.submit(
+        { myKey: "myValue" },
+        { method: "post", encType: "application/json" }
+      );
+      ```
 
-  If you created an ID manually, you can use that instead:
+     */
+    target: SubmitTarget, options?: FetcherSubmitOptions): Promise<void>;
+}
+/**
+  The imperative version of {@link Form | `<Form>`} that lets you submit a form from code instead of a user interaction.
 
   ```tsx
-  route("/", "containers/app.tsx", { id: "app" }})
+  import { useSubmit } from "react-router";
+
+  function SomeComponent() {
+    const submit = useSubmit();
+    return (
+      <Form
+        onChange={(event) => {
+          submit(event.currentTarget);
+        }}
+      />
+    );
+  }
   ```
 
   @category Hooks
  */
-declare function useRouteLoaderData<T = any>(routeId: string): SerializeFrom<T> | undefined;
+declare function useSubmit(): SubmitFunction;
 /**
-  Returns the action data from the most recent POST navigation form submission or `undefined` if there hasn't been one.
+  Resolves the URL to the closest route in the component hierarchy instead of the current URL of the app.
+
+  This is used internally by {@link Form} resolve the action to the closest route, but can be used generically as well.
 
   ```tsx
-  import { Form, useActionData } from "react-router"
+  import { useFormAction } from "react-router";
 
-  export async function action({ request }) {
-    const body = await request.formData()
-    const name = body.get("visitorsName")
-    return { message: `Hello, ${name}` }
-  }
+  function SomeComponent() {
+    // closest route URL
+    let action = useFormAction();
 
-  export default function Invoices() {
-    const data = useActionData()
-    return (
-      <Form method="post">
-        <input type="text" name="visitorsName" />
-        {data ? data.message : "Waiting..."}
-      </Form>
-    )
+    // closest route URL + "destroy"
+    let destroyAction = useFormAction("destroy");
   }
   ```
 
   @category Hooks
  */
-declare function useActionData<T = any>(): SerializeFrom<T> | undefined;
+declare function useFormAction(
 /**
-  Accesses the error thrown during an {@link ActionFunction | action}, {@link LoaderFunction | loader}, or component render to be used in a route module Error Boundary.
+ * The action to append to the closest route URL.
+ */
+action?: string, { relative }?: {
+    relative?: RelativeRoutingType;
+}): string;
+/**
+The return value of `useFetcher` that keeps track of the state of a fetcher.
+
+```tsx
+let fetcher = useFetcher();
+```
+ */
+type FetcherWithComponents<TData> = Fetcher<TData> & {
+    /**
+      Just like {@link Form} except it doesn't cause a navigation.
+  
+      ```tsx
+      function SomeComponent() {
+        const fetcher = useFetcher()
+        return (
+          <fetcher.Form method="post" action="/some/route">
+            <input type="text" />
+          </fetcher.Form>
+        )
+      }
+      ```
+     */
+    Form: React.ForwardRefExoticComponent<FetcherFormProps & React.RefAttributes<HTMLFormElement>>;
+    /**
+      Submits form data to a route. While multiple nested routes can match a URL, only the leaf route will be called.
+  
+      The `formData` can be multiple types:
+  
+      - [`FormData`][form_data] - A `FormData` instance.
+      - [`HTMLFormElement`][html_form_element] - A [`<form>`][form_element] DOM element.
+      - `Object` - An object of key/value pairs that will be converted to a `FormData` instance by default. You can pass a more complex object and serialize it as JSON by specifying `encType: "application/json"`. See [`useSubmit`][use-submit] for more details.
+  
+      If the method is `GET`, then the route [`loader`][loader] is being called and with the `formData` serialized to the url as [`URLSearchParams`][url_search_params]. If `DELETE`, `PATCH`, `POST`, or `PUT`, then the route [`action`][action] is being called with `formData` as the body.
+  
+      ```tsx
+      // Submit a FormData instance (GET request)
+      const formData = new FormData();
+      fetcher.submit(formData);
+  
+      // Submit the HTML form element
+      fetcher.submit(event.currentTarget.form, {
+        method: "POST",
+      });
+  
+      // Submit key/value JSON as a FormData instance
+      fetcher.submit(
+        { serialized: "values" },
+        { method: "POST" }
+      );
+  
+      // Submit raw JSON
+      fetcher.submit(
+        {
+          deeply: {
+            nested: {
+              json: "values",
+            },
+          },
+        },
+        {
+          method: "POST",
+          encType: "application/json",
+        }
+      );
+      ```
+     */
+    submit: FetcherSubmitFunction;
+    /**
+      Loads data from a route. Useful for loading data imperatively inside of user events outside of a normal button or form, like a combobox or search input.
+  
+      ```tsx
+      let fetcher = useFetcher()
+  
+      <input onChange={e => {
+        fetcher.load(`/search?q=${e.target.value}`)
+      }} />
+      ```
+     */
+    load: (href: string, opts?: {
+        /**
+         * Wraps the initial state update for this `fetcher.load` in a
+         * `ReactDOM.flushSync` call instead of the default `React.startTransition`.
+         * This allows you to perform synchronous DOM actions immediately after the
+         * update is flushed to the DOM.
+         */
+        flushSync?: boolean;
+    }) => Promise<void>;
+};
+/**
+  Useful for creating complex, dynamic user interfaces that require multiple, concurrent data interactions without causing a navigation.
+
+  Fetchers track their own, independent state and can be used to load data, submit forms, and generally interact with loaders and actions.
 
   ```tsx
-  export function ErrorBoundary() {
-    const error = useRouteError();
-    return <div>{error.message}</div>;
+  import { useFetcher } from "react-router"
+
+  function SomeComponent() {
+    let fetcher = useFetcher()
+
+    // states are available on the fetcher
+    fetcher.state // "idle" | "loading" | "submitting"
+    fetcher.data // the data returned from the action or loader
+
+    // render a form
+    <fetcher.Form method="post" />
+
+    // load data
+    fetcher.load("/some/route")
+
+    // submit data
+    fetcher.submit(someFormRef, { method: "post" })
+    fetcher.submit(someData, {
+      method: "post",
+      encType: "application/json"
+    })
   }
   ```
 
   @category Hooks
  */
-declare function useRouteError(): unknown;
+declare function useFetcher<T = any>({ key, }?: {
+    /**
+      By default, `useFetcher` generate a unique fetcher scoped to that component. If you want to identify a fetcher with your own key such that you can access it from elsewhere in your app, you can do that with the `key` option:
+  
+      ```tsx
+      function SomeComp() {
+        let fetcher = useFetcher({ key: "my-key" })
+        // ...
+      }
+  
+      // Somewhere else
+      function AnotherComp() {
+        // this will be the same fetcher, sharing the state across the app
+        let fetcher = useFetcher({ key: "my-key" });
+        // ...
+      }
+      ```
+     */
+    key?: string;
+}): FetcherWithComponents<SerializeFrom<T>>;
 /**
-  Returns the resolved promise value from the closest {@link Await | `<Await>`}.
+  Returns an array of all in-flight fetchers. This is useful for components throughout the app that didn't create the fetchers but want to use their submissions to participate in optimistic UI.
 
   ```tsx
-  function SomeDescendant() {
-    const value = useAsyncValue();
+  import { useFetchers } from "react-router";
+
+  function SomeComponent() {
+    const fetchers = useFetchers();
+    fetchers[0].formData; // FormData
+    fetchers[0].state; // etc.
     // ...
   }
-
-  // somewhere in your app
-  <Await resolve={somePromise}>
-    <SomeDescendant />
-  </Await>
   ```
 
   @category Hooks
  */
-declare function useAsyncValue(): unknown;
+declare function useFetchers(): (Fetcher & {
+    key: string;
+})[];
 /**
-  Returns the rejection value from the closest {@link Await | `<Await>`}.
+ * When rendered inside a RouterProvider, will restore scroll positions on navigations
+ */
+declare function useScrollRestoration({ getKey, storageKey, }?: {
+    getKey?: GetScrollRestorationKeyFunction;
+    storageKey?: string;
+}): void;
+/**
+ * Setup a callback to be fired on the window's `beforeunload` event.
+ *
+ * @category Hooks
+ */
+declare function useBeforeUnload(callback: (event: BeforeUnloadEvent) => any, options?: {
+    capture?: boolean;
+}): void;
+/**
+  Wrapper around useBlocker to show a window.confirm prompt to users instead of building a custom UI with {@link useBlocker}.
+
+  The `unstable_` flag will not be removed because this technique has a lot of rough edges and behaves very differently (and incorrectly sometimes) across browsers if users click addition back/forward navigations while the confirmation is open.  Use at your own risk.
 
   ```tsx
-  import { Await, useAsyncError } from "react-router"
+  function ImportantForm() {
+    let [value, setValue] = React.useState("");
+
+    // Block navigating elsewhere when data has been entered into the input
+    unstable_usePrompt({
+      message: "Are you sure?",
+      when: ({ currentLocation, nextLocation }) =>
+        value !== "" &&
+        currentLocation.pathname !== nextLocation.pathname,
+    });
 
-  function ErrorElement() {
-    const error = useAsyncError();
     return (
-      <p>Uh Oh, something went wrong! {error.message}</p>
+      <Form method="post">
+        <label>
+          Enter some important data:
+          <input
+            name="data"
+            value={value}
+            onChange={(e) => setValue(e.target.value)}
+          />
+        </label>
+        <button type="submit">Save</button>
+      </Form>
     );
   }
-
-  // somewhere in your app
-  <Await
-    resolve={promiseThatRejects}
-    errorElement={<ErrorElement />}
-  />
   ```
 
   @category Hooks
+  @name unstable_usePrompt
  */
-declare function useAsyncError(): unknown;
+declare function usePrompt({ when, message, }: {
+    when: boolean | BlockerFunction;
+    message: string;
+}): void;
 /**
- * Allow the application to block navigations within the SPA and present the
- * user a confirmation dialog to confirm the navigation.  Mostly used to avoid
- * using half-filled form data.  This does not handle hard-reloads or
- * cross-origin navigations.
- *
- * @category Hooks
+  This hook returns `true` when there is an active [View Transition](https://developer.mozilla.org/en-US/docs/Web/API/View_Transitions_API) to the specified location. This can be used to apply finer-grained styles to elements to further customize the view transition. This requires that view transitions have been enabled for the given navigation via {@link LinkProps.viewTransition} (or the `Form`, `submit`, or `navigate` call)
+
+  @category Hooks
+  @name useViewTransitionState
  */
-declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
+declare function useViewTransitionState(to: To, opts?: {
+    relative?: RelativeRoutingType;
+}): boolean;
 
 interface StaticRouterProps {
     basename?: string;
@@ -404,7 +3874,7 @@ interface StaticRouterProps {
 declare function StaticRouter({ basename, children, location: locationProp, }: StaticRouterProps): React.JSX.Element;
 interface StaticRouterProviderProps {
     context: StaticHandlerContext;
-    router: Router;
+    router: Router$1;
     hydrate?: boolean;
     nonce?: string;
 }
@@ -424,8 +3894,8 @@ declare function createStaticHandler(routes: RouteObject[], opts?: CreateStaticH
  * @category Data Routers
  */
 declare function createStaticRouter(routes: RouteObject[], context: StaticHandlerContext, opts?: {
-    future?: Partial<FutureConfig>;
-}): Router;
+    future?: Partial<FutureConfig$1>;
+}): Router$1;
 
 interface ServerRouterProps {
     context: EntryContext;
@@ -497,7 +3967,7 @@ interface RoutesTestStubProps {
     /**
      * Future flags mimicking the settings in react-router.config.ts
      */
-    future?: Partial<FutureConfig$1>;
+    future?: Partial<FutureConfig>;
 }
 /**
  * @category Utils
@@ -752,16 +4222,26 @@ declare function setDevServerHooks(devServerHooks: DevServerHooks): void;
  */
 interface Register {
 }
+type AnyParams = Record<string, string | undefined>;
+type AnyPages = Record<string, {
+    params: AnyParams;
+}>;
+type Pages = Register extends {
+    pages: infer Registered extends AnyPages;
+} ? Registered : AnyPages;
+type AnyRouteFiles = Record<string, {
+    id: string;
+    page: string;
+}>;
+type RouteFiles = Register extends {
+    routeFiles: infer Registered extends AnyRouteFiles;
+} ? Registered : AnyRouteFiles;
 
-type AnyParams = Record<string, Record<string, string | undefined>>;
-type Params = Register extends {
-    params: infer RegisteredParams extends AnyParams;
-} ? RegisteredParams : AnyParams;
 type Args = {
-    [K in keyof Params]: ToArgs<Params[K]>;
+    [K in keyof Pages]: ToArgs<Pages[K]["params"]>;
 };
-type ToArgs<T> = Equal<T, {}> extends true ? [] : Partial<T> extends T ? [T] | [] : [
-    T
+type ToArgs<Params extends Record<string, string | undefined>> = Equal<Params, {}> extends true ? [] : Partial<Params> extends Params ? [Params] | [] : [
+    Params
 ];
 /**
   Returns a resolved URL path for the specified route.
@@ -799,16 +4279,16 @@ declare class RemixErrorBoundary extends React.Component<RemixErrorBoundaryProps
 }
 
 declare function getPatchRoutesOnNavigationFunction(manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, routeDiscovery: ServerBuild["routeDiscovery"], isSpaMode: boolean, basename: string | undefined): PatchRoutesOnNavigationFunction | undefined;
-declare function useFogOFWarDiscovery(router: Router, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, routeDiscovery: ServerBuild["routeDiscovery"], isSpaMode: boolean): void;
+declare function useFogOFWarDiscovery(router: Router$1, manifest: AssetsManifest, routeModules: RouteModules, ssr: boolean, routeDiscovery: ServerBuild["routeDiscovery"], isSpaMode: boolean): void;
 
 declare function getHydrationData(state: {
-    loaderData?: Router["state"]["loaderData"];
-    actionData?: Router["state"]["actionData"];
-    errors?: Router["state"]["errors"];
+    loaderData?: Router$1["state"]["loaderData"];
+    actionData?: Router$1["state"]["actionData"];
+    errors?: Router$1["state"]["errors"];
 }, routes: DataRouteObject[], getRouteInfo: (routeId: string) => {
     clientLoader: ClientLoaderFunction | undefined;
     hasLoader: boolean;
     hasHydrateFallback: boolean;
 }, location: Path, basename: string | undefined, isSpaMode: boolean): HydrationState;
 
-export { ActionFunction, AppLoadContext, Blocker, BlockerFunction, ClientLoaderFunction, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, DataRouteObject, Router as DataRouter, DataStrategyFunction, EntryContext, type FlashSessionData, HydrationState, IndexRouteObject, InitialEntry, type IsCookieFunction, type IsSessionFunction, LinksFunction, LoaderFunction, Location, MetaFunction, type NavigateFunction, NavigateOptions, Navigation, Action as NavigationType, NonIndexRouteObject, ParamParseKey, Params$1 as Params, PatchRoutesOnNavigationFunction, Path, PathMatch, PathPattern, type Register, RelativeRoutingType, type RequestHandler, RouteObject, RouterState, type RoutesTestStubProps, ServerBuild, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, StaticHandler, StaticHandlerContext, StaticRouter, type StaticRouterProps, StaticRouterProvider, type StaticRouterProviderProps, To, UIMatch, AssetsManifest as UNSAFE_AssetsManifest, MiddlewareEnabled as UNSAFE_MiddlewareEnabled, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getHydrationData as UNSAFE_getHydrationData, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, createCookie, createCookieSessionStorage, createMemorySessionStorage, createRequestHandler, createRoutesStub, createSession, createSessionStorage, createStaticHandler, createStaticRouter, href, isCookie, isSession, unstable_InitialContext, setDevServerHooks as unstable_setDevServerHooks, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };
+export { type ActionFunction, type ActionFunctionArgs, type AppLoadContext, Await, type AwaitProps, type Blocker, type BlockerFunction, BrowserRouter, type BrowserRouterProps, type ClientActionFunction, type ClientActionFunctionArgs, type ClientLoaderFunction, type ClientLoaderFunctionArgs, type Cookie, type CookieOptions, type CookieSignatureOptions, type CreateRequestHandlerFunction, type DOMRouterOpts, type DataRouteMatch, type DataRouteObject, type Router$1 as DataRouter, type DataStrategyFunction, type DataStrategyFunctionArgs, type DataStrategyMatch, type DataStrategyResult, type EntryContext, type ErrorResponse, type Fetcher, type FetcherFormProps, type FetcherSubmitFunction, type FetcherSubmitOptions, type FetcherWithComponents, type FlashSessionData, Form, type FormEncType, type FormMethod, type FormProps, type Future, type GetScrollPositionFunction, type GetScrollRestorationKeyFunction, type HTMLFormMethod, type HandleDataRequestFunction, type HandleDocumentRequestFunction, type HandleErrorFunction, HashRouter, type HashRouterProps, type HeadersArgs, type HeadersFunction, type HistoryRouterProps, type HtmlLinkDescriptor, type HydrationState, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, type IndexRouteObject, type IndexRouteProps, type InitialEntry, type IsCookieFunction, type IsSessionFunction, type LayoutRouteProps, type LazyRouteFunction, Link, type LinkDescriptor, type LinkProps, Links, type LinksFunction, type LoaderFunction, type LoaderFunctionArgs, type Location, MemoryRouter, type MemoryRouterOpts, type MemoryRouterProps, Meta, type MetaArgs, type MetaDescriptor, type MetaFunction, NavLink, type NavLinkProps, type NavLinkRenderProps, Navigate, type NavigateFunction, type NavigateOptions, type NavigateProps, type Navigation, type NavigationStates, Action as NavigationType, type Navigator, type NonIndexRouteObject, Outlet, type OutletProps, type PageLinkDescriptor, type Pages, type ParamKeyValuePair, type ParamParseKey, type Params, type PatchRoutesOnNavigationFunction, type PatchRoutesOnNavigationFunctionArgs, type Path, type PathMatch, type PathParam, type PathPattern, type PathRouteProps, PrefetchPageLinks, type RedirectFunction, type Register, type RelativeRoutingType, type RequestHandler, type RevalidationState, Route$1 as Route, type RouteFiles, type RouteMatch, type RouteObject, type RouteProps, Router, type RouterFetchOptions, type RouterInit, type RouterNavigateOptions, type RouterProps, RouterProvider, type RouterProviderProps, type RouterState, type RouterSubscriber, Routes, type RoutesProps, type RoutesTestStubProps, Scripts, type ScriptsProps, ScrollRestoration, type ScrollRestorationProps, type ServerBuild, type ServerEntryModule, ServerRouter, type ServerRouterProps, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, type SetURLSearchParams, type ShouldRevalidateFunction, type ShouldRevalidateFunctionArgs, type StaticHandler, type StaticHandlerContext, StaticRouter, type StaticRouterProps, StaticRouterProvider, type StaticRouterProviderProps, type SubmitFunction, type SubmitOptions, type SubmitTarget, type To, type UIMatch, type AssetsManifest as UNSAFE_AssetsManifest, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, DataWithResponseInit as UNSAFE_DataWithResponseInit, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, FetchersContext as UNSAFE_FetchersContext, FrameworkContext as UNSAFE_FrameworkContext, LocationContext as UNSAFE_LocationContext, type MiddlewareEnabled as UNSAFE_MiddlewareEnabled, NavigationContext as UNSAFE_NavigationContext, RemixErrorBoundary as UNSAFE_RemixErrorBoundary, RouteContext as UNSAFE_RouteContext, type RouteModules as UNSAFE_RouteModules, ServerMode as UNSAFE_ServerMode, SingleFetchRedirectSymbol as UNSAFE_SingleFetchRedirectSymbol, ViewTransitionContext as UNSAFE_ViewTransitionContext, createBrowserHistory as UNSAFE_createBrowserHistory, createClientRoutes as UNSAFE_createClientRoutes, createClientRoutesWithHMRRevalidationOptOut as UNSAFE_createClientRoutesWithHMRRevalidationOptOut, createRouter as UNSAFE_createRouter, decodeViaTurboStream as UNSAFE_decodeViaTurboStream, deserializeErrors as UNSAFE_deserializeErrors, getHydrationData as UNSAFE_getHydrationData, getPatchRoutesOnNavigationFunction as UNSAFE_getPatchRoutesOnNavigationFunction, getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy, hydrationRouteProperties as UNSAFE_hydrationRouteProperties, invariant as UNSAFE_invariant, mapRouteProperties as UNSAFE_mapRouteProperties, shouldHydrateRouteLoader as UNSAFE_shouldHydrateRouteLoader, useFogOFWarDiscovery as UNSAFE_useFogOFWarDiscovery, useScrollRestoration as UNSAFE_useScrollRestoration, type URLSearchParamsInit, createBrowserRouter, createCookie, createCookieSessionStorage, createHashRouter, createMemoryRouter, createMemorySessionStorage, createPath, createRequestHandler, createRoutesFromChildren, createRoutesFromElements, createRoutesStub, createSearchParams, createSession, createSessionStorage, createStaticHandler, createStaticRouter, data, generatePath, href, isCookie, isRouteErrorResponse, isSession, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, replace, resolvePath, HistoryRouter as unstable_HistoryRouter, type unstable_InitialContext, type unstable_MiddlewareFunction, type unstable_RouterContext, unstable_RouterContextProvider, type unstable_SerializesTo, unstable_createContext, setDevServerHooks as unstable_setDevServerHooks, usePrompt as unstable_usePrompt, useActionData, useAsyncError, useAsyncValue, useBeforeUnload, useBlocker, useFetcher, useFetchers, useFormAction, useHref, useInRouterContext, useLinkClickHandler, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, useSearchParams, useSubmit, useViewTransitionState };