UNPKG

react-router/dist/production/routeModules-BR2FO0ix.d.ts

Version:
74.4 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 {
  unstable_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>;
177/**
* 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
*/
184interface BrowserHistory extends UrlHistory {
185}
186type BrowserHistoryOptions = UrlHistoryOptions;
187/**
* 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
*/
194declare function createBrowserHistory(options?: BrowserHistoryOptions): BrowserHistory;
195/**
* @private
*/
198declare function invariant(value: boolean, message?: string): asserts value;
199declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
200/**
* Creates a string URL path from the given pathname, search, and hash components.
*
* @category Utils
*/
205declare function createPath({ pathname, search, hash, }: Partial<Path>): string;
206/**
* Parses a string URL path into its separate pathname, search, and hash components.
*
* @category Utils
*/
211declare function parsePath(path: string): Partial<Path>;
212interface UrlHistory extends History {
213}
214type UrlHistoryOptions = {
  window?: Window;
  v5Compat?: boolean;
217};
218
219type MaybePromise<T> = T | Promise<T>;
220/**
* Map of routeId -> data returned from a loader/action/error
*/
223interface RouteData {
  [routeId: string]: any;
225}
226type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
227type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
228/**
* Users can specify either lowercase or uppercase form methods on `<Form>`,
* useSubmit(), `<fetcher.Form>`, etc.
*/
232type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
233/**
* Active navigation/fetcher form methods are exposed in uppercase on the
* RouterState. This is to align with the normalization done via fetch().
*/
237type FormMethod = UpperCaseFormMethod;
238type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
239type JsonObject = {
  [Key in string]: JsonValue;
241} & {
  [Key in string]?: JsonValue | undefined;
243};
244type JsonArray = JsonValue[] | readonly JsonValue[];
245type JsonPrimitive = string | number | boolean | null;
246type JsonValue = JsonPrimitive | JsonObject | JsonArray;
247/**
* @private
* Internal interface to pass around for action submissions, not intended for
* external consumption
*/
252type Submission = {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: FormData;
  json: undefined;
  text: undefined;
259} | {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: undefined;
  json: JsonValue;
  text: undefined;
266} | {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: undefined;
  json: undefined;
  text: string;
273};
274interface unstable_RouterContext<T = unknown> {
  defaultValue?: T;
276}
277/**
* Creates a context object that may be used to store and retrieve arbitrary values.
*
* If a `defaultValue` is provided, it will be returned from `context.get()` when no value has been
* set for the context. Otherwise reading this context when no value has been set will throw an
* error.
*
* @param defaultValue The default value for the context
* @returns A context object
*/
287declare function unstable_createContext<T>(defaultValue?: T): unstable_RouterContext<T>;
288/**
* A Map of RouterContext objects to their initial values - used to populate a
* fresh `context` value per request/navigation/fetch
*/
292type unstable_InitialContext = Map<unstable_RouterContext, unknown>;
293/**
* Provides methods for writing/reading values in application context in a typesafe way.
*/
296declare class unstable_RouterContextProvider {
  #private;
  constructor(init?: unstable_InitialContext);
  get<T>(context: unstable_RouterContext<T>): T;
  set<C extends unstable_RouterContext>(context: C, value: C extends unstable_RouterContext<infer T> ? T : never): void;
301}
302type DefaultContext = MiddlewareEnabled extends true ? unstable_RouterContextProvider : any;
303/**
* @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.
*/
308interface DataFunctionArgs<Context> {
  /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read headers (like cookies, and {@link https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams URLSearchParams} from the request. */
  request: Request;
  /**
   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
   * @example
   * // app/routes.ts
   * route("teams/:teamId", "./team.tsx"),
   *
   * // app/team.tsx
   * export function loader({
   *   params,
   * }: Route.LoaderArgs) {
   *   params.teamId;
   *   //        ^ string
   * }
   **/
  params: Params;
  /**
   * This is the context passed in to your server adapter's getLoadContext() function.
   * It's a way to bridge the gap between the adapter's request/response API with your React Router app.
   * It is only applicable if you are using a custom server adapter.
   */
  context: Context;
332}
333/**
* Route middleware `next` function to call downstream handlers and then complete
* middlewares from the bottom-up
*/
337interface unstable_MiddlewareNextFunction<Result = unknown> {
  (): MaybePromise<Result>;
339}
340/**
* 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
*/
346type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
347/**
* Arguments passed to loader functions
*/
350interface LoaderFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
351}
352/**
* Arguments passed to action functions
*/
355interface ActionFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
356}
357/**
* Loaders and actions can return anything
*/
360type DataFunctionValue = unknown;
361type DataFunctionReturnValue = MaybePromise<DataFunctionValue>;
362/**
* Route loader function signature
*/
365type LoaderFunction<Context = DefaultContext> = {
  (args: LoaderFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
367} & {
  hydrate?: boolean;
369};
370/**
* Route action function signature
*/
373interface ActionFunction<Context = DefaultContext> {
  (args: ActionFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
375}
376/**
* Arguments passed to shouldRevalidate function
*/
379interface 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;
431}
432/**
* 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.
*/
439interface ShouldRevalidateFunction {
  (args: ShouldRevalidateFunctionArgs): boolean;
441}
442interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
  /**
   * @private
   */
  _lazyPromises?: {
      middleware: Promise<void> | undefined;
      handler: Promise<void> | undefined;
      route: Promise<void> | undefined;
  };
  /**
   * 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`, then only
   *    `a` will have `shouldLoad=true` for the action execution of `dataStrategy`
   *  - After the `action`, `dataStrategy` will be called again for the `loader`
   *    revalidation, and all matches will have `shouldLoad=true` (assuming no custom
   *   `shouldRevalidate` implementations)
   */
  shouldLoad: boolean;
  unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
  unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
  /**
   * An async function that will resolve any `route.lazy` implementations and
   * execute the route's handler (if necessary), returning a `DataStrategyResult`
   *
   * - Calling `match.resolve` does not mean you're calling the `loader`/`action`
   *   (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>;
490}
491interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
  /**
   * Matches for this route extended with Data strategy APIs
   */
  matches: DataStrategyMatch[];
  unstable_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;
502}
503/**
* Result from a loader or action called via dataStrategy
*/
506interface DataStrategyResult {
  type: "data" | "error";
  result: unknown;
509}
510interface DataStrategyFunction<Context = DefaultContext> {
  (args: DataStrategyFunctionArgs<Context>): Promise<Record<string, DataStrategyResult>>;
512}
513type 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;
519};
520type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = (opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>) => MaybePromise<void>;
521/**
* Function provided by the framework-aware layers to set any framework-specific
* properties from framework-agnostic properties
*/
525interface MapRoutePropertiesFunction {
  (route: AgnosticRouteObject): {
      hasErrorBoundary: boolean;
  } & Record<string, any>;
529}
530/**
* 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.
*/
535type UnsupportedLazyRouteObjectKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
536/**
* 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.
*/
541type UnsupportedLazyRouteFunctionKey = UnsupportedLazyRouteObjectKey | "unstable_middleware";
542/**
* lazy object to load route properties, which can add non-matching
* related properties to a route
*/
546type LazyRouteObject<R extends AgnosticRouteObject> = {
  [K in keyof R as K extends UnsupportedLazyRouteObjectKey ? never : K]?: () => Promise<R[K] | null | undefined>;
548};
549/**
* lazy() function to load a route definition, which can add non-matching
* related properties to a route
*/
553interface LazyRouteFunction<R extends AgnosticRouteObject> {
  (): Promise<Omit<R, UnsupportedLazyRouteFunctionKey> & Partial<Record<UnsupportedLazyRouteFunctionKey, never>>>;
555}
556type LazyRouteDefinition<R extends AgnosticRouteObject> = LazyRouteObject<R> | LazyRouteFunction<R>;
557/**
* Base RouteObject with common props shared by all types of routes
*/
560type AgnosticBaseRouteObject = {
  caseSensitive?: boolean;
  path?: string;
  id?: string;
  unstable_middleware?: unstable_MiddlewareFunction[];
  loader?: LoaderFunction | boolean;
  action?: ActionFunction | boolean;
  hasErrorBoundary?: boolean;
  shouldRevalidate?: ShouldRevalidateFunction;
  handle?: any;
  lazy?: LazyRouteDefinition<AgnosticBaseRouteObject>;
571};
572/**
* Index routes must not have children
*/
575type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
  children?: undefined;
  index: true;
