UNPKG

react-router/dist/production/instrumentation-DvHY1sgY.d.ts

Version:
127 kBTypeScriptView Raw
1import * as React from 'react';
2import { ComponentType, ReactElement } from 'react';
3
4/**
* An augmentable interface users can modify in their app-code to opt into
* future-flag-specific types
*/
8interface Future {
9}
10type MiddlewareEnabled = Future extends {
  v8_middleware: infer T extends boolean;
12} ? T : false;
13
14/**
* Actions represent the type of change to a location value.
*/
17declare 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"
37}
38/**
* The pathname, search, and hash values of a URL.
*/
41interface 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;
54}
55/**
* An entry in a history stack. A location contains information about the
* URL path, as well as possibly some arbitrary state and a key.
*/
59interface 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;
71}
72/**
* A change to the current location.
*/
75interface 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;
88}
89/**
* A function that receives notifications about location changes.
*/
92interface Listener {
  (update: Update): void;
94}
95/**
* Describes a location that is the destination of some navigation used in
* {@link Link}, {@link useNavigate}, etc.
*/
99type To = string | Partial<Path>;
100/**
* 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.
*/
108interface 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;
171}
172/**
* A user-supplied object that describes a location. Used when providing
* entries to `createMemoryHistory` via its `initialEntries` option.
*/
176type InitialEntry = string | Partial<Location>;
177type MemoryHistoryOptions = {
  initialEntries?: InitialEntry[];
  initialIndex?: number;
  v5Compat?: boolean;
181};
182/**
* A memory history stores locations in memory. This is useful in stateful
* environments where there is no web browser, such as node tests or React
* Native.
*/
187interface MemoryHistory extends History {
  /**
   * The current index in the history stack.
   */
  readonly index: number;
192}
193/**
* Memory history stores the current location in memory. It is designed for use
* in stateful non-browser environments like tests and React Native.
*/
197declare function createMemoryHistory(options?: MemoryHistoryOptions): MemoryHistory;
198/**
* 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
*/
205interface BrowserHistory extends UrlHistory {
206}
207type BrowserHistoryOptions = UrlHistoryOptions;
208/**
* 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
*/
215declare function createBrowserHistory(options?: BrowserHistoryOptions): BrowserHistory;
216/**
* A hash history stores the current location in the fragment identifier portion
* of the URL in a web browser environment.
*
* This is ideal for apps that do not control the server for some reason
* (because the fragment identifier is never sent to the server), including some
* shared hosting environments that do not provide fine-grained controls over
* which pages are served at which URLs.
*
* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
*/
227interface HashHistory extends UrlHistory {
228}
229type HashHistoryOptions = UrlHistoryOptions;
230/**
* Hash history stores the location in window.location.hash. This makes it ideal
* for situations where you don't want to send the location to the server for
* some reason, either because you do cannot configure it or the URL space is
* reserved for something else.
*
* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
*/
238declare function createHashHistory(options?: HashHistoryOptions): HashHistory;
239/**
* @private
*/
242declare function invariant(value: boolean, message?: string): asserts value;
243declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
244/**
* Creates a string URL path from the given pathname, search, and hash components.
*
* @category Utils
*/
249declare function createPath({ pathname, search, hash, }: Partial<Path>): string;
250/**
* Parses a string URL path into its separate pathname, search, and hash components.
*
* @category Utils
*/
255declare function parsePath(path: string): Partial<Path>;
256interface UrlHistory extends History {
257}
258type UrlHistoryOptions = {
  window?: Window;
  v5Compat?: boolean;
261};
262
263type MaybePromise<T> = T | Promise<T>;
264/**
* Map of routeId -> data returned from a loader/action/error
*/
267interface RouteData {
  [routeId: string]: any;
269}
270type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
271type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
272/**
* Users can specify either lowercase or uppercase form methods on `<Form>`,
* useSubmit(), `<fetcher.Form>`, etc.
*/
276type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
277/**
* Active navigation/fetcher form methods are exposed in uppercase on the
* RouterState. This is to align with the normalization done via fetch().
*/
281type FormMethod = UpperCaseFormMethod;
282type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
283type JsonObject = {
  [Key in string]: JsonValue;
285} & {
  [Key in string]?: JsonValue | undefined;
287};
288type JsonArray = JsonValue[] | readonly JsonValue[];
289type JsonPrimitive = string | number | boolean | null;
290type JsonValue = JsonPrimitive | JsonObject | JsonArray;
291/**
* @private
* Internal interface to pass around for action submissions, not intended for
* external consumption
*/
296type Submission = {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: FormData;
  json: undefined;
  text: undefined;
303} | {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: undefined;
  json: JsonValue;
  text: undefined;
310} | {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: undefined;
  json: undefined;
  text: string;
317};
318/**
* A context instance used as the key for the `get`/`set` methods of a
* {@link RouterContextProvider}. Accepts an optional default
* value to be returned if no value has been set.
*/
323interface RouterContext<T = unknown> {
  defaultValue?: T;
325}
326/**
* Creates a type-safe {@link RouterContext} object that can be used to
* store and retrieve arbitrary values in [`action`](../../start/framework/route-module#action)s,
* [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
* Similar to React's [`createContext`](https://react.dev/reference/react/createContext),
* but specifically designed for React Router's request/response lifecycle.
*
* 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.
*
* ```tsx filename=app/context.ts
* import { createContext } from "react-router";
*
* // Create a context for user data
* export const userContext =
*   createContext<User | null>(null);
* ```
*
* ```tsx filename=app/middleware/auth.ts
* import { getUserFromSession } from "~/auth.server";
* import { userContext } from "~/context";
*
* export const authMiddleware = async ({
*   context,
*   request,
* }) => {
*   const user = await getUserFromSession(request);
*   context.set(userContext, user);
* };
* ```
*
* ```tsx filename=app/routes/profile.tsx
* import { userContext } from "~/context";
*
* export async function loader({
*   context,
* }: Route.LoaderArgs) {
*   const user = context.get(userContext);
*
*   if (!user) {
*     throw new Response("Unauthorized", { status: 401 });
*   }
*
*   return { user };
* }
* ```
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param defaultValue An optional default value for the context. This value
* will be returned if no value has been set for this context.
* @returns A {@link RouterContext} object that can be used with
* `context.get()` and `context.set()` in [`action`](../../start/framework/route-module#action)s,
* [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
*/
384declare function createContext<T>(defaultValue?: T): RouterContext<T>;
385/**
* Provides methods for writing/reading values in application context in a
* type-safe way. Primarily for usage with [middleware](../../how-to/middleware).
*
* @example
* import {
*   createContext,
*   RouterContextProvider
* } from "react-router";
*
* const userContext = createContext<User | null>(null);
* const contextProvider = new RouterContextProvider();
* contextProvider.set(userContext, getUser());
* //                               ^ Type-safe
* const user = contextProvider.get(userContext);
* //    ^ User
*
* @public
* @category Utils
* @mode framework
* @mode data
*/
407declare class RouterContextProvider {
  #private;
  /**
   * Create a new `RouterContextProvider` instance
   * @param init An optional initial context map to populate the provider with
   */
  constructor(init?: Map<RouterContext, unknown>);
  /**
   * Access a value from the context. If no value has been set for the context,
   * it will return the context's `defaultValue` if provided, or throw an error
   * if no `defaultValue` was set.
   * @param context The context to get the value for
   * @returns The value for the context, or the context's `defaultValue` if no
   * value was set
   */
  get<T>(context: RouterContext<T>): T;
  /**
   * Set a value for the context. If the context already has a value set, this
   * will overwrite it.
   *
   * @param context The context to set the value for
   * @param value The value to set for the context
   * @returns {void}
   */
  set<C extends RouterContext>(context: C, value: C extends RouterContext<infer T> ? T : never): void;
432}
433type DefaultContext = MiddlewareEnabled extends true ? Readonly<RouterContextProvider> : any;
434/**
* @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.
*/
439interface DataFunctionArgs<Context> {
  /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read headers (like cookies, and {@link https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams URLSearchParams} from the request. */
  request: Request;
  /**
   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
   */
  unstable_pattern: string;
  /**
   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
   * @example
   * // 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;
468}
469/**
* Route middleware `next` function to call downstream handlers and then complete
* middlewares from the bottom-up
*/
473interface MiddlewareNextFunction<Result = unknown> {
  (): Promise<Result>;
475}
476/**
* 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
*/
482type MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<Readonly<RouterContextProvider>>, next: MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
483/**
* Arguments passed to loader functions
*/
486interface LoaderFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
487}
488/**
* Arguments passed to action functions
*/
491interface ActionFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
492}
493/**
* Loaders and actions can return anything
*/
496type DataFunctionValue = unknown;
497type DataFunctionReturnValue = MaybePromise<DataFunctionValue>;
498/**
* Route loader function signature
*/
501type LoaderFunction<Context = DefaultContext> = {
  (args: LoaderFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
503} & {
  hydrate?: boolean;
505};
506/**
* Route action function signature
*/
509interface ActionFunction<Context = DefaultContext> {
  (args: ActionFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
511}
512/**
* Arguments passed to shouldRevalidate function
*/
515interface 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;
567}
568/**
* 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.
*/
575interface ShouldRevalidateFunction {
  (args: ShouldRevalidateFunctionArgs): boolean;
577}
578interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
  /**
   * @private
   */
  _lazyPromises?: {
      middleware: Promise<void> | undefined;
      handler: Promise<void> | undefined;
      route: Promise<void> | undefined;
  };
  /**
   * @deprecated Deprecated in favor of `shouldCallHandler`
   *
   * A boolean value indicating whether this route handler should be called in
   * this pass.
   *
   * The `matches` array always includes _all_ matched routes even when only
   * _some_ route handlers need to be called so that things like middleware can
   * be implemented.
   *
   * `shouldLoad` is usually only interesting if you are skipping the route
   * handler entirely and implementing custom handler logic - since it lets you
   * determine if that custom logic should run for this route or not.
   *
   * For example:
   *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
   *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
   *    will have `shouldLoad=true` because the data for `parent` and `child` is
   *    already loaded
   *  - If you are on `/parent/child/a` and you submit to `a`'s [`action`](https://reactrouter.com/docs/start/data/route-object#action),
   *    then only `a` will have `shouldLoad=true` for the action execution of
   *    `dataStrategy`
   *  - After the [`action`](https://reactrouter.com/docs/start/data/route-object#action),
   *    `dataStrategy` will be called again for the [`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
   *    revalidation, and all matches will have `shouldLoad=true` (assuming no
   *    custom `shouldRevalidate` implementations)
   */
  shouldLoad: boolean;
  /**
   * Arguments passed to the `shouldRevalidate` function for this `loader` execution.
   * Will be `null` if this is not a revalidating loader {@link DataStrategyMatch}.
   */
  shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
  /**
   * Determine if this route's handler should be called during this `dataStrategy`
   * execution. Calling it with no arguments will leverage the default revalidation
   * behavior. You can pass your own `defaultShouldRevalidate` value if you wish
   * to change the default revalidation behavior with your `dataStrategy`.
   *
   * @param defaultShouldRevalidate `defaultShouldRevalidate` override value (optional)
   */
  shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
  /**
   * An async function that will resolve any `route.lazy` implementations and
   * execute the route's handler (if necessary), returning a {@link DataStrategyResult}
   *
   * - Calling `match.resolve` does not mean you're calling the
   *   [`action`](https://reactrouter.com/docs/start/data/route-object#action)/[`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
   *   (the "handler") - `resolve` will only call the `handler` internally if
   *   needed _and_ if you don't pass your own `handlerOverride` function parameter
   * - It is safe to call `match.resolve` for all matches, even if they have
   *   `shouldLoad=false`, and it will no-op if no loading is required
   * - You should generally always call `match.resolve()` for `shouldLoad:true`
   *   routes to ensure that any `route.lazy` implementations are processed
   * - See the examples below for how to implement custom handler execution via
   *   `match.resolve`
   */
  resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
645}
646interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
  /**
   * Matches for this route extended with Data strategy APIs
   */
  matches: DataStrategyMatch[];
  runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
  /**
   * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
   * for navigational executions
   */
  fetcherKey: string | null;
