UNPKG

react-router/dist/development/index-react-server.d.ts

Version:
73.1 kBTypeScriptView Raw
1import { AsyncLocalStorage } from 'node:async_hooks';
2import * as React from 'react';
3export { Await, BrowserRouter, Form, HashRouter, Link, Links, MemoryRouter, Meta, NavLink, Navigate, Outlet, Route, Router, RouterProvider, Routes, ScrollRestoration, StaticRouter, StaticRouterProvider, unstable_HistoryRouter } from 'react-router/internal/react-server-client';
4import { ParseOptions, SerializeOptions } from 'cookie';
5export { ParseOptions as CookieParseOptions, SerializeOptions as CookieSerializeOptions } from 'cookie';
6
7/**
* Actions represent the type of change to a location value.
*/
10declare 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"
30}
31/**
* The pathname, search, and hash values of a URL.
*/
34interface 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;
47}
48/**
* An entry in a history stack. A location contains information about the
* URL path, as well as possibly some arbitrary state and a key.
*/
52interface 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;
64}
65/**
* A change to the current location.
*/
68interface 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;
81}
82/**
* A function that receives notifications about location changes.
*/
85interface Listener {
  (update: Update): void;
87}
88/**
* Describes a location that is the destination of some navigation used in
* {@link Link}, {@link useNavigate}, etc.
*/
92type To = string | Partial<Path>;
93/**
* 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.
*/
101interface 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;
164}
165
166/**
* An augmentable interface users can modify in their app-code to opt into
* future-flag-specific types
*/
170interface Future {
171}
172type MiddlewareEnabled = Future extends {
  unstable_middleware: infer T extends boolean;
174} ? T : false;
175
176type MaybePromise<T> = T | Promise<T>;
177/**
* Map of routeId -> data returned from a loader/action/error
*/
180interface RouteData {
  [routeId: string]: any;
182}
183type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
184type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
185/**
* Users can specify either lowercase or uppercase form methods on `<Form>`,
* useSubmit(), `<fetcher.Form>`, etc.
*/
189type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
190/**
* Active navigation/fetcher form methods are exposed in uppercase on the
* RouterState. This is to align with the normalization done via fetch().
*/
194type FormMethod = UpperCaseFormMethod;
195type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
196type JsonObject = {
  [Key in string]: JsonValue;
198} & {
  [Key in string]?: JsonValue | undefined;
200};
201type JsonArray = JsonValue[] | readonly JsonValue[];
202type JsonPrimitive = string | number | boolean | null;
203type JsonValue = JsonPrimitive | JsonObject | JsonArray;
204/**
* @private
* Internal interface to pass around for action submissions, not intended for
* external consumption
*/
209type Submission = {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: FormData;
  json: undefined;
  text: undefined;
216} | {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: undefined;
  json: JsonValue;
  text: undefined;
223} | {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: undefined;
  json: undefined;
  text: string;
230};
231interface unstable_RouterContext<T = unknown> {
  defaultValue?: T;
233}
234/**
* 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
*/
244declare function unstable_createContext<T>(defaultValue?: T): unstable_RouterContext<T>;
245/**
* A Map of RouterContext objects to their initial values - used to populate a
* fresh `context` value per request/navigation/fetch
*/
249type unstable_InitialContext = Map<unstable_RouterContext, unknown>;
250/**
* Provides methods for writing/reading values in application context in a typesafe way.
*/
253declare 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;
258}
259type DefaultContext = MiddlewareEnabled extends true ? unstable_RouterContextProvider : any;
260/**
* @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.
*/
265interface 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;
289}
290/**
* Route middleware `next` function to call downstream handlers and then complete
* middlewares from the bottom-up
*/
294interface unstable_MiddlewareNextFunction<Result = unknown> {
  (): MaybePromise<Result>;
296}
297/**
* 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
*/
303type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
304/**
* Arguments passed to loader functions
*/
307interface LoaderFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
308}
309/**
* Arguments passed to action functions
*/
312interface ActionFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
313}
314/**
* Loaders and actions can return anything
*/
317type DataFunctionValue = unknown;
318type DataFunctionReturnValue = MaybePromise<DataFunctionValue>;
319/**
* Route loader function signature
*/
322type LoaderFunction<Context = DefaultContext> = {
  (args: LoaderFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
324} & {
  hydrate?: boolean;
326};
327/**
* Route action function signature
*/
330interface ActionFunction<Context = DefaultContext> {
  (args: ActionFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
332}
333/**
* Arguments passed to shouldRevalidate function
*/
336interface 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;
388}
389/**
* 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.
*/
396interface ShouldRevalidateFunction {
  (args: ShouldRevalidateFunctionArgs): boolean;
398}
399interface 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>;
447}
448interface 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;
459}
460/**
* Result from a loader or action called via dataStrategy
*/
463interface DataStrategyResult {
  type: "data" | "error";
  result: unknown;
466}
467interface DataStrategyFunction<Context = DefaultContext> {
  (args: DataStrategyFunctionArgs<Context>): Promise<Record<string, DataStrategyResult>>;
469}
470type 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;
476};
477type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = (opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>) => MaybePromise<void>;
478/**
* Function provided by the framework-aware layers to set any framework-specific
* properties from framework-agnostic properties
*/
482interface MapRoutePropertiesFunction {
  (route: AgnosticRouteObject): {
      hasErrorBoundary: boolean;
  } & Record<string, any>;
486}
487/**
* 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.
*/
492type UnsupportedLazyRouteObjectKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
493/**
* 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.
*/
498type UnsupportedLazyRouteFunctionKey = UnsupportedLazyRouteObjectKey | "unstable_middleware";
499/**
* lazy object to load route properties, which can add non-matching
* related properties to a route
*/
503type LazyRouteObject<R extends AgnosticRouteObject> = {
  [K in keyof R as K extends UnsupportedLazyRouteObjectKey ? never : K]?: () => Promise<R[K] | null | undefined>;
505};
506/**
* lazy() function to load a route definition, which can add non-matching
* related properties to a route
*/
510interface LazyRouteFunction<R extends AgnosticRouteObject> {
  (): Promise<Omit<R, UnsupportedLazyRouteFunctionKey> & Partial<Record<UnsupportedLazyRouteFunctionKey, never>>>;
512}
513type LazyRouteDefinition<R extends AgnosticRouteObject> = LazyRouteObject<R> | LazyRouteFunction<R>;
514/**
* Base RouteObject with common props shared by all types of routes
*/
517type 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>;
528};
529/**
* Index routes must not have children
*/
532type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
  children?: undefined;
  index: true;