578};
579/**
* Non-index routes may have children, but cannot have index
*/
582type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
  children?: AgnosticRouteObject[];
  index?: false;
585};
586/**
* A route object represents a logical route, with (optionally) its child
* routes organized in a tree-like structure.
*/
590type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
591type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
  id: string;
593};
594type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
  children?: AgnosticDataRouteObject[];
  id: string;
597};
598/**
* A data route object, which is just a RouteObject with a required unique ID
*/
601type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
602type RouteManifest<R = AgnosticDataRouteObject> = Record<string, R | undefined>;
603type 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";
604type 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";
605type Regex_09 = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
606type Regex_w = Regex_az | Regez_AZ | Regex_09 | "_";
607type ParamChar = Regex_w | "-";
608type 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;
609type _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;
610type PathParam<Path extends string> = Path extends "*" | "/*" ? "*" : Path extends `${infer Rest}/*` ? "*" | _PathParam<Rest> : _PathParam<Path>;
611type ParamParseKey<Segment extends string> = [
  PathParam<Segment>
613] extends [never] ? string : PathParam<Segment>;
614/**
* The parameters that were parsed from the URL path.
*/
617type Params<Key extends string = string> = {
  readonly [key in Key]: string | undefined;
619};
620/**
* A RouteMatch contains info about how a route matched a URL.
*/
623interface 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;
640}
641interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
642}
643/**
* Matches the given routes to a location and returns the match data.
*
* @category Utils
*/
648declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
649interface UIMatch<Data = unknown, Handle = unknown> {
  id: string;
  pathname: string;
  /**
   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the matched route.
   **/
  params: AgnosticRouteMatch["params"];
  /** The return value from the matched route's loader or clientLoader */
  data: Data;
  /** The {@link https://reactrouter.com/start/framework/route-module#handle handle object} exported from the matched route module */
  handle: Handle;
660}
661/**
* Returns a path with params interpolated.
*
* @category Utils
*/
666declare function generatePath<Path extends string>(originalPath: Path, params?: {
  [key in PathParam<Path>]: string | null;
668}): string;
669/**
* A PathPattern is used to match on some portion of a URL pathname.
*/
672interface PathPattern<Path extends string = string> {
  /**
   * A string to match against a URL pathname. May contain `:id`-style segments
   * to indicate placeholders for dynamic parameters. May also end with `/*` to
   * indicate matching the rest of the URL pathname.
   */
  path: Path;
  /**
   * Should be `true` if the static portions of the `path` should be matched in
   * the same case.
   */
  caseSensitive?: boolean;
  /**
   * Should be `true` if this pattern should match the entire URL pathname.
   */
  end?: boolean;
688}
689/**
* A PathMatch contains info about how a PathPattern matched on a URL pathname.
*/
692interface 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;
709}
710/**
* Performs pattern matching on a URL pathname and returns information about
* the match.
*
* @category Utils
*/
716declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
717/**
* Returns a resolved path object relative to the given pathname.
*
* @category Utils
*/
722declare function resolvePath(to: To, fromPathname?: string): Path;
723declare class DataWithResponseInit<D> {
  type: string;
  data: D;
  init: ResponseInit | null;
  constructor(data: D, init?: ResponseInit);
728}
729/**
* Create "responses" that contain `status`/`headers` without forcing
* serialization into an actual `Response` - used by Remix single fetch
*
* @category Utils
*/
735declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
736type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
737/**
* A redirect response. Sets the status code and the `Location` header.
* Defaults to "302 Found".
*
* @category Utils
*/
743declare const redirect: RedirectFunction;
744/**
* A redirect response that will force a document reload to the new location.
* Sets the status code and the `Location` header.
* Defaults to "302 Found".
*
* @category Utils
*/
751declare const redirectDocument: RedirectFunction;
752/**
* A redirect response that will perform a `history.replaceState` instead of a
* `history.pushState` for client-side navigation redirects.
* Sets the status code and the `Location` header.
* Defaults to "302 Found".
*
* @category Utils
*/
760declare const replace: RedirectFunction;
761type ErrorResponse = {
  status: number;
  statusText: string;
  data: any;
765};
766/**
* @private
* Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
*
* We don't export the class for public use since it's an implementation
* detail, but we export the interface above so folks can build their own
* abstractions around instances via isRouteErrorResponse()
*/
774declare class ErrorResponseImpl implements ErrorResponse {
  status: number;
  statusText: string;
  data: any;
  private error?;
  private internal;
  constructor(status: number, statusText: string | undefined, data: any, internal?: boolean);
781}
782/**
* Check if the given error is an ErrorResponse generated from a 4xx/5xx
* Response thrown from an action/loader
*
* @category Utils
*/
788declare function isRouteErrorResponse(error: any): error is ErrorResponse;
789
790/**
* A Router instance manages all navigation and data loading/mutations
*/
793interface Router {
  /**
   * @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;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Subscribe to router.state updates
   *
   * @param fn function to call with the new state
   */
  subscribe(fn: RouterSubscriber): () => void;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Enable scroll restoration behavior in the router
   *
   * @param savedScrollPositions Object that will manage positions, in case
   *                             it's being restored from sessionStorage
   * @param getScrollPosition    Function to get the active Y scroll position
   * @param getKey               Function to get the key to use for restoration
   */
  enableScrollRestoration(savedScrollPositions: Record<string, number>, getScrollPosition: GetScrollPositionFunction, getKey?: GetScrollRestorationKeyFunction): () => void;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Navigate forward/backward in the history stack
   * @param to Delta to move in the history stack
   */
  navigate(to: number): Promise<void>;
  /**
   * Navigate to the given path
   * @param to Path to navigate to
   * @param opts Navigation options (method, submission, etc.)
   */
  navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Trigger a fetcher load/submission
   *
   * @param key     Fetcher key
   * @param routeId Route that owns the fetcher
   * @param href    href to fetch
   * @param opts    Fetcher options, (method, submission, etc.)
   */
  fetch(key: string, routeId: string, href: string | null, opts?: RouterFetchOptions): Promise<void>;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Trigger a revalidation of all current route loaders and fetcher loads
   */
  revalidate(): Promise<void>;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Utility function to create an href for the given location
   * @param location
   */
  createHref(location: Location | URL): string;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Utility function to URL encode a destination path according to the internal
   * history implementation
   * @param to
   */
  encodeLocation(to: To): Path;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Get/create a fetcher for the given key
   * @param key
   */
  getFetcher<TData = any>(key: string): Fetcher<TData>;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Delete the fetcher for a given key
   * @param key
   */
  deleteFetcher(key: string): void;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Cleanup listeners and abort any in-progress loads
   */
  dispose(): void;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Get a navigation blocker
   * @param key The identifier for the blocker
   * @param fn The blocker function implementation
   */
  getBlocker(key: string, fn: BlockerFunction): Blocker;
  /**
   * @private
   * PRIVATE - DO NOT USE
   *
   * Delete a navigation blocker
   * @param key The identifier for the blocker
   */
  deleteBlocker(key: string): void;
  /**
   * @private
   * PRIVATE DO NOT USE
   *
   * Patch additional children routes into an existing parent route
   * @param routeId The parent route id or a callback function accepting `patch`
   *                to perform batch patching
   * @param children The additional children routes
   * @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>;
984}
985/**
* State maintained internally by the router.  During a navigation, all states
* reflect the "old" location unless otherwise noted.
*/
989interface 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>;
1046}
1047/**
* Data that can be passed into hydrate a Router from SSR
*/
1050type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
1051/**
* Future flags to toggle new feature behavior
*/
1054interface FutureConfig {
  unstable_middleware: boolean;
1056}
1057/**
* Initialization options for createRouter
*/
1060interface RouterInit {
  routes: AgnosticRouteObject[];
  history: History;
  basename?: string;
  unstable_getContext?: () => MaybePromise<unstable_InitialContext>;
  mapRouteProperties?: MapRoutePropertiesFunction;
  future?: Partial<FutureConfig>;
  hydrationRouteProperties?: string[];
  hydrationData?: HydrationState;
  window?: Window;
  dataStrategy?: DataStrategyFunction;
  patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;
1072}
1073/**
* State returned from a server-side query() call
*/
1076interface StaticHandlerContext {
  basename: Router["basename"];
  location: RouterState["location"];
  matches: RouterState["matches"];
  loaderData: RouterState["loaderData"];
  actionData: RouterState["actionData"];
  errors: RouterState["errors"];
  statusCode: number;
  loaderHeaders: Record<string, Headers>;
  actionHeaders: Record<string, Headers>;
  _deepestRenderedBoundaryId?: string | null;
1087}
1088/**
* A StaticHandler instance manages a singular SSR navigation/fetch event
*/
1091interface StaticHandler {
  dataRoutes: AgnosticDataRouteObject[];
  query(request: Request, opts?: {
      requestContext?: unknown;
      filterMatchesToLoad?: (match: AgnosticDataRouteMatch) => boolean;
      skipLoaderErrorBubbling?: boolean;
      skipRevalidation?: boolean;
      dataStrategy?: DataStrategyFunction<unknown>;
      unstable_respond?: (staticContext: StaticHandlerContext) => MaybePromise<Response>;
      unstable_stream?: (context: unstable_RouterContextProvider, query: (r: Request) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
  }): Promise<StaticHandlerContext | Response>;
  queryRoute(request: Request, opts?: {
      routeId?: string;
      requestContext?: unknown;
      dataStrategy?: DataStrategyFunction<unknown>;
      unstable_respond?: (res: Response) => MaybePromise<Response>;
  }): Promise<any>;
1108}
1109type ViewTransitionOpts = {
  currentLocation: Location;
  nextLocation: Location;
1112};
1113/**
* Subscriber function signature for changes to router state
*/
1116interface RouterSubscriber {
  (state: RouterState, opts: {
      deletedFetchers: string[];
      viewTransitionOpts?: ViewTransitionOpts;
      flushSync: boolean;
  }): void;
1122}
1123/**
* Function signature for determining the key to be used in scroll restoration
* for a given location
*/
1127interface GetScrollRestorationKeyFunction {
  (location: Location, matches: UIMatch[]): string | null;
1129}
1130/**
* Function signature for determining the current scroll position
*/
1133interface GetScrollPositionFunction {
  (): number;
1135}
1136/**
* - "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.
*/
1144type RelativeRoutingType = "route" | "path";
1145type BaseNavigateOrFetchOptions = {
  preventScrollReset?: boolean;
  relative?: RelativeRoutingType;
  flushSync?: boolean;
1149};
1150type BaseNavigateOptions = BaseNavigateOrFetchOptions & {
  replace?: boolean;
  state?: any;
  fromRouteId?: string;
  viewTransition?: boolean;
1155};
1156type BaseSubmissionOptions = {
  formMethod?: HTMLFormMethod;
  formEncType?: FormEncType;
1159} & ({
  formData: FormData;
  body?: undefined;
1162} | {
  formData?: undefined;
  body: any;
1165});
1166/**
* Options for a navigate() call for a normal (non-submission) navigation
*/
1169type LinkNavigateOptions = BaseNavigateOptions;
1170/**
* Options for a navigate() call for a submission navigation
*/
1173type SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;
1174/**
* Options to pass to navigate() for a navigation
*/
1177type RouterNavigateOptions = LinkNavigateOptions | SubmissionNavigateOptions;
1178/**
* Options for a fetch() load
*/
1181type LoadFetchOptions = BaseNavigateOrFetchOptions;
1182/**
* Options for a fetch() submission
*/
1185type SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;
1186/**
* Options to pass to fetch()
*/
1189type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;
1190/**
* Potential states for state.navigation
*/
1193type 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"];
  };