657}
658/**
* Result from a loader or action called via dataStrategy
*/
661interface DataStrategyResult {
  type: "data" | "error";
  result: unknown;
664}
665interface DataStrategyFunction<Context = DefaultContext> {
  (args: DataStrategyFunctionArgs<Context>): Promise<Record<string, DataStrategyResult>>;
667}
668type 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;
674};
675type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = (opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>) => MaybePromise<void>;
676/**
* Function provided by the framework-aware layers to set any framework-specific
* properties from framework-agnostic properties
*/
680interface MapRoutePropertiesFunction {
  (route: AgnosticDataRouteObject): {
      hasErrorBoundary: boolean;
  } & Record<string, any>;
684}
685/**
* 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.
*/
690type UnsupportedLazyRouteObjectKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
691/**
* 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.
*/
696type UnsupportedLazyRouteFunctionKey = UnsupportedLazyRouteObjectKey | "middleware";
697/**
* lazy object to load route properties, which can add non-matching
* related properties to a route
*/
701type LazyRouteObject<R extends AgnosticRouteObject> = {
  [K in keyof R as K extends UnsupportedLazyRouteObjectKey ? never : K]?: () => Promise<R[K] | null | undefined>;
703};
704/**
* lazy() function to load a route definition, which can add non-matching
* related properties to a route
*/
708interface LazyRouteFunction<R extends AgnosticRouteObject> {
  (): Promise<Omit<R, UnsupportedLazyRouteFunctionKey> & Partial<Record<UnsupportedLazyRouteFunctionKey, never>>>;
710}
711type LazyRouteDefinition<R extends AgnosticRouteObject> = LazyRouteObject<R> | LazyRouteFunction<R>;
712/**
* Base RouteObject with common props shared by all types of routes
*/
715type AgnosticBaseRouteObject = {
  caseSensitive?: boolean;
  path?: string;
  id?: string;
  middleware?: MiddlewareFunction[];
  loader?: LoaderFunction | boolean;
  action?: ActionFunction | boolean;
  hasErrorBoundary?: boolean;
  shouldRevalidate?: ShouldRevalidateFunction;
  handle?: any;
  lazy?: LazyRouteDefinition<AgnosticBaseRouteObject>;
726};
727/**
* Index routes must not have children
*/
730type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
  children?: undefined;
  index: true;
733};
734/**
* Non-index routes may have children, but cannot have index
*/
737type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
  children?: AgnosticRouteObject[];
  index?: false;
740};
741/**
* A route object represents a logical route, with (optionally) its child
* routes organized in a tree-like structure.
*/
745type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
746type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
  id: string;
748};
749type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
  children?: AgnosticDataRouteObject[];
  id: string;
752};
753/**
* A data route object, which is just a RouteObject with a required unique ID
*/
756type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
757type RouteManifest<R = AgnosticDataRouteObject> = Record<string, R | undefined>;
758type 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";
759type 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";
760type Regex_09 = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
761type Regex_w = Regex_az | Regez_AZ | Regex_09 | "_";
762type ParamChar = Regex_w | "-";
763type 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;
764type _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;
765type PathParam<Path extends string> = Path extends "*" | "/*" ? "*" : Path extends `${infer Rest}/*` ? "*" | _PathParam<Rest> : _PathParam<Path>;
766type ParamParseKey<Segment extends string> = [
  PathParam<Segment>
768] extends [never] ? string : PathParam<Segment>;
769/**
* The parameters that were parsed from the URL path.
*/
772type Params<Key extends string = string> = {
  readonly [key in Key]: string | undefined;
774};
775/**
* A RouteMatch contains info about how a route matched a URL.
*/
778interface 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;
795}
796interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
797}
798/**
* Matches the given routes to a location and returns the match data.
*
* @example
* import { matchRoutes } from "react-router";
*
* let routes = [{
*   path: "/",
*   Component: Root,
*   children: [{
*     path: "dashboard",
*     Component: Dashboard,
*   }]
* }];
*
* matchRoutes(routes, "/dashboard"); // [rootMatch, dashboardMatch]
*
* @public
* @category Utils
* @param routes The array of route objects to match against.
* @param locationArg The location to match against, either a string path or a
* partial {@link Location} object
* @param basename Optional base path to strip from the location before matching.
* Defaults to `/`.
* @returns An array of matched routes, or `null` if no matches were found.
*/
824declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
825interface 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. This might
   * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
   * an error and we're currently displaying an `ErrorBoundary`.
   *
   * @deprecated Use `UIMatch.loaderData` instead
   */
  data: Data | undefined;
  /**
   * The return value from the matched route's loader or clientLoader. This might
   * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
   * an error and we're currently displaying an `ErrorBoundary`.
   */
  loaderData: Data | undefined;
  /**
   * The {@link https://reactrouter.com/start/framework/route-module#handle handle object}
   * exported from the matched route module
   */
  handle: Handle;
851}
852/**
* Returns a path with params interpolated.
*
* @example
* import { generatePath } from "react-router";
*
* generatePath("/users/:id", { id: "123" }); // "/users/123"
*
* @public
* @category Utils
* @param originalPath The original path to generate.
* @param params The parameters to interpolate into the path.
* @returns The generated path with parameters interpolated.
*/
866declare function generatePath<Path extends string>(originalPath: Path, params?: {
  [key in PathParam<Path>]: string | null;
868}): string;
869/**
* Used to match on some portion of a URL pathname.
*/
872interface PathPattern<Path extends string = string> {
  /**
   * A string to match against a URL pathname. May contain `:id`-style segments
   * to indicate placeholders for dynamic parameters. It 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;
888}
889/**
* Contains info about how a {@link PathPattern} matched on a URL pathname.
*/
892interface 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;
909}
910/**
* Performs pattern matching on a URL pathname and returns information about
* the match.
*
* @public
* @category Utils
* @param pattern The pattern to match against the URL pathname. This can be a
* string or a {@link PathPattern} object. If a string is provided, it will be
* treated as a pattern with `caseSensitive` set to `false` and `end` set to
* `true`.
* @param pathname The URL pathname to match against the pattern.
* @returns A path match object if the pattern matches the pathname,
* or `null` if it does not match.
*/
924declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
925/**
* Returns a resolved {@link Path} object relative to the given pathname.
*
* @public
* @category Utils
* @param to The path to resolve, either a string or a partial {@link Path}
* object.
* @param fromPathname The pathname to resolve the path from. Defaults to `/`.
* @returns A {@link Path} object with the resolved pathname, search, and hash.
*/
935declare function resolvePath(to: To, fromPathname?: string): Path;
936declare class DataWithResponseInit<D> {
  type: string;
  data: D;
  init: ResponseInit | null;
  constructor(data: D, init?: ResponseInit);
941}
942/**
* Create "responses" that contain `headers`/`status` without forcing
* serialization into an actual [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
*
* @example
* import { data } from "react-router";
*
* export async function action({ request }: Route.ActionArgs) {
*   let formData = await request.formData();
*   let item = await createItem(formData);
*   return data(item, {
*     headers: { "X-Custom-Header": "value" }
*     status: 201,
*   });
* }
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param data The data to be included in the response.
* @param init The status code or a `ResponseInit` object to be included in the
* response.
* @returns A {@link DataWithResponseInit} instance containing the data and
* response init.
*/
968declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
969interface TrackedPromise extends Promise<any> {
  _tracked?: boolean;
  _data?: any;
  _error?: any;
973}
974type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
975/**
* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
* Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
*
* @example
* import { redirect } from "react-router";
*
* export async function loader({ request }: Route.LoaderArgs) {
*   if (!isLoggedIn(request))
*     throw redirect("/login");
*   }
*
*   // ...
* }
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param url The URL to redirect to.
* @param init The status code or a `ResponseInit` object to be included in the
* response.
* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header.
*/
1002declare const redirect: RedirectFunction;
1003/**
* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* that will force a document reload to the new location. Sets the status code
* and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
*
* ```tsx filename=routes/logout.tsx
* import { redirectDocument } from "react-router";
*
* import { destroySession } from "../sessions.server";
*
* export async function action({ request }: Route.ActionArgs) {
*   let session = await getSession(request.headers.get("Cookie"));
*   return redirectDocument("/", {
*     headers: { "Set-Cookie": await destroySession(session) }
*   });
* }
* ```
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param url The URL to redirect to.
* @param init The status code or a `ResponseInit` object to be included in the
* response.
* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header.
*/
1033declare const redirectDocument: RedirectFunction;
1034/**
* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* that will perform a [`history.replaceState`](https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState)
* instead of a [`history.pushState`](https://developer.mozilla.org/en-US/docs/Web/API/History/pushState)
* for client-side navigation redirects. Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
*
* @example
* import { replace } from "react-router";
*
* export async function loader() {
*   return replace("/new-location");
* }
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param url The URL to redirect to.
* @param init The status code or a `ResponseInit` object to be included in the
* response.
* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header.
*/
1059declare const replace: RedirectFunction;
1060type ErrorResponse = {
  status: number;
  statusText: string;
  data: any;
1064};
1065declare class ErrorResponseImpl implements ErrorResponse {
  status: number;
  statusText: string;
  data: any;
  private error?;
  private internal;
  constructor(status: number, statusText: string | undefined, data: any, internal?: boolean);
1072}
1073/**
* Check if the given error is an {@link ErrorResponse} generated from a 4xx/5xx
* [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* thrown from an [`action`](../../start/framework/route-module#action) or
* [`loader`](../../start/framework/route-module#loader) function.
*
* @example
* import { isRouteErrorResponse } from "react-router";
*
* export function ErrorBoundary({ error }: Route.ErrorBoundaryProps) {
*   if (isRouteErrorResponse(error)) {
*     return (
*       <>
*         <p>Error: `${error.status}: ${error.statusText}`</p>
*         <p>{error.data}</p>
*       </>
*     );
*   }
*
*   return (
*     <p>Error: {error instanceof Error ? error.message : "Unknown Error"}</p>
*   );
* }
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param error The error to check.
* @returns `true` if the error is an {@link ErrorResponse}, `false` otherwise.
*/
1104declare function isRouteErrorResponse(error: any): error is ErrorResponse;
1105
1106/**
* 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
*/
1112interface AppLoadContext {
  [key: string]: unknown;
1114}
1115
1116/**
* A Router instance manages all navigation and data loading/mutations
*/
1119interface 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;
  /**
   * @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>;
  /**
   * @internal
   * PRIVATE - DO NOT USE
   *
   * Reset the fetcher for a given key
   * @param key
   */
  resetFetcher(key: string, opts?: {
      reason?: unknown;
  }): void;
  /**
   * @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
   * @param unstable_allowElementMutations Allow mutation or route elements on
   *                                       existing routes. Intended for RSC-usage
   *                                       only.
   */
  patchRoutes(routeId: string | null, children: AgnosticRouteObject[], unstable_allowElementMutations?: boolean): 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
   *
   * Cause subscribers to re-render.  This is used to force a re-render.
   */
  _internalSetStateDoNotUseOrYouWillBreakYourApp(state: Partial<RouterState>): void;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Internal fetch AbortControllers accessed by unit tests
   */
  _internalFetchControllers: Map<string, AbortController>;