535};
536/**
* Non-index routes may have children, but cannot have index
*/
539type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
  children?: AgnosticRouteObject[];
  index?: false;
542};
543/**
* A route object represents a logical route, with (optionally) its child
* routes organized in a tree-like structure.
*/
547type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
548type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
  id: string;
550};
551type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
  children?: AgnosticDataRouteObject[];
  id: string;
554};
555/**
* A data route object, which is just a RouteObject with a required unique ID
*/
558type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
559/**
* The parameters that were parsed from the URL path.
*/
562type Params<Key extends string = string> = {
  readonly [key in Key]: string | undefined;
564};
565/**
* A RouteMatch contains info about how a route matched a URL.
*/
568interface 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;
585}
586interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
587}
588/**
* Matches the given routes to a location and returns the match data.
*
* @category Utils
*/
593declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
594interface 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;
605}
606declare class DataWithResponseInit<D> {
  type: string;
  data: D;
  init: ResponseInit | null;
  constructor(data: D, init?: ResponseInit);
611}
612/**
* Create "responses" that contain `status`/`headers` without forcing
* serialization into an actual `Response` - used by Remix single fetch
*
* @category Utils
*/
618declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
619type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
620/**
* A redirect response. Sets the status code and the `Location` header.
* Defaults to "302 Found".
*
* @category Utils
*/
626declare const redirect$1: RedirectFunction;
627/**
* 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
*/
634declare const redirectDocument$1: RedirectFunction;
635/**
* 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
*/
643declare const replace$1: RedirectFunction;
644
645/**
* A Router instance manages all navigation and data loading/mutations
*/
648interface 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>;
839}
840/**
* State maintained internally by the router.  During a navigation, all states
* reflect the "old" location unless otherwise noted.
*/
844interface 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>;
901}
902/**
* Data that can be passed into hydrate a Router from SSR
*/
905type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
906/**
* Future flags to toggle new feature behavior
*/
909interface FutureConfig {
  unstable_middleware: boolean;
911}
912/**
* Initialization options for createRouter
*/
915interface 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;
927}
928/**
* State returned from a server-side query() call
*/
931interface 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;
942}
943/**
* A StaticHandler instance manages a singular SSR navigation/fetch event
*/
946interface 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>;
963}
964type ViewTransitionOpts = {
  currentLocation: Location;
  nextLocation: Location;
967};
968/**
* Subscriber function signature for changes to router state
*/
971interface RouterSubscriber {
  (state: RouterState, opts: {
      deletedFetchers: string[];
      viewTransitionOpts?: ViewTransitionOpts;
      flushSync: boolean;
  }): void;
977}
978/**
* Function signature for determining the key to be used in scroll restoration
* for a given location
*/
982interface GetScrollRestorationKeyFunction {
  (location: Location, matches: UIMatch[]): string | null;
984}
985/**
* Function signature for determining the current scroll position
*/
988interface GetScrollPositionFunction {
  (): number;
990}
991/**
* - "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.
*/
999type RelativeRoutingType = "route" | "path";
1000type BaseNavigateOrFetchOptions = {
  preventScrollReset?: boolean;
  relative?: RelativeRoutingType;
  flushSync?: boolean;
1004};
1005type BaseNavigateOptions = BaseNavigateOrFetchOptions & {
  replace?: boolean;
  state?: any;
  fromRouteId?: string;
  viewTransition?: boolean;
1010};
1011type BaseSubmissionOptions = {
  formMethod?: HTMLFormMethod;
  formEncType?: FormEncType;
1014} & ({
  formData: FormData;
  body?: undefined;
1017} | {
  formData?: undefined;
  body: any;
1020});
1021/**
* Options for a navigate() call for a normal (non-submission) navigation
*/
1024type LinkNavigateOptions = BaseNavigateOptions;
1025/**
* Options for a navigate() call for a submission navigation
*/
1028type SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;
1029/**
* Options to pass to navigate() for a navigation
*/
1032type RouterNavigateOptions = LinkNavigateOptions | SubmissionNavigateOptions;
1033/**
* Options for a fetch() load
*/
1036type LoadFetchOptions = BaseNavigateOrFetchOptions;
1037/**
* Options for a fetch() submission
*/
1040type SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;
1041/**
* Options to pass to fetch()
*/
1044type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;
1045/**
* Potential states for state.navigation
*/
1048type 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"];
  };