1224};
1225type Navigation = NavigationStates[keyof NavigationStates];
1226type RevalidationState = "idle" | "loading";
1227/**
* Potential states for fetchers
*/
1230type 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;
  };
1301};
1302type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
1303interface BlockerBlocked {
  state: "blocked";
  reset: () => void;
  proceed: () => void;
  location: Location;
1308}
1309interface BlockerUnblocked {
  state: "unblocked";
  reset: undefined;
  proceed: undefined;
  location: undefined;
1314}
1315interface BlockerProceeding {
  state: "proceeding";
  reset: undefined;
  proceed: undefined;
  location: Location;
1320}
1321type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
1322type BlockerFunction = (args: {
  currentLocation: Location;
  nextLocation: Location;
  historyAction: Action;
1326}) => boolean;
1327declare const IDLE_NAVIGATION: NavigationStates["Idle"];
1328declare const IDLE_FETCHER: FetcherStates["Idle"];
1329declare const IDLE_BLOCKER: BlockerUnblocked;
1330/**
* Create a router and listen to history POP navigations
*/
1333declare function createRouter(init: RouterInit): Router;
1334interface CreateStaticHandlerOptions {
  basename?: string;
  mapRouteProperties?: MapRoutePropertiesFunction;
  future?: {};
1338}
1339
1340interface IndexRouteObject {
  caseSensitive?: AgnosticIndexRouteObject["caseSensitive"];
  path?: AgnosticIndexRouteObject["path"];
  id?: AgnosticIndexRouteObject["id"];
  unstable_middleware?: AgnosticIndexRouteObject["unstable_middleware"];
  loader?: AgnosticIndexRouteObject["loader"];
  action?: AgnosticIndexRouteObject["action"];
  hasErrorBoundary?: AgnosticIndexRouteObject["hasErrorBoundary"];
  shouldRevalidate?: AgnosticIndexRouteObject["shouldRevalidate"];
  handle?: AgnosticIndexRouteObject["handle"];
  index: true;
  children?: undefined;
  element?: React.ReactNode | null;
  hydrateFallbackElement?: React.ReactNode | null;
  errorElement?: React.ReactNode | null;
  Component?: React.ComponentType | null;
  HydrateFallback?: React.ComponentType | null;
  ErrorBoundary?: React.ComponentType | null;
  lazy?: LazyRouteDefinition<RouteObject>;
1359}
1360interface NonIndexRouteObject {
  caseSensitive?: AgnosticNonIndexRouteObject["caseSensitive"];
  path?: AgnosticNonIndexRouteObject["path"];
  id?: AgnosticNonIndexRouteObject["id"];
  unstable_middleware?: AgnosticNonIndexRouteObject["unstable_middleware"];
  loader?: AgnosticNonIndexRouteObject["loader"];
  action?: AgnosticNonIndexRouteObject["action"];
  hasErrorBoundary?: AgnosticNonIndexRouteObject["hasErrorBoundary"];
  shouldRevalidate?: AgnosticNonIndexRouteObject["shouldRevalidate"];
  handle?: AgnosticNonIndexRouteObject["handle"];
  index?: false;
  children?: RouteObject[];
  element?: React.ReactNode | null;
  hydrateFallbackElement?: React.ReactNode | null;
  errorElement?: React.ReactNode | null;
  Component?: React.ComponentType | null;
  HydrateFallback?: React.ComponentType | null;
  ErrorBoundary?: React.ComponentType | null;
  lazy?: LazyRouteDefinition<RouteObject>;
1379}
1380type RouteObject = IndexRouteObject | NonIndexRouteObject;
1381type DataRouteObject = RouteObject & {
  children?: DataRouteObject[];
  id: string;
1384};
1385interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {
1386}
1387interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
1388}
1389type PatchRoutesOnNavigationFunctionArgs = AgnosticPatchRoutesOnNavigationFunctionArgs<RouteObject, RouteMatch>;
1390type PatchRoutesOnNavigationFunction = AgnosticPatchRoutesOnNavigationFunction<RouteObject, RouteMatch>;
1391interface DataRouterContextObject extends Omit<NavigationContextObject, "future"> {
  router: Router;
  staticContext?: StaticHandlerContext;
1394}
1395declare const DataRouterContext: React.Context<DataRouterContextObject | null>;
1396declare const DataRouterStateContext: React.Context<RouterState | null>;
1397type ViewTransitionContextObject = {
  isTransitioning: false;
1399} | {
  isTransitioning: true;
  flushSync: boolean;
  currentLocation: Location;
  nextLocation: Location;
1404};
1405declare const ViewTransitionContext: React.Context<ViewTransitionContextObject>;
1406type FetchersContextObject = Map<string, any>;
1407declare const FetchersContext: React.Context<FetchersContextObject>;
1408interface 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;
1421}
1422/**
* 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.
*/
1431interface 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;
1437}
1438interface NavigationContextObject {
  basename: string;
  navigator: Navigator;
  static: boolean;
  future: {};
1443}
1444declare const NavigationContext: React.Context<NavigationContextObject>;
1445interface LocationContextObject {
  location: Location;
  navigationType: Action;
1448}
1449declare const LocationContext: React.Context<LocationContextObject>;
1450interface RouteContextObject {
  outlet: React.ReactElement | null;
  matches: RouteMatch[];
  isDataRoute: boolean;
1454}
1455declare const RouteContext: React.Context<RouteContextObject>;
1456
1457type Primitive = null | undefined | string | number | boolean | symbol | bigint;
1458type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
1459interface 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;
1521}
1522interface 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;
1544}
1545/**
* Represents a `<link>` element.
*
* WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
*/
1550type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
  imageSizes?: never;