1320}
1321/**
* State maintained internally by the router.  During a navigation, all states
* reflect the "old" location unless otherwise noted.
*/
1325interface 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/revalidations)
   *  - null -> don't have a saved position, scroll to hash or top of page
   */
  restoreScrollPosition: number | false | null;
  /**
   * Indicate whether this navigation should skip resetting the scroll position
   * if we are unable to restore the scroll position
   */
  preventScrollReset: boolean;
  /**
   * Tracks the state of the current navigation
   */
  navigation: Navigation;
  /**
   * Tracks any in-progress revalidations
   */
  revalidation: RevalidationState;
  /**
   * Data from the loaders for the current matches
   */
  loaderData: RouteData;
  /**
   * Data from the action for the current matches
   */
  actionData: RouteData | null;
  /**
   * Errors caught from loaders for the current matches
   */
  errors: RouteData | null;
  /**
   * Map of current fetchers
   */
  fetchers: Map<string, Fetcher>;
  /**
   * Map of current blockers
   */
  blockers: Map<string, Blocker>;
1382}
1383/**
* Data that can be passed into hydrate a Router from SSR
*/
1386type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
1387/**
* Future flags to toggle new feature behavior
*/
1390interface FutureConfig {
1391}
1392/**
* Initialization options for createRouter
*/
1395interface RouterInit {
  routes: AgnosticRouteObject[];
  history: History;
  basename?: string;
  getContext?: () => MaybePromise<RouterContextProvider>;
  unstable_instrumentations?: unstable_ClientInstrumentation[];
  mapRouteProperties?: MapRoutePropertiesFunction;
  future?: Partial<FutureConfig>;
  hydrationRouteProperties?: string[];
  hydrationData?: HydrationState;
  window?: Window;
  dataStrategy?: DataStrategyFunction;
  patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;
1408}
1409/**
* State returned from a server-side query() call
*/
1412interface 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;
1423}
1424/**
* A StaticHandler instance manages a singular SSR navigation/fetch event
*/
1427interface StaticHandler {
  dataRoutes: AgnosticDataRouteObject[];
  query(request: Request, opts?: {
      requestContext?: unknown;
      filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
      skipLoaderErrorBubbling?: boolean;
      skipRevalidation?: boolean;
      dataStrategy?: DataStrategyFunction<unknown>;
      generateMiddlewareResponse?: (query: (r: Request, args?: {
          filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
      }) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
  }): Promise<StaticHandlerContext | Response>;
  queryRoute(request: Request, opts?: {
      routeId?: string;
      requestContext?: unknown;
      dataStrategy?: DataStrategyFunction<unknown>;
      generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>;
  }): Promise<any>;
1445}
1446type ViewTransitionOpts = {
  currentLocation: Location;
  nextLocation: Location;
1449};
1450/**
* Subscriber function signature for changes to router state
*/
1453interface RouterSubscriber {
  (state: RouterState, opts: {
      deletedFetchers: string[];
      newErrors: RouteData | null;
      viewTransitionOpts?: ViewTransitionOpts;
      flushSync: boolean;
  }): void;
1460}
1461/**
* Function signature for determining the key to be used in scroll restoration
* for a given location
*/
1465interface GetScrollRestorationKeyFunction {
  (location: Location, matches: UIMatch[]): string | null;
1467}
1468/**
* Function signature for determining the current scroll position
*/
1471interface GetScrollPositionFunction {
  (): number;
1473}
1474/**
* - "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.
*/
1482type RelativeRoutingType = "route" | "path";
1483type BaseNavigateOrFetchOptions = {
  preventScrollReset?: boolean;
  relative?: RelativeRoutingType;
  flushSync?: boolean;
  unstable_defaultShouldRevalidate?: boolean;
1488};
1489type BaseNavigateOptions = BaseNavigateOrFetchOptions & {
  replace?: boolean;
  state?: any;
  fromRouteId?: string;
  viewTransition?: boolean;
1494};
1495type BaseSubmissionOptions = {
  formMethod?: HTMLFormMethod;
  formEncType?: FormEncType;
1498} & ({
  formData: FormData;
  body?: undefined;
1501} | {
  formData?: undefined;
  body: any;
1504});
1505/**
* Options for a navigate() call for a normal (non-submission) navigation
*/
1508type LinkNavigateOptions = BaseNavigateOptions;
1509/**
* Options for a navigate() call for a submission navigation
*/
1512type SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;
1513/**
* Options to pass to navigate() for a navigation
*/
1516type RouterNavigateOptions = LinkNavigateOptions | SubmissionNavigateOptions;
1517/**
* Options for a fetch() load
*/
1520type LoadFetchOptions = BaseNavigateOrFetchOptions;
1521/**
* Options for a fetch() submission
*/
1524type SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;
1525/**
* Options to pass to fetch()
*/
1528type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;
1529/**
* Potential states for state.navigation
*/
1532type 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"];
  };
1563};
1564type Navigation = NavigationStates[keyof NavigationStates];
1565type RevalidationState = "idle" | "loading";
1566/**
* Potential states for fetchers
*/
1569type 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;
  };
1640};
1641type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
1642interface BlockerBlocked {
  state: "blocked";
  reset: () => void;
  proceed: () => void;
  location: Location;
1647}
1648interface BlockerUnblocked {
  state: "unblocked";
  reset: undefined;
  proceed: undefined;
  location: undefined;
1653}
1654interface BlockerProceeding {
  state: "proceeding";
  reset: undefined;
  proceed: undefined;
  location: Location;
1659}
1660type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
1661type BlockerFunction = (args: {
  currentLocation: Location;
  nextLocation: Location;
  historyAction: Action;
1665}) => boolean;
1666declare const IDLE_NAVIGATION: NavigationStates["Idle"];
1667declare const IDLE_FETCHER: FetcherStates["Idle"];
1668declare const IDLE_BLOCKER: BlockerUnblocked;
1669/**
* Create a router and listen to history POP navigations
*/
1672declare function createRouter(init: RouterInit): Router$1;
1673interface CreateStaticHandlerOptions {
  basename?: string;
  mapRouteProperties?: MapRoutePropertiesFunction;
  unstable_instrumentations?: Pick<unstable_ServerInstrumentation, "route">[];
  future?: {};
1678}
1679
1680declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
  hasErrorBoundary: boolean;