1079};
1080type Navigation = NavigationStates[keyof NavigationStates];
1081type RevalidationState = "idle" | "loading";
1082/**
* Potential states for fetchers
*/
1085type 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;
  };
1156};
1157type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
1158interface BlockerBlocked {
  state: "blocked";
  reset: () => void;
  proceed: () => void;
  location: Location;
1163}
1164interface BlockerUnblocked {
  state: "unblocked";
  reset: undefined;
  proceed: undefined;
  location: undefined;
1169}
1170interface BlockerProceeding {
  state: "proceeding";
  reset: undefined;
  proceed: undefined;
  location: Location;
1175}
1176type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
1177type BlockerFunction = (args: {
  currentLocation: Location;
  nextLocation: Location;
  historyAction: Action;
1181}) => boolean;
1182interface CreateStaticHandlerOptions {
  basename?: string;
  mapRouteProperties?: MapRoutePropertiesFunction;
  future?: {};
1186}
1187declare function createStaticHandler(routes: AgnosticRouteObject[], opts?: CreateStaticHandlerOptions): StaticHandler;
1188
1189interface 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>;
1208}
1209interface 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>;
1228}
1229type RouteObject = IndexRouteObject | NonIndexRouteObject;
1230type DataRouteObject = RouteObject & {
  children?: DataRouteObject[];
  id: string;
1233};
1234interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {
1235}
1236interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
1237}
1238
1239type Primitive = null | undefined | string | number | boolean | symbol | bigint;
1240type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
1241interface 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;
1303}
1304interface 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;
1326}
1327/**
* Represents a `<link>` element.
*
* WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
*/
1332type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
  imageSizes?: never;