1552});
1553interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
  /**
   * The absolute path of the page to prefetch.
   */
  page: string;
1558}
1559type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
1560
1561/**
* 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
*/
1567interface AppLoadContext {
  [key: string]: unknown;
1569}
1570
1571type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
  [key: PropertyKey]: Serializable;
1573} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
1574
1575type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
1576type IsAny<T> = 0 extends 1 & T ? true : false;
1577type Func = (...args: any[]) => unknown;
1578type Pretty<T> = {
  [K in keyof T]: T[K];
1580} & {};
1581type Normalize<T> = _Normalize<UnionKeys<T>, T>;
1582type _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;
1584} & {
  [K in Key as K extends keyof U ? undefined extends U[K] ? K : never : never]?: K extends keyof U ? U[K] : never;
1586} & {
  [K in Key as K extends keyof U ? never : K]?: undefined;
1588}> : never;
1589type UnionKeys<T> = T extends any ? keyof T : never;
1590
1591type 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;
1603};
1604
1605/**
* 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.
*/
1611type unstable_SerializesTo<T> = {
  unstable__ReactRouter_SerializesTo: [T];
1613};
1614
1615type Serialize<T> = T extends unstable_SerializesTo<infer To> ? To : T extends Serializable ? T : T extends (...args: any[]) => unknown ? undefined : T extends Promise<infer U> ? Promise<Serialize<U>> : T extends Map<infer K, infer V> ? Map<Serialize<K>, Serialize<V>> : T extends Set<infer U> ? Set<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? {
  [K in keyof T]: Serialize<T[K]>;
1617} : undefined;
1618type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
1619type DataFrom<T> = IsAny<T> extends true ? undefined : T extends Func ? VoidToUndefined<Awaited<ReturnType<T>>> : undefined;
1620type ClientData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? U : T;
1621type ServerData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? Serialize<U> : Serialize<T>;
1622type ServerDataFrom<T> = ServerData<DataFrom<T>>;
1623type ClientDataFrom<T> = ClientData<DataFrom<T>>;
1624type 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;
  /**
   * When `future.unstable_middleware` is not enabled, this is undefined.
   *
   * When `future.unstable_middleware` is enabled, this is an instance of
   * `unstable_RouterContextProvider` and can be used to access context values
   * from your route middlewares.  You may pass in initial context values in your
   * `<HydratedRouter unstable_getContext>` prop
   */
  context: unstable_RouterContextProvider;