1682};
1683declare const hydrationRouteProperties: (keyof RouteObject)[];
1684/**
* @category Data Routers
*/
1687interface MemoryRouterOpts {
  /**
   * Basename path for the application.
   */
  basename?: string;
  /**
   * A function that returns an {@link RouterContextProvider} instance
   * which is provided as the `context` argument to client [`action`](../../start/data/route-object#action)s,
   * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
   * This function is called to generate a fresh `context` instance on each
   * navigation or fetcher call.
   */
  getContext?: RouterInit["getContext"];
  /**
   * Future flags to enable for the router.
   */
  future?: Partial<FutureConfig>;
  /**
   * Hydration data to initialize the router with if you have already performed
   * data loading on the server.
   */
  hydrationData?: HydrationState;
  /**
   * Initial entries in the in-memory history stack
   */
  initialEntries?: InitialEntry[];
  /**
   * Index of `initialEntries` the application should initialize to
   */
  initialIndex?: number;
  /**
   * Array of instrumentation objects allowing you to instrument the router and
   * individual routes prior to router initialization (and on any subsequently
   * added routes via `route.lazy` or `patchRoutesOnNavigation`).  This is
   * mostly useful for observability such as wrapping navigations, fetches,
   * as well as route loaders/actions/middlewares with logging and/or performance
   * tracing.  See the [docs](../../how-to/instrumentation) for more information.
   *
   * ```tsx
   * let router = createBrowserRouter(routes, {
   *   unstable_instrumentations: [logging]
   * });
   *
   *
   * let logging = {
   *   router({ instrument }) {
   *     instrument({
   *       navigate: (impl, info) => logExecution(`navigate ${info.to}`, impl),
   *       fetch: (impl, info) => logExecution(`fetch ${info.to}`, impl)
   *     });
   *   },
   *   route({ instrument, id }) {
   *     instrument({
   *       middleware: (impl, info) => logExecution(
   *         `middleware ${info.request.url} (route ${id})`,
   *         impl
   *       ),
   *       loader: (impl, info) => logExecution(
   *         `loader ${info.request.url} (route ${id})`,
   *         impl
   *       ),
   *       action: (impl, info) => logExecution(
   *         `action ${info.request.url} (route ${id})`,
   *         impl
   *       ),
   *     })
   *   }
   * };
   *
   * async function logExecution(label: string, impl: () => Promise<void>) {
   *   let start = performance.now();
   *   console.log(`start ${label}`);
   *   await impl();
   *   let duration = Math.round(performance.now() - start);
   *   console.log(`end ${label} (${duration}ms)`);
   * }
   * ```
   */
  unstable_instrumentations?: unstable_ClientInstrumentation[];
  /**
   * Override the default data strategy of running loaders in parallel -
   * see the [docs](../../how-to/data-strategy) for more information.
   *
   * ```tsx
   * let router = createBrowserRouter(routes, {
   *   async dataStrategy({
   *     matches,
   *     request,
   *     runClientMiddleware,
   *   }) {
   *     const matchesToLoad = matches.filter((m) =>
   *       m.shouldCallHandler(),
   *     );
   *
   *     const results: Record<string, DataStrategyResult> = {};
   *     await runClientMiddleware(() =>
   *       Promise.all(
   *         matchesToLoad.map(async (match) => {
   *           results[match.route.id] = await match.resolve();
   *         }),
   *       ),
   *     );
   *     return results;
   *   },
   * });
   * ```
   */
  dataStrategy?: DataStrategyFunction;
  /**
   * Lazily define portions of the route tree on navigations.
   */
  patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
1799}
1800/**
* Create a new {@link DataRouter} that manages the application path using an
* in-memory [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
* stack. Useful for non-browser environments without a DOM API.
*
* @public
* @category Data Routers
* @mode data
* @param routes Application routes
* @param opts Options
* @param {MemoryRouterOpts.basename} opts.basename n/a
* @param {MemoryRouterOpts.dataStrategy} opts.dataStrategy n/a
* @param {MemoryRouterOpts.future} opts.future n/a
* @param {MemoryRouterOpts.getContext} opts.getContext n/a
* @param {MemoryRouterOpts.hydrationData} opts.hydrationData n/a
* @param {MemoryRouterOpts.initialEntries} opts.initialEntries n/a
* @param {MemoryRouterOpts.initialIndex} opts.initialIndex n/a
* @param {MemoryRouterOpts.unstable_instrumentations} opts.unstable_instrumentations n/a
* @param {MemoryRouterOpts.patchRoutesOnNavigation} opts.patchRoutesOnNavigation n/a
* @returns An initialized {@link DataRouter} to pass to {@link RouterProvider | `<RouterProvider>`}
*/
1821declare function createMemoryRouter(routes: RouteObject[], opts?: MemoryRouterOpts): Router$1;
1822/**
* Function signature for client side error handling for loader/actions errors
* and rendering errors via `componentDidCatch`
*/
1826interface ClientOnErrorFunction {
  (error: unknown, info: {
      location: Location;
      params: Params;
      unstable_pattern: string;
      errorInfo?: React.ErrorInfo;
  }): void;
1833}
1834/**
* @category Types
*/
1837interface RouterProviderProps {
  /**
   * The {@link DataRouter} instance to use for navigation and data fetching.
   */
  router: Router$1;
  /**
   * The [`ReactDOM.flushSync`](https://react.dev/reference/react-dom/flushSync)
   * implementation to use for flushing updates.
   *
   * You usually don't have to worry about this:
   * - The `RouterProvider` exported from `react-router/dom` handles this internally for you
   * - If you are rendering in a non-DOM environment, you can import
   *   `RouterProvider` from `react-router` and ignore this prop
   */
  flushSync?: (fn: () => unknown) => undefined;
  /**
   * An error handler function that will be called for any middleware, loader, action,
   * or render errors that are encountered in your application.  This is useful for
   * logging or reporting errors instead of in the {@link ErrorBoundary} because it's not
   * subject to re-rendering and will only run one time per error.
   *
   * The `errorInfo` parameter is passed along from
   * [`componentDidCatch`](https://react.dev/reference/react/Component#componentdidcatch)
   * and is only present for render errors.
   *
   * ```tsx
   * <RouterProvider onError=(error, info) => {
   *   let { location, params, unstable_pattern, errorInfo } = info;
   *   console.error(error, location, errorInfo);
   *   reportToErrorService(error, location, errorInfo);
   * }} />
   * ```
   */
  onError?: ClientOnErrorFunction;
  /**
   * Control whether router state updates are internally wrapped in
   * [`React.startTransition`](https://react.dev/reference/react/startTransition).
   *
   * - When left `undefined`, all state updates are wrapped in
   *   `React.startTransition`
   *   - This can lead to buggy behaviors if you are wrapping your own
   *     navigations/fetchers in `startTransition`.
   * - When set to `true`, {@link Link} and {@link Form} navigations will be wrapped
   *   in `React.startTransition` and router state changes will be wrapped in
   *   `React.startTransition` and also sent through
   *   [`useOptimistic`](https://react.dev/reference/react/useOptimistic) to
   *   surface mid-navigation router state changes to the UI.
   * - When set to `false`, the router will not leverage `React.startTransition` or
   *   `React.useOptimistic` on any navigations or state changes.
   *
   * For more information, please see the [docs](https://reactrouter.com/explanation/react-transitions).
   */
  unstable_useTransitions?: boolean;
1890}
1891/**
* Render the UI for the given {@link DataRouter}. This component should
* typically be at the top of an app's element tree.
*
* ```tsx
* import { createBrowserRouter } from "react-router";
* import { RouterProvider } from "react-router/dom";
* import { createRoot } from "react-dom/client";
*
* const router = createBrowserRouter(routes);
* createRoot(document.getElementById("root")).render(
*   <RouterProvider router={router} />
* );
* ```
*
* <docs-info>Please note that this component is exported both from
* `react-router` and `react-router/dom` with the only difference being that the
* latter automatically wires up `react-dom`'s [`flushSync`](https://react.dev/reference/react-dom/flushSync)
* implementation. You _almost always_ want to use the version from
* `react-router/dom` unless you're running in a non-DOM environment.</docs-info>
*
*
* @public
* @category Data Routers
* @mode data
* @param props Props
* @param {RouterProviderProps.flushSync} props.flushSync n/a
* @param {RouterProviderProps.onError} props.onError n/a
* @param {RouterProviderProps.router} props.router n/a
* @param {RouterProviderProps.unstable_useTransitions} props.unstable_useTransitions n/a
* @returns React element for the rendered router
*/
1923declare function RouterProvider({ router, flushSync: reactDomFlushSyncImpl, onError, unstable_useTransitions, }: RouterProviderProps): React.ReactElement;
1924/**
* @category Types
*/
1927interface MemoryRouterProps {
  /**
   * Application basename
   */
  basename?: string;
  /**
   * Nested {@link Route} elements describing the route tree
   */
  children?: React.ReactNode;
  /**
   * Initial entries in the in-memory history stack
   */
  initialEntries?: InitialEntry[];
  /**
   * Index of `initialEntries` the application should initialize to
   */
  initialIndex?: number;
  /**
   * Control whether router state updates are internally wrapped in
   * [`React.startTransition`](https://react.dev/reference/react/startTransition).
   *
   * - When left `undefined`, all router state updates are wrapped in
   *   `React.startTransition`
   * - When set to `true`, {@link Link} and {@link Form} navigations will be wrapped
   *   in `React.startTransition` and all router state updates are wrapped in
   *   `React.startTransition`
   * - When set to `false`, the router will not leverage `React.startTransition`
   *   on any navigations or state changes.
   *
   * For more information, please see the [docs](https://reactrouter.com/explanation/react-transitions).
   */
  unstable_useTransitions?: boolean;
1959}
1960/**
* A declarative {@link Router | `<Router>`} that stores all entries in memory.
*
* @public
* @category Declarative Routers
* @mode declarative
* @param props Props
* @param {MemoryRouterProps.basename} props.basename n/a
* @param {MemoryRouterProps.children} props.children n/a
* @param {MemoryRouterProps.initialEntries} props.initialEntries n/a
* @param {MemoryRouterProps.initialIndex} props.initialIndex n/a
* @param {MemoryRouterProps.unstable_useTransitions} props.unstable_useTransitions n/a
* @returns A declarative in-memory {@link Router | `<Router>`} for client-side
* routing.
*/
1975declare function MemoryRouter({ basename, children, initialEntries, initialIndex, unstable_useTransitions, }: MemoryRouterProps): React.ReactElement;
1976/**
* @category Types
*/
1979interface NavigateProps {
  /**
   * The path to navigate to. This can be a string or a {@link Path} object
   */
  to: To;
  /**
   * Whether to replace the current entry in the [`History`](https://developer.mozilla.org/en-US/docs/Web/API/History)
   * stack
   */
  replace?: boolean;
  /**
   * State to pass to the new {@link Location} to store in [`history.state`](https://developer.mozilla.org/en-US/docs/Web/API/History/state).
   */
  state?: any;
  /**
   * How to interpret relative routing in the `to` prop.
   * See {@link RelativeRoutingType}.
   */
  relative?: RelativeRoutingType;
1998}
1999/**
* A component-based version of {@link useNavigate} to use in a
* [`React.Component` class](https://react.dev/reference/react/Component) where
* hooks cannot be used.
*
* It's recommended to avoid using this component in favor of {@link useNavigate}.
*
* @example
* <Navigate to="/tasks" />
*
* @public
* @category Components
* @param props Props
* @param {NavigateProps.relative} props.relative n/a
* @param {NavigateProps.replace} props.replace n/a
* @param {NavigateProps.state} props.state n/a
* @param {NavigateProps.to} props.to n/a
* @returns {void}
*
*/
2019declare function Navigate({ to, replace, state, relative, }: NavigateProps): null;
2020/**
* @category Types
*/
2023interface 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;
2035}
2036/**
* Renders the matching child route of a parent route or nothing if no child
* route matches.
*
* @example
* import { Outlet } from "react-router";
*
* export default function SomeParent() {
*   return (
*     <div>
*       <h1>Parent Content</h1>
*       <Outlet />
*     </div>
*   );
* }
*
* @public
* @category Components
* @param props Props
* @param {OutletProps.context} props.context n/a
* @returns React element for the rendered outlet or `null` if no child route matches.
*/
2058declare function Outlet(props: OutletProps): React.ReactElement | null;
2059/**
* @category Types
*/
2062interface PathRouteProps {
  /**
   * Whether the path should be case-sensitive. Defaults to `false`.
   */
  caseSensitive?: NonIndexRouteObject["caseSensitive"];
  /**
   * The path pattern to match. If unspecified or empty, then this becomes a
   * layout route.
   */
  path?: NonIndexRouteObject["path"];
  /**
   * The unique identifier for this route (for use with {@link DataRouter}s)
   */
  id?: NonIndexRouteObject["id"];
  /**
   * A function that returns a promise that resolves to the route object.
   * Used for code-splitting routes.
   * See [`lazy`](../../start/data/route-object#lazy).
   */
  lazy?: LazyRouteFunction<NonIndexRouteObject>;
  /**
   * The route middleware.
   * See [`middleware`](../../start/data/route-object#middleware).
   */
  middleware?: NonIndexRouteObject["middleware"];
  /**
   * The route loader.
   * See [`loader`](../../start/data/route-object#loader).
   */
  loader?: NonIndexRouteObject["loader"];
  /**
   * The route action.
   * See [`action`](../../start/data/route-object#action).
   */
  action?: NonIndexRouteObject["action"];
  hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"];
  /**
   * The route shouldRevalidate function.
   * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
   */
  shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"];
  /**
   * The route handle.
   */
  handle?: NonIndexRouteObject["handle"];
  /**
   * Whether this is an index route.
   */
  index?: false;
  /**
   * Child Route components
   */
  children?: React.ReactNode;
  /**
   * The React element to render when this Route matches.
   * Mutually exclusive with `Component`.
   */
  element?: React.ReactNode | null;
  /**
   * The React element to render while this router is loading data.
   * Mutually exclusive with `HydrateFallback`.
   */
  hydrateFallbackElement?: React.ReactNode | null;
  /**
   * The React element to render at this route if an error occurs.
   * Mutually exclusive with `ErrorBoundary`.
   */
  errorElement?: React.ReactNode | null;
  /**
   * The React Component to render when this route matches.
   * Mutually exclusive with `element`.
   */
  Component?: React.ComponentType | null;
  /**
   * The React Component to render while this router is loading data.
   * Mutually exclusive with `hydrateFallbackElement`.
   */
  HydrateFallback?: React.ComponentType | null;
  /**
   * The React Component to render at this route if an error occurs.
   * Mutually exclusive with `errorElement`.
   */
  ErrorBoundary?: React.ComponentType | null;
2145}
2146/**
* @category Types
*/
2149interface LayoutRouteProps extends PathRouteProps {
2150}
2151/**
* @category Types
*/
2154interface IndexRouteProps {
  /**
   * Whether the path should be case-sensitive. Defaults to `false`.
   */
  caseSensitive?: IndexRouteObject["caseSensitive"];
  /**
   * The path pattern to match. If unspecified or empty, then this becomes a
   * layout route.
   */
  path?: IndexRouteObject["path"];
  /**
   * The unique identifier for this route (for use with {@link DataRouter}s)
   */
  id?: IndexRouteObject["id"];
  /**
   * A function that returns a promise that resolves to the route object.
   * Used for code-splitting routes.
   * See [`lazy`](../../start/data/route-object#lazy).
   */
  lazy?: LazyRouteFunction<IndexRouteObject>;
  /**
   * The route middleware.
   * See [`middleware`](../../start/data/route-object#middleware).
   */
  middleware?: IndexRouteObject["middleware"];
  /**
   * The route loader.
   * See [`loader`](../../start/data/route-object#loader).
   */
  loader?: IndexRouteObject["loader"];
  /**
   * The route action.
   * See [`action`](../../start/data/route-object#action).
   */
  action?: IndexRouteObject["action"];
  hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"];
  /**
   * The route shouldRevalidate function.
   * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
   */
  shouldRevalidate?: IndexRouteObject["shouldRevalidate"];
  /**
   * The route handle.
   */
  handle?: IndexRouteObject["handle"];
  /**
   * Whether this is an index route.
   */
  index: true;
  /**
   * Child Route components
   */
  children?: undefined;
  /**
   * The React element to render when this Route matches.
   * Mutually exclusive with `Component`.
   */
  element?: React.ReactNode | null;
  /**
   * The React element to render while this router is loading data.
   * Mutually exclusive with `HydrateFallback`.
   */
  hydrateFallbackElement?: React.ReactNode | null;
  /**
   * The React element to render at this route if an error occurs.
   * Mutually exclusive with `ErrorBoundary`.
   */
  errorElement?: React.ReactNode | null;
  /**
   * The React Component to render when this route matches.
   * Mutually exclusive with `element`.
   */
  Component?: React.ComponentType | null;
  /**
   * The React Component to render while this router is loading data.
   * Mutually exclusive with `hydrateFallbackElement`.
   */
  HydrateFallback?: React.ComponentType | null;
  /**
   * The React Component to render at this route if an error occurs.
   * Mutually exclusive with `errorElement`.
   */
  ErrorBoundary?: React.ComponentType | null;
2237}
2238type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;
2239/**
* Configures an element to render when a pattern matches the current location.
* It must be rendered within a {@link Routes} element. Note that these routes
* do not participate in data loading, actions, code splitting, or any other
* route module features.
*
* @example
* // Usually used in a declarative router
* function App() {
*   return (
*     <BrowserRouter>
*       <Routes>
*         <Route index element={<StepOne />} />
*         <Route path="step-2" element={<StepTwo />} />
*         <Route path="step-3" element={<StepThree />} />
*       </Routes>
*    </BrowserRouter>
*   );
* }
*
* // But can be used with a data router as well if you prefer the JSX notation
* const routes = createRoutesFromElements(
*   <>
*     <Route index loader={step1Loader} Component={StepOne} />
*     <Route path="step-2" loader={step2Loader} Component={StepTwo} />
*     <Route path="step-3" loader={step3Loader} Component={StepThree} />
*   </>
* );
*
* const router = createBrowserRouter(routes);
*
* function App() {
*   return <RouterProvider router={router} />;
* }
*
* @public
* @category Components
* @param props Props
* @param {PathRouteProps.action} props.action n/a
* @param {PathRouteProps.caseSensitive} props.caseSensitive n/a
* @param {PathRouteProps.Component} props.Component n/a
* @param {PathRouteProps.children} props.children n/a
* @param {PathRouteProps.element} props.element n/a
* @param {PathRouteProps.ErrorBoundary} props.ErrorBoundary n/a
* @param {PathRouteProps.errorElement} props.errorElement n/a
* @param {PathRouteProps.handle} props.handle n/a
* @param {PathRouteProps.HydrateFallback} props.HydrateFallback n/a
* @param {PathRouteProps.hydrateFallbackElement} props.hydrateFallbackElement n/a
* @param {PathRouteProps.id} props.id n/a
* @param {PathRouteProps.index} props.index n/a
* @param {PathRouteProps.lazy} props.lazy n/a
* @param {PathRouteProps.loader} props.loader n/a
* @param {PathRouteProps.path} props.path n/a
* @param {PathRouteProps.shouldRevalidate} props.shouldRevalidate n/a
* @returns {void}
*/
2295declare function Route(props: RouteProps): React.ReactElement | null;
2296/**
* @category Types
*/
2299interface RouterProps {
  /**
   * The base path for the application. This is prepended to all locations
   */
  basename?: string;
  /**
   * Nested {@link Route} elements describing the route tree
   */
  children?: React.ReactNode;
  /**
   * The location to match against. Defaults to the current location.
   * This can be a string or a {@link Location} object.
   */
  location: Partial<Location> | string;
  /**
   * The type of navigation that triggered this `location` change.
   * Defaults to {@link NavigationType.Pop}.
   */
  navigationType?: Action;
  /**
   * The navigator to use for navigation. This is usually a history object
   * or a custom navigator that implements the {@link Navigator} interface.
   */
  navigator: Navigator;
  /**
   * Whether this router is static or not (used for SSR). If `true`, the router
   * will not be reactive to location changes.
   */
  static?: boolean;
  /**
   * Control whether router state updates are internally wrapped in
   * [`React.startTransition`](https://react.dev/reference/react/startTransition).
   *
   * - When left `undefined`, all router state updates are wrapped in
   *   `React.startTransition`
   * - When set to `true`, {@link Link} and {@link Form} navigations will be wrapped
   *   in `React.startTransition` and all router state updates are wrapped in
   *   `React.startTransition`
   * - When set to `false`, the router will not leverage `React.startTransition`
   *   on any navigations or state changes.
   *
   * For more information, please see the [docs](https://reactrouter.com/explanation/react-transitions).
   */
  unstable_useTransitions?: boolean;
2343}
2344/**
* Provides location context for the rest of the app.
*
* Note: You usually won't render a `<Router>` directly. Instead, you'll render a
* router that is more specific to your environment such as a {@link BrowserRouter}
* in web browsers or a {@link ServerRouter} for server rendering.
*
* @public
* @category Declarative Routers
* @mode declarative
* @param props Props
* @param {RouterProps.basename} props.basename n/a
* @param {RouterProps.children} props.children n/a
* @param {RouterProps.location} props.location n/a
* @param {RouterProps.navigationType} props.navigationType n/a
* @param {RouterProps.navigator} props.navigator n/a
* @param {RouterProps.static} props.static n/a
* @param {RouterProps.unstable_useTransitions} props.unstable_useTransitions n/a
* @returns React element for the rendered router or `null` if the location does
* not match the {@link props.basename}
*/
2365declare function Router({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, unstable_useTransitions, }: RouterProps): React.ReactElement | null;
2366/**
* @category Types
*/
2369interface RoutesProps {
  /**
   * Nested {@link Route} elements
   */
  children?: React.ReactNode;
  /**
   * The {@link Location} to match against. Defaults to the current location.
   */
  location?: Partial<Location> | string;
2378}
2379/**
* Renders a branch of {@link Route | `<Route>`s} that best matches the current
* location. Note that these routes do not participate in [data loading](../../start/framework/route-module#loader),
* [`action`](../../start/framework/route-module#action), code splitting, or
* any other [route module](../../start/framework/route-module) features.
*
* @example
* import { Route, Routes } from "react-router";
*
* <Routes>
*   <Route index element={<StepOne />} />
*   <Route path="step-2" element={<StepTwo />} />
*   <Route path="step-3" element={<StepThree />} />
* </Routes>
*
* @public
* @category Components
* @param props Props
* @param {RoutesProps.children} props.children n/a
* @param {RoutesProps.location} props.location n/a
* @returns React element for the rendered routes or `null` if no route matches
*/
2401declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
2402interface AwaitResolveRenderFunction<Resolve = any> {
  (data: Awaited<Resolve>): React.ReactNode;
2404}
2405/**
* @category Types
*/
2408interface AwaitProps<Resolve> {
  /**
   * When using a function, the resolved value is provided as the parameter.
   *
   * ```tsx [2]
   * <Await resolve={reviewsPromise}>
   *   {(resolvedReviews) => <Reviews items={resolvedReviews} />}
   * </Await>
   * ```
   *
   * When using React elements, {@link useAsyncValue} will provide the
   * resolved value:
   *
   * ```tsx [2]
   * <Await resolve={reviewsPromise}>
   *   <Reviews />
   * </Await>
   *
   * function Reviews() {
   *   const resolvedReviews = useAsyncValue();
   *   return <div>...</div>;
   * }
   * ```
   */
  children: React.ReactNode | AwaitResolveRenderFunction<Resolve>;
  /**
   * The error element renders instead of the `children` when the [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
   * rejects.
   *
   * ```tsx
   * <Await
   *   errorElement={<div>Oops</div>}
   *   resolve={reviewsPromise}
   * >
   *   <Reviews />
   * </Await>
   * ```
   *
   * To provide a more contextual error, you can use the {@link useAsyncError} in a
   * child component
   *
   * ```tsx
   * <Await
   *   errorElement={<ReviewsError />}
   *   resolve={reviewsPromise}
   * >
   *   <Reviews />
   * </Await>
   *
   * function ReviewsError() {
   *   const error = useAsyncError();
   *   return <div>Error loading reviews: {error.message}</div>;
   * }
   * ```
   *
   * If you do not provide an `errorElement`, the rejected value will bubble up
   * to the nearest route-level [`ErrorBoundary`](../../start/framework/route-module#errorboundary)
   * and be accessible via the {@link useRouteError} hook.
   */
  errorElement?: React.ReactNode;
  /**
   * Takes a [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
   * returned from a [`loader`](../../start/framework/route-module#loader) to be
   * resolved and rendered.
   *
   * ```tsx
   * import { Await, useLoaderData } from "react-router";
   *
   * export async function loader() {
   *   let reviews = getReviews(); // not awaited
   *   let book = await getBook();
   *   return {
   *     book,
   *     reviews, // this is a promise
   *   };
   * }
   *
   * export default function Book() {
   *   const {
   *     book,
   *     reviews, // this is the same promise
   *   } = useLoaderData();
   *
   *   return (
   *     <div>
   *       <h1>{book.title}</h1>
   *       <p>{book.description}</p>
   *       <React.Suspense fallback={<ReviewsSkeleton />}>
   *         <Await
   *           // and is the promise we pass to Await
   *           resolve={reviews}
   *         >
   *           <Reviews />
   *         </Await>
   *       </React.Suspense>
   *     </div>
   *   );
   * }
   * ```
   */
  resolve: Resolve;
2509}
2510/**
* Used to render promise values with automatic error handling.
*
* **Note:** `<Await>` expects to be rendered inside a [`<React.Suspense>`](https://react.dev/reference/react/Suspense)
*
* @example
* import { Await, useLoaderData } from "react-router";
*
* export async function loader() {
*   // not awaited
*   const reviews = getReviews();
*   // awaited (blocks the transition)
*   const book = await fetch("/api/book").then((res) => res.json());
*   return { book, reviews };
* }
*
* function Book() {
*   const { book, reviews } = useLoaderData();
*   return (
*     <div>
*       <h1>{book.title}</h1>
*       <p>{book.description}</p>
*       <React.Suspense fallback={<ReviewsSkeleton />}>
*         <Await
*           resolve={reviews}
*           errorElement={
*             <div>Could not load reviews 😬</div>
*           }
*           children={(resolvedReviews) => (
*             <Reviews items={resolvedReviews} />
*           )}
*         />
*       </React.Suspense>
*     </div>
*   );
* }
*
* @public
* @category Components
* @mode framework
* @mode data
* @param props Props
* @param {AwaitProps.children} props.children n/a
* @param {AwaitProps.errorElement} props.errorElement n/a
* @param {AwaitProps.resolve} props.resolve n/a
* @returns React element for the rendered awaited value
*/
2557declare function Await<Resolve>({ children, errorElement, resolve, }: AwaitProps<Resolve>): React.JSX.Element;
2558/**
* Creates a route config from a React "children" object, which is usually
* either a `<Route>` element or an array of them. Used internally by
* `<Routes>` to create a route config from its children.
*
* @category Utils
* @mode data
* @param children The React children to convert into a route config
* @param parentPath The path of the parent route, used to generate unique IDs.
* @returns An array of {@link RouteObject}s that can be used with a {@link DataRouter}
*/
2569declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[];
2570/**
* Create route objects from JSX elements instead of arrays of objects.
*
* @example
* const routes = createRoutesFromElements(
*   <>
*     <Route index loader={step1Loader} Component={StepOne} />
*     <Route path="step-2" loader={step2Loader} Component={StepTwo} />
*     <Route path="step-3" loader={step3Loader} Component={StepThree} />
*   </>
* );
*
* const router = createBrowserRouter(routes);
*
* function App() {
*   return <RouterProvider router={router} />;
* }
*
* @name createRoutesFromElements
* @public
* @category Utils
* @mode data
* @param children The React children to convert into a route config
* @param parentPath The path of the parent route, used to generate unique IDs.
* This is used for internal recursion and is not intended to be used by the
* application developer.
* @returns An array of {@link RouteObject}s that can be used with a {@link DataRouter}
*/
2598declare const createRoutesFromElements: typeof createRoutesFromChildren;
2599/**
* Renders the result of {@link matchRoutes} into a React element.
*
* @public
* @category Utils
* @param matches The array of {@link RouteMatch | route matches} to render
* @returns A React element that renders the matched routes or `null` if no matches
*/
2607declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
2608declare function useRouteComponentProps(): {
  params: Readonly<Params<string>>;
  loaderData: any;
  actionData: any;
  matches: UIMatch<unknown, unknown>[];
2613};
2614type RouteComponentProps = ReturnType<typeof useRouteComponentProps>;
2615type RouteComponentType = React.ComponentType<RouteComponentProps>;
2616declare function WithComponentProps({ children, }: {
  children: React.ReactElement;
2618}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
2619declare function withComponentProps(Component: RouteComponentType): () => React.ReactElement<{
  params: Readonly<Params<string>>;
  loaderData: any;
  actionData: any;
  matches: UIMatch<unknown, unknown>[];
2624}, string | React.JSXElementConstructor<any>>;
2625declare function useHydrateFallbackProps(): {
  params: Readonly<Params<string>>;
  loaderData: any;
  actionData: any;
2629};
2630type HydrateFallbackProps = ReturnType<typeof useHydrateFallbackProps>;
2631type HydrateFallbackType = React.ComponentType<HydrateFallbackProps>;
2632declare function WithHydrateFallbackProps({ children, }: {
  children: React.ReactElement;
2634}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
2635declare function withHydrateFallbackProps(HydrateFallback: HydrateFallbackType): () => React.ReactElement<{
  params: Readonly<Params<string>>;
  loaderData: any;
  actionData: any;
2639}, string | React.JSXElementConstructor<any>>;
2640declare function useErrorBoundaryProps(): {
  params: Readonly<Params<string>>;
  loaderData: any;
  actionData: any;
  error: unknown;
2645};
2646type ErrorBoundaryProps = ReturnType<typeof useErrorBoundaryProps>;
2647type ErrorBoundaryType = React.ComponentType<ErrorBoundaryProps>;
2648declare function WithErrorBoundaryProps({ children, }: {
  children: React.ReactElement;
2650}): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
2651declare function withErrorBoundaryProps(ErrorBoundary: ErrorBoundaryType): () => React.ReactElement<{
  params: Readonly<Params<string>>;
  loaderData: any;
  actionData: any;
  error: unknown;
2656}, string | React.JSXElementConstructor<any>>;
2657
2658interface IndexRouteObject {
  caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
  path?: AgnosticIndexRouteObject["path"];
  id?: AgnosticIndexRouteObject["id"];
  middleware?: AgnosticIndexRouteObject["middleware"];
  loader?: AgnosticIndexRouteObject["loader"];
  action?: AgnosticIndexRouteObject["action"];
  hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
  shouldRevalidate?: AgnosticIndexRouteObject["shouldRevalidate"];
  handle?: AgnosticIndexRouteObject["handle"];
  index: true;
  children?: undefined;
  element?: React.ReactNode | null;
  hydrateFallbackElement?: React.ReactNode | null;
  errorElement?: React.ReactNode | null;
  Component?: React.ComponentType | null;
  HydrateFallback?: React.ComponentType | null;
  ErrorBoundary?: React.ComponentType | null;
  lazy?: LazyRouteDefinition<RouteObject>;
2677}
2678interface NonIndexRouteObject {
  caseSensitive?: AgnosticNonIndexRouteObject["caseSensitive"];
  path?: AgnosticNonIndexRouteObject["path"];
  id?: AgnosticNonIndexRouteObject["id"];
  middleware?: AgnosticNonIndexRouteObject["middleware"];
  loader?: AgnosticNonIndexRouteObject["loader"];
  action?: AgnosticNonIndexRouteObject["action"];
  hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];
  shouldRevalidate?: AgnosticNonIndexRouteObject["shouldRevalidate"];
  handle?: AgnosticNonIndexRouteObject["handle"];
  index?: false;
  children?: RouteObject[];
  element?: React.ReactNode | null;
  hydrateFallbackElement?: React.ReactNode | null;
  errorElement?: React.ReactNode | null;
  Component?: React.ComponentType | null;
  HydrateFallback?: React.ComponentType | null;
  ErrorBoundary?: React.ComponentType | null;
  lazy?: LazyRouteDefinition<RouteObject>;
2697}
2698type RouteObject = IndexRouteObject | NonIndexRouteObject;
2699type DataRouteObject = RouteObject & {
  children?: DataRouteObject[];
  id: string;
2702};
2703interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {
2704}
2705interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
2706}
2707type PatchRoutesOnNavigationFunctionArgs = AgnosticPatchRoutesOnNavigationFunctionArgs<RouteObject, RouteMatch>;
2708type PatchRoutesOnNavigationFunction = AgnosticPatchRoutesOnNavigationFunction<RouteObject, RouteMatch>;
2709interface DataRouterContextObject extends Omit<NavigationContextObject, "future" | "unstable_useTransitions"> {
  router: Router$1;
  staticContext?: StaticHandlerContext;
  onError?: ClientOnErrorFunction;
2713}
2714declare const DataRouterContext: React.Context<DataRouterContextObject | null>;
2715declare const DataRouterStateContext: React.Context<RouterState | null>;
2716type ViewTransitionContextObject = {
  isTransitioning: false;
2718} | {
  isTransitioning: true;
  flushSync: boolean;
  currentLocation: Location;
  nextLocation: Location;
2723};
2724declare const ViewTransitionContext: React.Context<ViewTransitionContextObject>;
2725type FetchersContextObject = Map<string, any>;
2726declare const FetchersContext: React.Context<FetchersContextObject>;
2727declare const AwaitContext: React.Context<TrackedPromise | null>;
2728declare const AwaitContextProvider: (props: React.ComponentProps<typeof AwaitContext.Provider>) => React.FunctionComponentElement<React.ProviderProps<TrackedPromise | null>>;
2729interface 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;
  /** Specifies the default revalidation behavior after this submission */
  unstable_defaultShouldRevalidate?: boolean;