1334});
1335interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
  /**
   * The absolute path of the page to prefetch.
   */
  page: string;
1340}
1341type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
1342
1343type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
  [key: PropertyKey]: Serializable;
1345} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
1346
1347type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
1348type IsAny<T> = 0 extends 1 & T ? true : false;
1349type Func = (...args: any[]) => unknown;
1350
1351/**
* 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.
*/
1357type unstable_SerializesTo<T> = {
  unstable__ReactRouter_SerializesTo: [T];
1359};
1360
1361type 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]>;
1363} : undefined;
1364type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
1365type DataFrom<T> = IsAny<T> extends true ? undefined : T extends Func ? VoidToUndefined<Awaited<ReturnType<T>>> : undefined;
1366type ClientData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? U : T;
1367type ServerData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? Serialize<U> : Serialize<T>;
1368type ServerDataFrom<T> = ServerData<DataFrom<T>>;
1369type ClientDataFrom<T> = ClientData<DataFrom<T>>;
1370type 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;
1401};
1402type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
  ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
1404] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
1405
1406/**
* A function that handles data mutations for a route on the client
*/
1409type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<ActionFunction>;
1410/**
* Arguments passed to a route `clientAction` function
*/
1413type ClientActionFunctionArgs = ActionFunctionArgs & {
  serverAction: <T = unknown>() => Promise<SerializeFrom<T>>;
1415};
1416/**
* A function that loads data for a route on the client
*/
1419type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<LoaderFunction>) & {
  hydrate?: boolean;
1421};
1422/**
* Arguments passed to a route `clientLoader` function
*/
1425type ClientLoaderFunctionArgs = LoaderFunctionArgs & {
  serverLoader: <T = unknown>() => Promise<SerializeFrom<T>>;
1427};
1428type HeadersArgs = {
  loaderHeaders: Headers;
  parentHeaders: Headers;
  actionHeaders: Headers;
  errorHeaders: Headers | undefined;
1433};
1434/**
* 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.
*/
1438interface HeadersFunction {
  (args: HeadersArgs): Headers | HeadersInit;
1440}
1441/**
* A function that defines `<link>` tags to be inserted into the `<head>` of
* the document on route transitions.
*
* @see https://remix.run/route/meta
*/
1447interface LinksFunction {
  (): LinkDescriptor[];
1449}
1450interface 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;
1458}
1459type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> = Array<{
  [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
1461}[keyof MatchLoaders]>;
1462interface 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;
1468}
1469/**
* 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"
* }
* ```
*/
1519interface MetaFunction<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
  (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
1521}
1522type MetaDescriptor = {
  charSet: "utf-8";
1524} | {
  title: string;
1526} | {
  name: string;
  content: string;
1529} | {
  property: string;
  content: string;
1532} | {
  httpEquiv: string;
  content: string;
1535} | {
  "script:ld+json": LdJsonObject;
1537} | {
  tagName: "meta" | "link";
  [name: string]: string;
1540} | {
  [name: string]: unknown;
1542};
1543type LdJsonObject = {
  [Key in string]: LdJsonValue;
1545} & {
  [Key in string]?: LdJsonValue | undefined;
1547};
1548type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
1549type LdJsonPrimitive = string | number | boolean | null;
1550type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
1551/**
* An arbitrary object that is associated with a route.
*
* @see https://remix.run/route/handle
*/
1556type RouteHandle = unknown;
1557
1558type ServerContext = {
  redirect?: Response;
1560};
1561declare global {
  var ___reactRouterServerStorage___: AsyncLocalStorage<ServerContext> | undefined;
1563}
1564declare const redirect: typeof redirect$1;
1565declare const redirectDocument: typeof redirectDocument$1;
1566declare const replace: typeof replace$1;
1567type RSCRouteConfigEntryBase = {
  action?: ActionFunction;
  clientAction?: ClientActionFunction;
  clientLoader?: ClientLoaderFunction;
  ErrorBoundary?: React.ComponentType<any>;
  handle?: any;
  headers?: HeadersFunction;
  HydrateFallback?: React.ComponentType<any>;
  Layout?: React.ComponentType<any>;
  links?: LinksFunction;
  loader?: LoaderFunction;
  meta?: MetaFunction;
  shouldRevalidate?: ShouldRevalidateFunction;
1580};
1581type RSCRouteConfigEntry = RSCRouteConfigEntryBase & {
  id: string;
  path?: string;
  Component?: React.ComponentType<any>;
  lazy?: () => Promise<RSCRouteConfigEntryBase & ({
      default?: React.ComponentType<any>;
      Component?: never;
  } | {
      default?: never;
      Component?: React.ComponentType<any>;
  })>;
1592} & ({
  index: true;
1594} | {
  children?: RSCRouteConfigEntry[];
1596});
1597type RSCRouteConfig = Array<RSCRouteConfigEntry>;
1598type RSCRouteManifest = {
  clientAction?: ClientActionFunction;
  clientLoader?: ClientLoaderFunction;
  element?: React.ReactElement | false;
  errorElement?: React.ReactElement;
  handle?: any;
  hasAction: boolean;
  hasComponent: boolean;
  hasErrorBoundary: boolean;
  hasLoader: boolean;
  hydrateFallbackElement?: React.ReactElement;
  id: string;
  index?: boolean;
  links?: LinksFunction;
  meta?: MetaFunction;
  parentId?: string;
  path?: string;
  shouldRevalidate?: ShouldRevalidateFunction;
1616};
1617type RSCRouteMatch = RSCRouteManifest & {
  params: Params;
  pathname: string;
  pathnameBase: string;
1621};
1622type RSCRenderPayload = {
  type: "render";
  actionData: Record<string, any> | null;
  basename: string | undefined;
  errors: Record<string, any> | null;
  loaderData: Record<string, any>;
  location: Location;
  matches: RSCRouteMatch[];
  patches?: RSCRouteManifest[];
  nonce?: string;
  formState?: unknown;
1633};
1634type RSCManifestPayload = {
  type: "manifest";
  patches: RSCRouteManifest[];
1637};
1638type RSCActionPayload = {
  type: "action";
  actionResult: Promise<unknown>;
  rerender?: Promise<RSCRenderPayload | RSCRedirectPayload>;
1642};
1643type RSCRedirectPayload = {
  type: "redirect";
  status: number;
  location: string;
  replace: boolean;
  reload: boolean;
  actionResult?: Promise<unknown>;
1650};
1651type RSCPayload = RSCRenderPayload | RSCManifestPayload | RSCActionPayload | RSCRedirectPayload;
1652type RSCMatch = {
  statusCode: number;
  headers: Headers;
  payload: RSCPayload;
1656};
1657type DecodeActionFunction = (formData: FormData) => Promise<() => Promise<unknown>>;
1658type DecodeFormStateFunction = (result: unknown, formData: FormData) => unknown;
1659type DecodeReplyFunction = (reply: FormData | string, { temporaryReferences }: {
  temporaryReferences: unknown;
1661}) => Promise<unknown[]>;
1662type LoadServerActionFunction = (id: string) => Promise<Function>;
1663/**
* Matches the given routes to a Request and returns a RSC Response encoding an
* `RSCPayload` for consumption by a RSC enabled client router.
*
* @example
* import {
*   createTemporaryReferenceSet,
*   decodeAction,
*   decodeReply,
*   loadServerAction,
*   renderToReadableStream,
* } from "@vitejs/plugin-rsc/rsc";
* import { unstable_matchRSCServerRequest as matchRSCServerRequest } from "react-router";
*
* matchRSCServerRequest({
*   createTemporaryReferenceSet,
*   decodeAction,
*   decodeFormState,
*   decodeReply,
*   loadServerAction,
*   request,
*   routes: routes(),
*   generateResponse(match) {
*     return new Response(
*       renderToReadableStream(match.payload),
*       {
*         status: match.statusCode,
*         headers: match.headers,
*       }
*     );
*   },
* });
*
* @name unstable_matchRSCServerRequest
* @public
* @category RSC
* @mode data
* @param opts Options
* @param opts.basename The basename to use when matching the request.
* @param opts.decodeAction Your `react-server-dom-xyz/server`'s `decodeAction`
* function, responsible for loading a server action.
* @param opts.decodeReply Your `react-server-dom-xyz/server`'s `decodeReply`
* function, used to decode the server function's arguments and bind them to the
* implementation for invocation by the router.
* @param opts.decodeFormState A function responsible for decoding form state for
* progressively enhanceable forms with `useActionState` using your
* `react-server-dom-xyz/server`'s `decodeFormState`.
* @param opts.generateResponse A function responsible for using your
* `renderToReadableStream` to generate a Response encoding the `RSCPayload`.
* @param opts.loadServerAction Your `react-server-dom-xyz/server`'s
* `loadServerAction` function, used to load a server action by ID.
* @param opts.request The request to match against.
* @param opts.requestContext An instance of `unstable_RouterContextProvider`
* that should be created per request, to be passed to loaders, actions and middleware.
* @param opts.routes Your route definitions.
* @param opts.createTemporaryReferenceSet A function that returns a temporary
* reference set for the request, used to track temporary references in the RSC stream.
* @param opts.onError An optional error handler that will be called with any
* errors that occur during the request processing.
* @returns A Response that contains the RSC data for hydration.
*/
1724declare function matchRSCServerRequest({ createTemporaryReferenceSet, basename, decodeReply, requestContext, loadServerAction, decodeAction, decodeFormState, onError, request, routes, generateResponse, }: {
  createTemporaryReferenceSet: () => unknown;
  basename?: string;
  decodeReply?: DecodeReplyFunction;
  decodeAction?: DecodeActionFunction;
  decodeFormState?: DecodeFormStateFunction;
  requestContext?: unstable_RouterContextProvider;
  loadServerAction?: LoadServerActionFunction;
  onError?: (error: unknown) => void;
  request: Request;
  routes: RSCRouteConfigEntry[];
  generateResponse: (match: RSCMatch, { temporaryReferences, }: {
      temporaryReferences: unknown;
  }) => Response;
1738}): Promise<Response>;
1739
1740interface CookieSignatureOptions {
  /**
   * An array of secrets that may be used to sign/unsign the value of a cookie.
   *
   * The array makes it easy to rotate secrets. New secrets should be added to
   * the beginning of the array. `cookie.serialize()` will always use the first
   * value in the array, but `cookie.parse()` may use any of them so that
   * cookies that were signed with older secrets still work.
   */
  secrets?: string[];
1750}
1751type CookieOptions = ParseOptions & SerializeOptions & CookieSignatureOptions;
1752/**
* A HTTP cookie.
*
* A Cookie is a logical container for metadata about a HTTP cookie; its name
* and options. But it doesn't contain a value. Instead, it has `parse()` and
* `serialize()` methods that allow a single instance to be reused for
* parsing/encoding multiple different values.
*
* @see https://remix.run/utils/cookies#cookie-api
*/
1762interface Cookie {
  /**
   * The name of the cookie, used in the `Cookie` and `Set-Cookie` headers.
   */
  readonly name: string;
  /**
   * True if this cookie uses one or more secrets for verification.
   */
  readonly isSigned: boolean;
  /**
   * The Date this cookie expires.
   *
   * Note: This is calculated at access time using `maxAge` when no `expires`
   * option is provided to `createCookie()`.
   */
  readonly expires?: Date;
  /**
   * Parses a raw `Cookie` header and returns the value of this cookie or
   * `null` if it's not present.
   */
  parse(cookieHeader: string | null, options?: ParseOptions): Promise<any>;
  /**
   * Serializes the given value to a string and returns the `Set-Cookie`
   * header.
   */
  serialize(value: any, options?: SerializeOptions): Promise<string>;
1788}
1789/**
* Creates a logical container for managing a browser cookie from the server.
*/
1792declare const createCookie: (name: string, cookieOptions?: CookieOptions) => Cookie;
1793type IsCookieFunction = (object: any) => object is Cookie;
1794/**
* Returns true if an object is a Remix cookie container.
*
* @see https://remix.run/utils/cookies#iscookie
*/
1799declare const isCookie: IsCookieFunction;
1800
1801/**
* An object of name/value pairs to be used in the session.
*/
1804interface SessionData {
  [name: string]: any;
1806}
1807/**
* Session persists data across HTTP requests.
*
* @see https://reactrouter.com/explanation/sessions-and-cookies#sessions
*/
1812interface Session<Data = SessionData, FlashData = Data> {
  /**
   * A unique identifier for this session.
   *
   * Note: This will be the empty string for newly created sessions and
   * sessions that are not backed by a database (i.e. cookie-based sessions).
   */
  readonly id: string;
  /**
   * The raw data contained in this session.
   *
   * This is useful mostly for SessionStorage internally to access the raw
   * session data to persist.
   */
  readonly data: FlashSessionData<Data, FlashData>;
  /**
   * Returns `true` if the session has a value for the given `name`, `false`
   * otherwise.
   */
  has(name: (keyof Data | keyof FlashData) & string): boolean;
  /**
   * Returns the value for the given `name` in this session.
   */
  get<Key extends (keyof Data | keyof FlashData) & string>(name: Key): (Key extends keyof Data ? Data[Key] : undefined) | (Key extends keyof FlashData ? FlashData[Key] : undefined) | undefined;
  /**
   * Sets a value in the session for the given `name`.
   */
  set<Key extends keyof Data & string>(name: Key, value: Data[Key]): void;
  /**
   * Sets a value in the session that is only valid until the next `get()`.
   * This can be useful for temporary values, like error messages.
   */
  flash<Key extends keyof FlashData & string>(name: Key, value: FlashData[Key]): void;
  /**
   * Removes a value from the session.
   */
  unset(name: keyof Data & string): void;
1849}
1850type FlashSessionData<Data, FlashData> = Partial<Data & {
  [Key in keyof FlashData as FlashDataKey<Key & string>]: FlashData[Key];
1852}>;
1853type FlashDataKey<Key extends string> = `__flash_${Key}__`;
1854type CreateSessionFunction = <Data = SessionData, FlashData = Data>(initialData?: Data, id?: string) => Session<Data, FlashData>;
1855/**
* Creates a new Session object.
*
* Note: This function is typically not invoked directly by application code.
* Instead, use a `SessionStorage` object's `getSession` method.
*/
1861declare const createSession: CreateSessionFunction;
1862type IsSessionFunction = (object: any) => object is Session;
1863/**
* Returns true if an object is a React Router session.
*
* @see https://reactrouter.com/api/utils/isSession
*/
1868declare const isSession: IsSessionFunction;
1869/**
* SessionStorage stores session data between HTTP requests and knows how to
* parse and create cookies.
*
* A SessionStorage creates Session objects using a `Cookie` header as input.
* Then, later it generates the `Set-Cookie` header to be used in the response.
*/
1876interface SessionStorage<Data = SessionData, FlashData = Data> {
  /**
   * Parses a Cookie header from a HTTP request and returns the associated
   * Session. If there is no session associated with the cookie, this will
   * return a new Session with no data.
   */
  getSession: (cookieHeader?: string | null, options?: ParseOptions) => Promise<Session<Data, FlashData>>;
  /**
   * Stores all data in the Session and returns the Set-Cookie header to be
   * used in the HTTP response.
   */
  commitSession: (session: Session<Data, FlashData>, options?: SerializeOptions) => Promise<string>;
  /**
   * Deletes all data associated with the Session and returns the Set-Cookie
   * header to be used in the HTTP response.
   */
  destroySession: (session: Session<Data, FlashData>, options?: SerializeOptions) => Promise<string>;
1893}
1894/**
* SessionIdStorageStrategy is designed to allow anyone to easily build their
* own SessionStorage using `createSessionStorage(strategy)`.
*
* This strategy describes a common scenario where the session id is stored in
* a cookie but the actual session data is stored elsewhere, usually in a
* database or on disk. A set of create, read, update, and delete operations
* are provided for managing the session data.
*/
1903interface SessionIdStorageStrategy<Data = SessionData, FlashData = Data> {
  /**
   * The Cookie used to store the session id, or options used to automatically
   * create one.
   */
  cookie?: Cookie | (CookieOptions & {
      name?: string;
  });
  /**
   * Creates a new record with the given data and returns the session id.
   */
  createData: (data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<string>;
  /**
   * Returns data for a given session id, or `null` if there isn't any.
   */
  readData: (id: string) => Promise<FlashSessionData<Data, FlashData> | null>;
  /**
   * Updates data for the given session id.
   */
  updateData: (id: string, data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<void>;
  /**
   * Deletes data for a given session id from the data store.
   */
  deleteData: (id: string) => Promise<void>;
1927}
1928/**
* Creates a SessionStorage object using a SessionIdStorageStrategy.
*
* Note: This is a low-level API that should only be used if none of the
* existing session storage options meet your requirements.
*/
1934declare function createSessionStorage<Data = SessionData, FlashData = Data>({ cookie: cookieArg, createData, readData, updateData, deleteData, }: SessionIdStorageStrategy<Data, FlashData>): SessionStorage<Data, FlashData>;
1935
1936interface CookieSessionStorageOptions {
  /**
   * The Cookie used to store the session data on the client, or options used
   * to automatically create one.
   */
  cookie?: SessionIdStorageStrategy["cookie"];
1942}
1943/**
* Creates and returns a SessionStorage object that stores all session data
* directly in the session cookie itself.
*
* This has the advantage that no database or other backend services are
* needed, and can help to simplify some load-balanced scenarios. However, it
* also has the limitation that serialized session data may not exceed the
* browser's maximum cookie size. Trade-offs!
*/
1952declare function createCookieSessionStorage<Data = SessionData, FlashData = Data>({ cookie: cookieArg }?: CookieSessionStorageOptions): SessionStorage<Data, FlashData>;
1953
1954interface MemorySessionStorageOptions {
  /**
   * The Cookie used to store the session id on the client, or options used
   * to automatically create one.
   */
  cookie?: SessionIdStorageStrategy["cookie"];
1960}
1961/**
* Creates and returns a simple in-memory SessionStorage object, mostly useful
* for testing and as a reference implementation.
*
* Note: This storage does not scale beyond a single process, so it is not
* suitable for most production scenarios.
*/
1968declare function createMemorySessionStorage<Data = SessionData, FlashData = Data>({ cookie }?: MemorySessionStorageOptions): SessionStorage<Data, FlashData>;
1969
1970export { type Cookie, type CookieOptions, type CookieSignatureOptions, type FlashSessionData, type IsCookieFunction, type IsSessionFunction, type Session, type SessionData, type SessionIdStorageStrategy, type SessionStorage, createCookie, createCookieSessionStorage, createMemorySessionStorage, createSession, createSessionStorage, createStaticHandler, data, isCookie, isSession, matchRoutes, redirect, redirectDocument, replace, type DecodeActionFunction as unstable_DecodeActionFunction, type DecodeFormStateFunction as unstable_DecodeFormStateFunction, type DecodeReplyFunction as unstable_DecodeReplyFunction, type LoadServerActionFunction as unstable_LoadServerActionFunction, type unstable_MiddlewareFunction, type unstable_MiddlewareNextFunction, type RSCManifestPayload as unstable_RSCManifestPayload, type RSCMatch as unstable_RSCMatch, type RSCPayload as unstable_RSCPayload, type RSCRenderPayload as unstable_RSCRenderPayload, type RSCRouteConfig as unstable_RSCRouteConfig, type RSCRouteConfigEntry as unstable_RSCRouteConfigEntry, type RSCRouteManifest as unstable_RSCRouteManifest, type RSCRouteMatch as unstable_RSCRouteMatch, type unstable_RouterContext, unstable_RouterContextProvider, unstable_createContext, matchRSCServerRequest as unstable_matchRSCServerRequest };