1655};
1656type 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;
  /**
   * Without `future.unstable_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.unstable_middleware` enabled, this is an instance of
   * `unstable_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 ? unstable_RouterContextProvider : AppLoadContext;
1687};
1688type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
  ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
1690] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
1691type IsDefined<T> = Equal<T, undefined> extends true ? false : true;
1692type IsHydrate<ClientLoader> = ClientLoader extends {
  hydrate: true;
1694} ? true : ClientLoader extends {
  hydrate: false;
1696} ? false : false;
1697type GetLoaderData<T extends RouteModule$1> = _DataLoaderData<ServerDataFrom<T["loader"]>, ClientDataFrom<T["clientLoader"]>, IsHydrate<T["clientLoader"]>, T extends {
  HydrateFallback: Func;
1699} ? true : false>;
1700type _DataLoaderData<ServerLoaderData, ClientLoaderData, ClientLoaderHydrate extends boolean, HasHydrateFallback> = [
  HasHydrateFallback,
  ClientLoaderHydrate
1703] extends [true, true] ? IsDefined<ClientLoaderData> extends true ? ClientLoaderData : undefined : [
  IsDefined<ClientLoaderData>,
  IsDefined<ServerLoaderData>
1706] extends [true, true] ? ServerLoaderData | ClientLoaderData : IsDefined<ClientLoaderData> extends true ? ClientLoaderData : IsDefined<ServerLoaderData> extends true ? ServerLoaderData : undefined;
1707type GetActionData<T extends RouteModule$1> = _DataActionData<ServerDataFrom<T["action"]>, ClientDataFrom<T["clientAction"]>>;
1708type _DataActionData<ServerActionData, ClientActionData> = Awaited<[
  IsDefined<ServerActionData>,
  IsDefined<ClientActionData>
1711] extends [true, true] ? ServerActionData | ClientActionData : IsDefined<ClientActionData> extends true ? ClientActionData : IsDefined<ServerActionData> extends true ? ServerActionData : undefined>;
1712
1713interface RouteModules {
  [routeId: string]: RouteModule | undefined;
1715}
1716/**
* The shape of a route module shipped to the client
*/
1719interface RouteModule {
  clientAction?: ClientActionFunction;
  clientLoader?: ClientLoaderFunction;
  unstable_clientMiddleware?: unstable_MiddlewareFunction<undefined>[];
  ErrorBoundary?: ErrorBoundaryComponent;
  HydrateFallback?: HydrateFallbackComponent;
  Layout?: LayoutComponent;
  default: RouteComponent;
  handle?: RouteHandle;
  links?: LinksFunction;
  meta?: MetaFunction;
  shouldRevalidate?: ShouldRevalidateFunction;
1731}
1732/**
* The shape of a route module on the server
*/
1735interface ServerRouteModule extends RouteModule {
  action?: ActionFunction;
  headers?: HeadersFunction | {
      [name: string]: string;
  };
  loader?: LoaderFunction;
  unstable_middleware?: unstable_MiddlewareFunction<Response>[];
1742}
1743/**
* A function that handles data mutations for a route on the client
*/
1746type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<ActionFunction>;
1747/**
* Arguments passed to a route `clientAction` function
*/
1750type ClientActionFunctionArgs = ActionFunctionArgs & {
  serverAction: <T = unknown>() => Promise<SerializeFrom<T>>;
1752};
1753/**
* A function that loads data for a route on the client
*/
1756type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<LoaderFunction>) & {
  hydrate?: boolean;
1758};
1759/**
* Arguments passed to a route `clientLoader` function
*/
1762type ClientLoaderFunctionArgs = LoaderFunctionArgs & {
  serverLoader: <T = unknown>() => Promise<SerializeFrom<T>>;
1764};
1765/**
* ErrorBoundary to display for this route
*/
1768type ErrorBoundaryComponent = ComponentType;
1769type HeadersArgs = {
  loaderHeaders: Headers;
  parentHeaders: Headers;
  actionHeaders: Headers;
  errorHeaders: Headers | undefined;
1774};
1775/**
* 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.
*/
1779interface HeadersFunction {
  (args: HeadersArgs): Headers | HeadersInit;
1781}
1782/**
* `<Route HydrateFallback>` component to render on initial loads
* when client loaders are present
*/
1786type HydrateFallbackComponent = ComponentType;
1787/**
* 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
*/
1792type LayoutComponent = ComponentType<{
  children: ReactElement<unknown, ErrorBoundaryComponent | HydrateFallbackComponent | RouteComponent>;
1794}>;
1795/**
* A function that defines `<link>` tags to be inserted into the `<head>` of
* the document on route transitions.
*
* @see https://remix.run/route/meta
*/
1801interface LinksFunction {
  (): LinkDescriptor[];
1803}
1804interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
  id: RouteId;
  pathname: DataRouteMatch["pathname"];
  data: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
  handle?: RouteHandle;
  params: DataRouteMatch["params"];
  meta: MetaDescriptor[];
  error?: unknown;