2744}
2745/**
* 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.
*/
2754interface 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;
2760}
2761interface NavigationContextObject {
  basename: string;
  navigator: Navigator;
  static: boolean;
  unstable_useTransitions: boolean | undefined;
  future: {};
2767}
2768declare const NavigationContext: React.Context<NavigationContextObject>;
2769interface LocationContextObject {
  location: Location;
  navigationType: Action;
2772}
2773declare const LocationContext: React.Context<LocationContextObject>;
2774interface RouteContextObject {
  outlet: React.ReactElement | null;
  matches: RouteMatch[];
  isDataRoute: boolean;
2778}
2779declare const RouteContext: React.Context<RouteContextObject>;
2780
2781type Primitive = null | undefined | string | number | boolean | symbol | bigint;
2782type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
2783interface 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;
2845}
2846interface 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;
2868}
2869/**
* Represents a `<link>` element.
*
* WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
*/
2874type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
  imageSizes?: never;
2876});
2877interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
  /**
   * A [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
   * attribute to render on the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
   * element
   */
  nonce?: string | undefined;
  /**
   * The absolute path of the page to prefetch, e.g. `/absolute/path`.
   */
  page: string;
2888}
2889type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
2890
2891type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
  [key: PropertyKey]: Serializable;
2893} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
2894
2895type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
2896type IsAny<T> = 0 extends 1 & T ? true : false;
2897type Func = (...args: any[]) => unknown;
2898type Pretty<T> = {
  [K in keyof T]: T[K];
2900} & {};
2901type Normalize<T> = _Normalize<UnionKeys<T>, T>;
2902type _Normalize<Key extends keyof any, T> = T extends infer U ? Pretty<{
  [K in Key as K extends keyof U ? undefined extends U[K] ? never : K : never]: K extends keyof U ? U[K] : never;
2904} & {
  [K in Key as K extends keyof U ? undefined extends U[K] ? K : never : never]?: K extends keyof U ? U[K] : never;
2906} & {
  [K in Key as K extends keyof U ? never : K]?: undefined;
2908}> : never;
2909type UnionKeys<T> = T extends any ? keyof T : never;
2910
2911type RouteModule$1 = {
  meta?: Func;
  links?: Func;
  headers?: Func;
  loader?: Func;
  clientLoader?: Func;
  action?: Func;
  clientAction?: Func;
  HydrateFallback?: Func;
  default?: Func;
  ErrorBoundary?: Func;
  [key: string]: unknown;
2923};
2924
2925/**
* 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.
*/
2931type unstable_SerializesTo<T> = {
  unstable__ReactRouter_SerializesTo: [T];
2933};
2934
2935type Serialize<T> = T extends unstable_SerializesTo<infer To> ? To : T extends Serializable ? T : T extends (...args: any[]) => unknown ? undefined : T extends Promise<infer U> ? Promise<Serialize<U>> : T extends Map<infer K, infer V> ? Map<Serialize<K>, Serialize<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Serialize<K>, Serialize<V>> : T extends Set<infer U> ? Set<Serialize<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? {
  [K in keyof T]: Serialize<T[K]>;
2937} : undefined;
2938type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
2939type DataFrom<T> = IsAny<T> extends true ? undefined : T extends Func ? VoidToUndefined<Awaited<ReturnType<T>>> : undefined;
2940type ClientData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? U : T;
2941type ServerData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? Serialize<U> : Serialize<T>;
2942type ServerDataFrom<T> = ServerData<DataFrom<T>>;
2943type ClientDataFrom<T> = ClientData<DataFrom<T>>;
2944type ClientDataFunctionArgs<Params> = {
  /**
   * A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the URL, the method, the "content-type" header, and the request body from the request.
   *
   * @note Because client data functions are called before a network request is made, the Request object does not include the headers which the browser automatically adds. React Router infers the "content-type" header from the enc-type of the form that performed the submission.
   **/
  request: Request;
  /**
   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
   * @example
   * // app/routes.ts
   * route("teams/:teamId", "./team.tsx"),
   *
   * // app/team.tsx
   * export function clientLoader({
   *   params,
   * }: Route.ClientLoaderArgs) {
   *   params.teamId;
   *   //        ^ string
   * }
   **/
  params: Params;
  /**
   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
   */
  unstable_pattern: string;
  /**
   * When `future.v8_middleware` is not enabled, this is undefined.
   *
   * When `future.v8_middleware` is enabled, this is an instance of
   * `RouterContextProvider` and can be used to access context values
   * from your route middlewares.  You may pass in initial context values in your
   * `<HydratedRouter getContext>` prop
   */
  context: Readonly<RouterContextProvider>;
2980};
2981type ServerDataFunctionArgs<Params> = {
  /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the url, method, headers (such as cookies), and request body from the request. */
  request: Request;
  /**
   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
   * @example
   * // app/routes.ts
   * route("teams/:teamId", "./team.tsx"),
   *
   * // app/team.tsx
   * export function loader({
   *   params,
   * }: Route.LoaderArgs) {
   *   params.teamId;
   *   //        ^ string
   * }
   **/
  params: Params;
  /**
   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
   */
  unstable_pattern: string;
  /**
   * Without `future.v8_middleware` enabled, this is the context passed in
   * to your server adapter's `getLoadContext` function. It's a way to bridge the
   * gap between the adapter's request/response API with your React Router app.
   * It is only applicable if you are using a custom server adapter.
   *
   * With `future.v8_middleware` enabled, this is an instance of
   * `RouterContextProvider` and can be used for type-safe access to
   * context value set in your route middlewares.  If you are using a custom
   * server adapter, you may provide an initial set of context values from your
   * `getLoadContext` function.
   */
  context: MiddlewareEnabled extends true ? Readonly<RouterContextProvider> : AppLoadContext;
3017};
3018type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
  ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
3020] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
3021type IsDefined<T> = Equal<T, undefined> extends true ? false : true;
3022type IsHydrate<ClientLoader> = ClientLoader extends {
  hydrate: true;
3024} ? true : ClientLoader extends {
  hydrate: false;
3026} ? false : false;
3027type GetLoaderData<T extends RouteModule$1> = _DataLoaderData<ServerDataFrom<T["loader"]>, ClientDataFrom<T["clientLoader"]>, IsHydrate<T["clientLoader"]>, T extends {
  HydrateFallback: Func;
3029} ? true : false>;
3030type _DataLoaderData<ServerLoaderData, ClientLoaderData, ClientLoaderHydrate extends boolean, HasHydrateFallback> = [
  HasHydrateFallback,
  ClientLoaderHydrate
3033] extends [true, true] ? IsDefined<ClientLoaderData> extends true ? ClientLoaderData : undefined : [
  IsDefined<ClientLoaderData>,
  IsDefined<ServerLoaderData>
3036] extends [true, true] ? ServerLoaderData | ClientLoaderData : IsDefined<ClientLoaderData> extends true ? ClientLoaderData : IsDefined<ServerLoaderData> extends true ? ServerLoaderData : undefined;
3037type GetActionData<T extends RouteModule$1> = _DataActionData<ServerDataFrom<T["action"]>, ClientDataFrom<T["clientAction"]>>;
3038type _DataActionData<ServerActionData, ClientActionData> = Awaited<[
  IsDefined<ServerActionData>,
  IsDefined<ClientActionData>
3041] extends [true, true] ? ServerActionData | ClientActionData : IsDefined<ClientActionData> extends true ? ClientActionData : IsDefined<ServerActionData> extends true ? ServerActionData : undefined>;
3042
3043interface RouteModules {
  [routeId: string]: RouteModule | undefined;
3045}
3046/**
* The shape of a route module shipped to the client
*/
3049interface RouteModule {
  clientAction?: ClientActionFunction;
  clientLoader?: ClientLoaderFunction;
  clientMiddleware?: MiddlewareFunction<Record<string, DataStrategyResult>>[];
  ErrorBoundary?: ErrorBoundaryComponent;
  HydrateFallback?: HydrateFallbackComponent;
  Layout?: LayoutComponent;
  default: RouteComponent;
  handle?: RouteHandle;
  links?: LinksFunction;
  meta?: MetaFunction;
  shouldRevalidate?: ShouldRevalidateFunction;
3061}
3062/**
* The shape of a route module on the server
*/
3065interface ServerRouteModule extends RouteModule {
  action?: ActionFunction;
  headers?: HeadersFunction | {
      [name: string]: string;
  };
  loader?: LoaderFunction;
  middleware?: MiddlewareFunction<Response>[];
3072}
3073/**
* A function that handles data mutations for a route on the client
*/
3076type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<ActionFunction>;
3077/**
* Arguments passed to a route `clientAction` function
*/
3080type ClientActionFunctionArgs = ActionFunctionArgs & {
  serverAction: <T = unknown>() => Promise<SerializeFrom<T>>;
3082};
3083/**
* A function that loads data for a route on the client
*/
3086type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<LoaderFunction>) & {
  hydrate?: boolean;
3088};
3089/**
* Arguments passed to a route `clientLoader` function
*/
3092type ClientLoaderFunctionArgs = LoaderFunctionArgs & {
  serverLoader: <T = unknown>() => Promise<SerializeFrom<T>>;
3094};
3095/**
* ErrorBoundary to display for this route
*/
3098type ErrorBoundaryComponent = ComponentType;
3099type HeadersArgs = {
  loaderHeaders: Headers;
  parentHeaders: Headers;
  actionHeaders: Headers;
  errorHeaders: Headers | undefined;
3104};
3105/**
* 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.
*/
3109interface HeadersFunction {
  (args: HeadersArgs): Headers | HeadersInit;
3111}
3112/**
* `<Route HydrateFallback>` component to render on initial loads
* when client loaders are present
*/
3116type HydrateFallbackComponent = ComponentType;
3117/**
* 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
*/
3122type LayoutComponent = ComponentType<{
  children: ReactElement<unknown, ErrorBoundaryComponent | HydrateFallbackComponent | RouteComponent>;
3124}>;
3125/**
* A function that defines `<link>` tags to be inserted into the `<head>` of
* the document on route transitions.
*
* @see https://reactrouter.com/start/framework/route-module#meta
*/
3131interface LinksFunction {
  (): LinkDescriptor[];
3133}
3134interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
  id: RouteId;
  pathname: DataRouteMatch["pathname"];
  /** @deprecated Use `MetaMatch.loaderData` instead */
  data: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
  loaderData: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
  handle?: RouteHandle;
  params: DataRouteMatch["params"];
  meta: MetaDescriptor[];
  error?: unknown;