1812}
1813type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> = Array<{
  [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
1815}[keyof MatchLoaders]>;
1816interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
  data: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
  params: Params;
  location: Location;
  matches: MetaMatches<MatchLoaders>;
  error?: unknown;
1822}
1823/**
* 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"
* }
* ```
*/
1873interface MetaFunction<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
  (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
1875}
1876type MetaDescriptor = {
  charSet: "utf-8";
1878} | {
  title: string;
1880} | {
  name: string;
  content: string;
1883} | {
  property: string;
  content: string;
1886} | {
  httpEquiv: string;
  content: string;
1889} | {
  "script:ld+json": LdJsonObject;
1891} | {
  tagName: "meta" | "link";
  [name: string]: string;
1894} | {
  [name: string]: unknown;
1896};
1897type LdJsonObject = {
  [Key in string]: LdJsonValue;
1899} & {
  [Key in string]?: LdJsonValue | undefined;
1901};
1902type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
1903type LdJsonPrimitive = string | number | boolean | null;
1904type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
1905/**
* A React component that is rendered for a route.
*/
1908type RouteComponent = ComponentType<{}>;
1909/**
* An arbitrary object that is associated with a route.
*
* @see https://remix.run/route/handle
*/
1914type RouteHandle = unknown;
1915
1916export { type GetScrollRestorationKeyFunction as $, Action as A, type BlockerFunction as B, type ClientDataFunctionArgs as C, type DataStrategyFunction as D, type unstable_InitialContext as E, type Equal as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type ClientActionFunction as J, type ClientLoaderFunction as K, type LinkDescriptor as L, type MetaDescriptor as M, type Normalize as N, type HeadersFunction as O, type Pretty as P, type ShouldRevalidateFunction as Q, type RouteModule$1 as R, type ServerDataFunctionArgs as S, type To as T, type UIMatch as U, type RouterInit as V, type RouterState as W, type PatchRoutesOnNavigationFunction as X, type DataRouteObject as Y, type StaticHandler as Z, type GetScrollPositionFunction as _, type Location as a, type ServerRouteModule as a$, type StaticHandlerContext as a0, type Fetcher as a1, type NavigationStates as a2, type RouterSubscriber as a3, type RouterNavigateOptions as a4, type RouterFetchOptions as a5, type RevalidationState as a6, type ActionFunctionArgs as a7, type DataStrategyFunctionArgs as a8, type DataStrategyMatch as a9, replace as aA, resolvePath as aB, type DataRouteMatch as aC, type Navigator as aD, type PatchRoutesOnNavigationFunctionArgs as aE, type RouteMatch as aF, type ClientActionFunctionArgs as aG, type ClientLoaderFunctionArgs as aH, type HeadersArgs as aI, type MetaArgs as aJ, type PageLinkDescriptor as aK, type HtmlLinkDescriptor as aL, type Future as aM, type unstable_SerializesTo as aN, createBrowserHistory as aO, invariant as aP, createRouter as aQ, ErrorResponseImpl as aR, DataRouterContext as aS, DataRouterStateContext as aT, FetchersContext as aU, LocationContext as aV, NavigationContext as aW, RouteContext as aX, ViewTransitionContext as aY, type FutureConfig as aZ, type RouteManifest as a_, type DataStrategyResult as aa, DataWithResponseInit as ab, type ErrorResponse as ac, type FormEncType as ad, type FormMethod as ae, type HTMLFormMethod as af, type LazyRouteFunction as ag, type LoaderFunctionArgs as ah, type unstable_MiddlewareFunction as ai, type PathParam as aj, type RedirectFunction as ak, type unstable_RouterContext as al, type ShouldRevalidateFunctionArgs as am, unstable_createContext as an, createPath as ao, parsePath as ap, IDLE_NAVIGATION as aq, IDLE_FETCHER as ar, IDLE_BLOCKER as as, data as at, generatePath as au, isRouteErrorResponse as av, matchPath as aw, matchRoutes as ax, redirect as ay, redirectDocument as az, type ServerDataFrom as b, type History as b0, type CreateStaticHandlerOptions as b1, type GetActionData as c, type Router as d, type RouteModules as e, type NavigateOptions as f, type Blocker as g, type SerializeFrom as h, type RelativeRoutingType as i, type ParamParseKey as j, type Path as k, type PathPattern as l, type PathMatch as m, type Navigation as n, type Params as o, type RouteObject as p, type IndexRouteObject as q, type LoaderFunction as r, type ActionFunction as s, type MetaFunction as t, type unstable_MiddlewareNextFunction as u, type LinksFunction as v, type NonIndexRouteObject as w, type AppLoadContext as x, unstable_RouterContextProvider as y, type MiddlewareEnabled as z };