3144}
3145type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> = Array<{
  [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
3147}[keyof MatchLoaders]>;
3148interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
  /** @deprecated Use `MetaArgs.loaderData` instead */
  data: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
  loaderData: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
  params: Params;
  location: Location;
  matches: MetaMatches<MatchLoaders>;
  error?: unknown;
3156}
3157/**
* 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"
* }
* ```
*/
3207interface MetaFunction<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
  (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
3209}
3210type MetaDescriptor = {
  charSet: "utf-8";
3212} | {
  title: string;
3214} | {
  name: string;
  content: string;
3217} | {
  property: string;
  content: string;
3220} | {
  httpEquiv: string;
  content: string;
3223} | {
  "script:ld+json": LdJsonObject;
3225} | {
  tagName: "meta" | "link";
  [name: string]: string;
3228} | {
  [name: string]: unknown;
3230};
3231type LdJsonObject = {
  [Key in string]: LdJsonValue;
3233} & {
  [Key in string]?: LdJsonValue | undefined;
3235};
3236type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
3237type LdJsonPrimitive = string | number | boolean | null;
3238type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
3239/**
* A React component that is rendered for a route.
*/
3242type RouteComponent = ComponentType<{}>;
3243/**
* An arbitrary object that is associated with a route.
*
* @see https://reactrouter.com/how-to/using-handle
*/
3248type RouteHandle = unknown;
3249
3250type unstable_ServerInstrumentation = {
  handler?: unstable_InstrumentRequestHandlerFunction;
  route?: unstable_InstrumentRouteFunction;
3253};
3254type unstable_ClientInstrumentation = {
  router?: unstable_InstrumentRouterFunction;
  route?: unstable_InstrumentRouteFunction;
3257};
3258type unstable_InstrumentRequestHandlerFunction = (handler: InstrumentableRequestHandler) => void;
3259type unstable_InstrumentRouterFunction = (router: InstrumentableRouter) => void;
3260type unstable_InstrumentRouteFunction = (route: InstrumentableRoute) => void;
3261type unstable_InstrumentationHandlerResult = {
  status: "success";
  error: undefined;
3264} | {
  status: "error";
  error: Error;
3267};
3268type InstrumentFunction<T> = (handler: () => Promise<unstable_InstrumentationHandlerResult>, info: T) => Promise<void>;
3269type ReadonlyRequest = {
  method: string;
  url: string;
  headers: Pick<Headers, "get">;
3273};
3274type ReadonlyContext = MiddlewareEnabled extends true ? Pick<RouterContextProvider, "get"> : Readonly<AppLoadContext>;
3275type InstrumentableRoute = {
  id: string;
  index: boolean | undefined;
  path: string | undefined;
  instrument(instrumentations: RouteInstrumentations): void;
3280};
3281type RouteInstrumentations = {
  lazy?: InstrumentFunction<RouteLazyInstrumentationInfo>;
  "lazy.loader"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
  "lazy.action"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
  "lazy.middleware"?: InstrumentFunction<RouteLazyInstrumentationInfo>;
  middleware?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
  loader?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
  action?: InstrumentFunction<RouteHandlerInstrumentationInfo>;
3289};
3290type RouteLazyInstrumentationInfo = undefined;
3291type RouteHandlerInstrumentationInfo = Readonly<{
  request: ReadonlyRequest;
  params: LoaderFunctionArgs["params"];
  unstable_pattern: string;
  context: ReadonlyContext;
3296}>;
3297type InstrumentableRouter = {
  instrument(instrumentations: RouterInstrumentations): void;
3299};
3300type RouterInstrumentations = {
  navigate?: InstrumentFunction<RouterNavigationInstrumentationInfo>;
  fetch?: InstrumentFunction<RouterFetchInstrumentationInfo>;
3303};
3304type RouterNavigationInstrumentationInfo = Readonly<{
  to: string | number;
  currentUrl: string;
  formMethod?: HTMLFormMethod;
  formEncType?: FormEncType;
  formData?: FormData;
  body?: any;
3311}>;
3312type RouterFetchInstrumentationInfo = Readonly<{
  href: string;
  currentUrl: string;
  fetcherKey: string;
  formMethod?: HTMLFormMethod;
  formEncType?: FormEncType;
  formData?: FormData;
  body?: any;
3320}>;
3321type InstrumentableRequestHandler = {
  instrument(instrumentations: RequestHandlerInstrumentations): void;
3323};
3324type RequestHandlerInstrumentations = {
  request?: InstrumentFunction<RequestHandlerInstrumentationInfo>;
3326};
3327type RequestHandlerInstrumentationInfo = Readonly<{
  request: ReadonlyRequest;
  context: ReadonlyContext | undefined;
3330}>;
3331
3332export { type RouterState as $, type ActionFunction as A, type BlockerFunction as B, type ClientActionFunction as C, type DataStrategyResult as D, type PathMatch as E, type Func as F, type GetLoaderData as G, type HeadersFunction as H, type Navigation as I, Action as J, type RouteObject as K, type Location as L, type MetaFunction as M, type Normalize as N, type InitialEntry as O, type Params as P, type HydrationState as Q, type RouteModule$1 as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type IndexRouteObject as V, type RouteComponentType as W, type HydrateFallbackType as X, type ErrorBoundaryType as Y, type NonIndexRouteObject as Z, type Equal as _, type ClientLoaderFunction as a, type RouterProviderProps as a$, type PatchRoutesOnNavigationFunction as a0, type DataRouteObject as a1, type StaticHandler as a2, type GetScrollPositionFunction as a3, type GetScrollRestorationKeyFunction as a4, type StaticHandlerContext as a5, type Fetcher as a6, type NavigationStates as a7, type RouterSubscriber as a8, type RouterNavigateOptions as a9, IDLE_FETCHER as aA, IDLE_BLOCKER as aB, data as aC, generatePath as aD, isRouteErrorResponse as aE, matchPath as aF, matchRoutes as aG, redirect as aH, redirectDocument as aI, replace as aJ, resolvePath as aK, type DataRouteMatch as aL, type Navigator as aM, type PatchRoutesOnNavigationFunctionArgs as aN, type RouteMatch as aO, AwaitContextProvider as aP, type AwaitProps as aQ, type IndexRouteProps as aR, type ClientOnErrorFunction as aS, type LayoutRouteProps as aT, type MemoryRouterOpts as aU, type MemoryRouterProps as aV, type NavigateProps as aW, type OutletProps as aX, type PathRouteProps as aY, type RouteProps as aZ, type RouterProps as a_, type RouterFetchOptions as aa, type RevalidationState as ab, type ActionFunctionArgs as ac, type DataStrategyFunctionArgs as ad, type DataStrategyMatch as ae, DataWithResponseInit as af, type ErrorResponse as ag, type FormEncType as ah, type FormMethod as ai, type HTMLFormMethod as aj, type LazyRouteFunction as ak, type LoaderFunctionArgs as al, type MiddlewareFunction as am, type PathParam as an, type RedirectFunction as ao, type RouterContext as ap, type ShouldRevalidateFunctionArgs as aq, createContext as ar, createPath as as, parsePath as at, type unstable_ServerInstrumentation as au, type unstable_InstrumentRequestHandlerFunction as av, type unstable_InstrumentRouterFunction as aw, type unstable_InstrumentRouteFunction as ax, type unstable_InstrumentationHandlerResult as ay, IDLE_NAVIGATION as az, type LinksFunction as b, type RoutesProps as b0, Await as b1, MemoryRouter as b2, Navigate as b3, Outlet as b4, Route as b5, Router as b6, RouterProvider as b7, Routes as b8, createMemoryRouter as b9, WithComponentProps as bA, withComponentProps as bB, WithHydrateFallbackProps as bC, withHydrateFallbackProps as bD, WithErrorBoundaryProps as bE, withErrorBoundaryProps as bF, type RouteManifest as bG, type ServerRouteModule as bH, type History as bI, type FutureConfig as bJ, type CreateStaticHandlerOptions as bK, createRoutesFromChildren as ba, createRoutesFromElements as bb, renderMatches as bc, type ClientActionFunctionArgs as bd, type ClientLoaderFunctionArgs as be, type HeadersArgs as bf, type MetaArgs as bg, type PageLinkDescriptor as bh, type HtmlLinkDescriptor as bi, type Future as bj, type unstable_SerializesTo as bk, createMemoryHistory as bl, createBrowserHistory as bm, createHashHistory as bn, invariant as bo, createRouter as bp, ErrorResponseImpl as bq, DataRouterContext as br, DataRouterStateContext as bs, FetchersContext as bt, LocationContext as bu, NavigationContext as bv, RouteContext as bw, ViewTransitionContext as bx, hydrationRouteProperties as by, mapRouteProperties as bz, RouterContextProvider as c, type LoaderFunction as d, type RouterInit as e, type LinkDescriptor as f, type Pretty as g, type MetaDescriptor as h, type ServerDataFunctionArgs as i, type MiddlewareNextFunction as j, type ClientDataFunctionArgs as k, type ServerDataFrom as l, type GetActionData as m, type Router$1 as n, type RouteModules as o, type DataStrategyFunction as p, type MiddlewareEnabled as q, type AppLoadContext as r, type NavigateOptions as s, type Blocker as t, type unstable_ClientInstrumentation as u, type SerializeFrom as v, type RelativeRoutingType as w, type ParamParseKey as x, type Path as y, type PathPattern as z };