UNPKG

react-router/dist/production/data-BqZ2x964.d.ts

Version:
68.5 kBTypeScriptView Raw
1import * as React from 'react';
2import { ComponentType, ReactElement } from 'react';
3
4/**
* An augmentable interface users can modify in their app-code to opt into
* future-flag-specific types
*/
8interface Future {
9}
10type MiddlewareEnabled = Future extends {
  v8_middleware: infer T extends boolean;
12} ? T : false;
13
14/**
* Actions represent the type of change to a location value.
*/
17declare enum Action {
  /**
   * A POP indicates a change to an arbitrary index in the history stack, such
   * as a back or forward navigation. It does not describe the direction of the
   * navigation, only that the current index changed.
   *
   * Note: This is the default action for newly created history objects.
   */
  Pop = "POP",
  /**
   * A PUSH indicates a new entry being added to the history stack, such as when
   * a link is clicked and a new page loads. When this happens, all subsequent
   * entries in the stack are lost.
   */
  Push = "PUSH",
  /**
   * A REPLACE indicates the entry at the current index in the history stack
   * being replaced by a new one.
   */
  Replace = "REPLACE"
37}
38/**
* The pathname, search, and hash values of a URL.
*/
41interface Path {
  /**
   * A URL pathname, beginning with a /.
   */
  pathname: string;
  /**
   * A URL search string, beginning with a ?.
   */
  search: string;
  /**
   * A URL fragment identifier, beginning with a #.
   */
  hash: string;
54}
55/**
* An entry in a history stack. A location contains information about the
* URL path, as well as possibly some arbitrary state and a key.
*/
59interface Location<State = any> extends Path {
  /**
   * A value of arbitrary data associated with this location.
   */
  state: State;
  /**
   * A unique string associated with this location. May be used to safely store
   * and retrieve data in some other storage API, like `localStorage`.
   *
   * Note: This value is always "default" on the initial location.
   */
  key: string;
  /**
   * The masked location displayed in the URL bar, which differs from the URL the
   * router is operating on
   */
  mask?: Path;
76}
77/**
* A change to the current location.
*/
80interface 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;
93}
94/**
* A function that receives notifications about location changes.
*/
97interface Listener {
  (update: Update): void;
99}
100/**
* Describes a location that is the destination of some navigation used in
* {@link Link}, {@link useNavigate}, etc.
*/
104type To = string | Partial<Path>;
105/**
* 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.
*/
113interface 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;
176}
177/**
* A user-supplied object that describes a location. Used when providing
* entries to `createMemoryHistory` via its `initialEntries` option.
*/
181type InitialEntry = string | Partial<Location>;
182type MemoryHistoryOptions = {
  initialEntries?: InitialEntry[];
  initialIndex?: number;
  v5Compat?: boolean;
186};
187/**
* A memory history stores locations in memory. This is useful in stateful
* environments where there is no web browser, such as node tests or React
* Native.
*/
192interface MemoryHistory extends History {
  /**
   * The current index in the history stack.
   */
  readonly index: number;
197}
198/**
* Memory history stores the current location in memory. It is designed for use
* in stateful non-browser environments like tests and React Native.
*/
202declare function createMemoryHistory(options?: MemoryHistoryOptions): MemoryHistory;
203/**
* 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
*/
210interface BrowserHistory extends UrlHistory {
211}
212type BrowserHistoryOptions = UrlHistoryOptions;
213/**
* 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
*/
220declare function createBrowserHistory(options?: BrowserHistoryOptions): BrowserHistory;
221/**
* A hash history stores the current location in the fragment identifier portion
* of the URL in a web browser environment.
*
* This is ideal for apps that do not control the server for some reason
* (because the fragment identifier is never sent to the server), including some
* shared hosting environments that do not provide fine-grained controls over
* which pages are served at which URLs.
*
* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
*/
232interface HashHistory extends UrlHistory {
233}
234type HashHistoryOptions = UrlHistoryOptions;
235/**
* Hash history stores the location in window.location.hash. This makes it ideal
* for situations where you don't want to send the location to the server for
* some reason, either because you do cannot configure it or the URL space is
* reserved for something else.
*
* @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
*/
243declare function createHashHistory(options?: HashHistoryOptions): HashHistory;
244/**
* @private
*/
247declare function invariant(value: boolean, message?: string): asserts value;
248declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
249/**
* Creates a string URL path from the given pathname, search, and hash components.
*
* @category Utils
*/
254declare function createPath({ pathname, search, hash, }: Partial<Path>): string;
255/**
* Parses a string URL path into its separate pathname, search, and hash components.
*
* @category Utils
*/
260declare function parsePath(path: string): Partial<Path>;
261interface UrlHistory extends History {
262}
263type UrlHistoryOptions = {
  window?: Window;
  v5Compat?: boolean;
266};
267
268type MaybePromise<T> = T | Promise<T>;
269/**
* Map of routeId -> data returned from a loader/action/error
*/
272interface RouteData {
  [routeId: string]: any;
274}
275type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
276type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
277/**
* Users can specify either lowercase or uppercase form methods on `<Form>`,
* useSubmit(), `<fetcher.Form>`, etc.
*/
281type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
282/**
* Active navigation/fetcher form methods are exposed in uppercase on the
* RouterState. This is to align with the normalization done via fetch().
*/
286type FormMethod = UpperCaseFormMethod;
287type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
288type JsonObject = {
  [Key in string]: JsonValue;
290} & {
  [Key in string]?: JsonValue | undefined;
292};
293type JsonArray = JsonValue[] | readonly JsonValue[];
294type JsonPrimitive = string | number | boolean | null;
295type JsonValue = JsonPrimitive | JsonObject | JsonArray;
296/**
* @private
* Internal interface to pass around for action submissions, not intended for
* external consumption
*/
301type Submission = {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: FormData;
  json: undefined;
  text: undefined;
308} | {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: undefined;
  json: JsonValue;
  text: undefined;
315} | {
  formMethod: FormMethod;
  formAction: string;
  formEncType: FormEncType;
  formData: undefined;
  json: undefined;
  text: string;
322};
323/**
* A context instance used as the key for the `get`/`set` methods of a
* {@link RouterContextProvider}. Accepts an optional default
* value to be returned if no value has been set.
*/
328interface RouterContext<T = unknown> {
  defaultValue?: T;
330}
331/**
* Creates a type-safe {@link RouterContext} object that can be used to
* store and retrieve arbitrary values in [`action`](../../start/framework/route-module#action)s,
* [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
* Similar to React's [`createContext`](https://react.dev/reference/react/createContext),
* but specifically designed for React Router's request/response lifecycle.
*
* If a `defaultValue` is provided, it will be returned from `context.get()`
* when no value has been set for the context. Otherwise, reading this context
* when no value has been set will throw an error.
*
* ```tsx filename=app/context.ts
* import { createContext } from "react-router";
*
* // Create a context for user data
* export const userContext =
*   createContext<User | null>(null);
* ```
*
* ```tsx filename=app/middleware/auth.ts
* import { getUserFromSession } from "~/auth.server";
* import { userContext } from "~/context";
*
* export const authMiddleware = async ({
*   context,
*   request,
* }) => {
*   const user = await getUserFromSession(request);
*   context.set(userContext, user);
* };
* ```
*
* ```tsx filename=app/routes/profile.tsx
* import { userContext } from "~/context";
*
* export async function loader({
*   context,
* }: Route.LoaderArgs) {
*   const user = context.get(userContext);
*
*   if (!user) {
*     throw new Response("Unauthorized", { status: 401 });
*   }
*
*   return { user };
* }
* ```
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param defaultValue An optional default value for the context. This value
* will be returned if no value has been set for this context.
* @returns A {@link RouterContext} object that can be used with
* `context.get()` and `context.set()` in [`action`](../../start/framework/route-module#action)s,
* [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
*/
389declare function createContext<T>(defaultValue?: T): RouterContext<T>;
390/**
* Provides methods for writing/reading values in application context in a
* type-safe way. Primarily for usage with [middleware](../../how-to/middleware).
*
* @example
* import {
*   createContext,
*   RouterContextProvider
* } from "react-router";
*
* const userContext = createContext<User | null>(null);
* const contextProvider = new RouterContextProvider();
* contextProvider.set(userContext, getUser());
* //                               ^ Type-safe
* const user = contextProvider.get(userContext);
* //    ^ User
*
* @public
* @category Utils
* @mode framework
* @mode data
*/
412declare class RouterContextProvider {
  #private;
  /**
   * Create a new `RouterContextProvider` instance
   * @param init An optional initial context map to populate the provider with
   */
  constructor(init?: Map<RouterContext, unknown>);
  /**
   * Access a value from the context. If no value has been set for the context,
   * it will return the context's `defaultValue` if provided, or throw an error
   * if no `defaultValue` was set.
   * @param context The context to get the value for
   * @returns The value for the context, or the context's `defaultValue` if no
   * value was set
   */
  get<T>(context: RouterContext<T>): T;
  /**
   * Set a value for the context. If the context already has a value set, this
   * will overwrite it.
   *
   * @param context The context to set the value for
   * @param value The value to set for the context
   * @returns {void}
   */
  set<C extends RouterContext>(context: C, value: C extends RouterContext<infer T> ? T : never): void;
437}
438type DefaultContext = MiddlewareEnabled extends true ? Readonly<RouterContextProvider> : any;
439/**
* @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.
*/
444interface 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;
  /**
   * A URL instance representing the application location being navigated to or
   * fetched. By default, this matches `request.url`.
   *
   * In Framework mode with `future.v8_passThroughRequests` enabled, this is a
   * normalized URL with React-Router-specific implementation details removed
   * (`.data` suffixes, `index`/`_routes` search params).
   */
  url: URL;
  /**
   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
   */
  pattern: string;
  /**
   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
   * @example
   * // app/routes.ts
   * route("teams/:teamId", "./team.tsx"),
   *
   * // app/team.tsx
   * export function loader({
   *   params,
   * }: Route.LoaderArgs) {
   *   params.teamId;
   *   //        ^ string
   * }
   */
  params: Params;
  /**
   * This is the context passed in to your server adapter's getLoadContext() function.
   * It's a way to bridge the gap between the adapter's request/response API with your React Router app.
   * It is only applicable if you are using a custom server adapter.
   */
  context: Context;
482}
483/**
* Route middleware `next` function to call downstream handlers and then complete
* middlewares from the bottom-up
*/
487interface MiddlewareNextFunction<Result = unknown> {
  (): Promise<Result>;
489}
490/**
* 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
*/
496type MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<Readonly<RouterContextProvider>>, next: MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
497/**
* Arguments passed to loader functions
*/
500interface LoaderFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
501}
502/**
* Arguments passed to action functions
*/
505interface ActionFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
506}
507/**
* Loaders and actions can return anything
*/
510type DataFunctionValue = unknown;
511type DataFunctionReturnValue = MaybePromise<DataFunctionValue>;
512/**
* Route loader function signature
*/
515type LoaderFunction<Context = DefaultContext> = {
  (args: LoaderFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
517} & {
  hydrate?: boolean;
519};
520/**
* Route action function signature
*/
523interface ActionFunction<Context = DefaultContext> {
  (args: ActionFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
525}
526/**
* Arguments passed to shouldRevalidate function
*/
529interface 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: DataRouteMatch["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: DataRouteMatch["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;
581}
582/**
* 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.
*/
589interface ShouldRevalidateFunction {
  (args: ShouldRevalidateFunctionArgs): boolean;
591}
592interface DataStrategyMatch extends RouteMatch<string, DataRouteObject> {
  /**
   * @private
   */
  _lazyPromises?: {
      middleware: Promise<void> | undefined;
      handler: Promise<void> | undefined;
      route: Promise<void> | undefined;
  };
  /**
   * @deprecated Deprecated in favor of `shouldCallHandler`
   *
   * A boolean value indicating whether this route handler should be called in
   * this pass.
   *
   * The `matches` array always includes _all_ matched routes even when only
   * _some_ route handlers need to be called so that things like middleware can
   * be implemented.
   *
   * `shouldLoad` is usually only interesting if you are skipping the route
   * handler entirely and implementing custom handler logic - since it lets you
   * determine if that custom logic should run for this route or not.
   *
   * For example:
   *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
   *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
   *    will have `shouldLoad=true` because the data for `parent` and `child` is
   *    already loaded
   *  - If you are on `/parent/child/a` and you submit to `a`'s [`action`](https://reactrouter.com/docs/start/data/route-object#action),
   *    then only `a` will have `shouldLoad=true` for the action execution of
   *    `dataStrategy`
   *  - After the [`action`](https://reactrouter.com/docs/start/data/route-object#action),
   *    `dataStrategy` will be called again for the [`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
   *    revalidation, and all matches will have `shouldLoad=true` (assuming no
   *    custom `shouldRevalidate` implementations)
   */
  shouldLoad: boolean;
  /**
   * Arguments passed to the `shouldRevalidate` function for this `loader` execution.
   * Will be `null` if this is not a revalidating loader {@link DataStrategyMatch}.
   */
  shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
  /**
   * Determine if this route's handler should be called during this `dataStrategy`
   * execution. Calling it with no arguments will leverage the default revalidation
   * behavior. You can pass your own `defaultShouldRevalidate` value if you wish
   * to change the default revalidation behavior with your `dataStrategy`.
   *
   * @param defaultShouldRevalidate `defaultShouldRevalidate` override value (optional)
   */
  shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
  /**
   * An async function that will resolve any `route.lazy` implementations and
   * execute the route's handler (if necessary), returning a {@link DataStrategyResult}
   *
   * - Calling `match.resolve` does not mean you're calling the
   *   [`action`](https://reactrouter.com/docs/start/data/route-object#action)/[`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
   *   (the "handler") - `resolve` will only call the `handler` internally if
   *   needed _and_ if you don't pass your own `handlerOverride` function parameter
   * - It is safe to call `match.resolve` for all matches, even if they have
   *   `shouldLoad=false`, and it will no-op if no loading is required
   * - You should generally always call `match.resolve()` for `shouldLoad:true`
   *   routes to ensure that any `route.lazy` implementations are processed
   * - See the examples below for how to implement custom handler execution via
   *   `match.resolve`
   */
  resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
659}
660interface DataStrategyFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {
  /**
   * Matches for this route extended with Data strategy APIs
   */
  matches: DataStrategyMatch[];
  runClientMiddleware: (cb: DataStrategyFunction<Context>) => Promise<Record<string, DataStrategyResult>>;
  /**
   * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
   * for navigational executions
   */
  fetcherKey: string | null;
671}
672/**
* Result from a loader or action called via dataStrategy
*/
675interface DataStrategyResult {
  type: "data" | "error";
  result: unknown;
678}
679interface DataStrategyFunction<Context = DefaultContext> {
  (args: DataStrategyFunctionArgs<Context>): Promise<Record<string, DataStrategyResult>>;
681}
682type PatchRoutesOnNavigationFunctionArgs = {
  signal: AbortSignal;
  path: string;
  matches: RouteMatch[];
  fetcherKey: string | undefined;
  patch: (routeId: string | null, children: RouteObject[]) => void;
688};
689type PatchRoutesOnNavigationFunction = (opts: PatchRoutesOnNavigationFunctionArgs) => MaybePromise<void>;
690/**
* Function provided to set route-specific properties from route objects
*/
693interface MapRoutePropertiesFunction {
  (route: DataRouteObject): {
      hasErrorBoundary: boolean;
  } & Record<string, any>;
697}
698/**
* 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.
*/
703type UnsupportedLazyRouteObjectKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
704/**
* 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.
*/
709type UnsupportedLazyRouteFunctionKey = UnsupportedLazyRouteObjectKey | "middleware";
710/**
* lazy object to load route properties, which can add non-matching
* related properties to a route
*/
714type LazyRouteObject<R extends RouteObject> = {
  [K in keyof R as K extends UnsupportedLazyRouteObjectKey ? never : K]?: () => Promise<R[K] | null | undefined>;
716};
717/**
* lazy() function to load a route definition, which can add non-matching
* related properties to a route
*/
721interface LazyRouteFunction<R extends RouteObject> {
  (): Promise<Omit<R, UnsupportedLazyRouteFunctionKey> & Partial<Record<UnsupportedLazyRouteFunctionKey, never>>>;
723}
724type LazyRouteDefinition<R extends RouteObject> = LazyRouteObject<R> | LazyRouteFunction<R>;
725/**
* Base RouteObject with common props shared by all types of routes
* @internal
*/
729type BaseRouteObject = {
  /**
   * Whether the path should be case-sensitive. Defaults to `false`.
   */
  caseSensitive?: boolean;
  /**
   * The path pattern to match. If unspecified or empty, then this becomes a
   * layout route.
   */
  path?: string;
  /**
   * The unique identifier for this route (for use with {@link DataRouter}s)
   */
  id?: string;
  /**
   * The route middleware.
   * See [`middleware`](../../start/data/route-object#middleware).
   */
  middleware?: MiddlewareFunction[];
  /**
   * The route loader.
   * See [`loader`](../../start/data/route-object#loader).
   */
  loader?: LoaderFunction | boolean;
  /**
   * The route action.
   * See [`action`](../../start/data/route-object#action).
   */
  action?: ActionFunction | boolean;
  hasErrorBoundary?: boolean;
  /**
   * The route shouldRevalidate function.
   * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
   */
  shouldRevalidate?: ShouldRevalidateFunction;
  /**
   * The route handle.
   */
  handle?: any;
  /**
   * A function that returns a promise that resolves to the route object.
   * Used for code-splitting routes.
   * See [`lazy`](../../start/data/route-object#lazy).
   */
  lazy?: LazyRouteDefinition<BaseRouteObject>;
  /**
   * The React Component to render when this route matches.
   * Mutually exclusive with `element`.
   */
  Component?: React.ComponentType | null;
  /**
   * The React element to render when this Route matches.
   * Mutually exclusive with `Component`.
   */
  element?: React.ReactNode | null;
  /**
   * The React Component to render at this route if an error occurs.
   * Mutually exclusive with `errorElement`.
   */
  ErrorBoundary?: React.ComponentType | null;
  /**
   * The React element to render at this route if an error occurs.
   * Mutually exclusive with `ErrorBoundary`.
   */
  errorElement?: React.ReactNode | null;
  /**
   * The React Component to render while this router is loading data.
   * Mutually exclusive with `hydrateFallbackElement`.
   */
  HydrateFallback?: React.ComponentType | null;
  /**
   * The React element to render while this router is loading data.
   * Mutually exclusive with `HydrateFallback`.
   */
  hydrateFallbackElement?: React.ReactNode | null;
804};
805/**
* Index routes must not have children
*/
808type IndexRouteObject = BaseRouteObject & {
  /**
   * Child Route objects - not valid on index routes.
   */
  children?: undefined;
  /**
   * Whether this is an index route.
   */
  index: true;
817};
818/**
* Non-index routes may have children, but cannot have `index` set to `true`.
*/
821type NonIndexRouteObject = BaseRouteObject & {
  /**
   * Child Route objects.
   */
  children?: RouteObject[];
  /**
   * Whether this is an index route - must be `false` or undefined on non-index routes.
   */
  index?: false;
830};
831/**
* A route object represents a logical route, with (optionally) its child
* routes organized in a tree-like structure.
*/
835type RouteObject = IndexRouteObject | NonIndexRouteObject;
836type DataIndexRouteObject = IndexRouteObject & {
  id: string;
838};
839type DataNonIndexRouteObject = NonIndexRouteObject & {
  children?: DataRouteObject[];
  id: string;
842};
843/**
* A data route object, which is just a RouteObject with a required unique ID
*/
846type DataRouteObject = DataIndexRouteObject | DataNonIndexRouteObject;
847type RouteManifest<R = DataRouteObject> = Record<string, R | undefined>;
848type 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";
849type Regex_AZ = Uppercase<Regex_az>;
850type Regex_09 = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
851type Regex_w = Regex_az | Regex_AZ | Regex_09 | "_";
852/** Emulates Regex `+` operator */
853type RegexMatchPlus<char extends string, T extends string> = _RegexMatchPlus<char, T> extends infer result extends string ? result extends '' ? never : result : never;
854type _RegexMatchPlus<char extends string, T extends string> = T extends `${infer head extends char}${infer rest}` ? `${head}${_RegexMatchPlus<char, rest>}` : '';
855type ParamNameChar = Regex_w | "-";
856type Simplify<T> = {
  [K in keyof T]: T[K];
858} & {};
859type GeneratePathParams<path extends string> = Simplify<ParseParams<path> & {
  [key in string]: string | null | undefined;
861}>;
862type ParseParams<path extends string> = path extends '*' ? {
  '*': string;
864} : path extends `${infer rest}/*` ? {
  '*': string;
866} & ParseParams<rest> : _ParseParams<path>;
867type _ParseParams<path extends string> = path extends `${infer left}/${infer right}` ? _ParseParams<left> & _ParseParams<right> : path extends `:${infer param}?${string}` ? {
  [key in RegexMatchPlus<ParamNameChar, param>]?: string | null | undefined;
869} : path extends `:${infer param}` ? {
  [key in RegexMatchPlus<ParamNameChar, param>]: string;
871} : {};
872type PathParam<path extends string> = (keyof ParseParams<path>) & string;
873type ParamParseKey<Segment extends string> = [
  PathParam<Segment>
875] extends [never] ? string : PathParam<Segment>;
876/**
* The parameters that were parsed from the URL path.
*/
879type Params<Key extends string = string> = {
  readonly [key in Key]: string | undefined;
881};
882/**
* A RouteMatch contains info about how a route matched a URL.
*/
885interface RouteMatch<ParamKey extends string = string, RouteObjectType extends RouteObject = RouteObject> {
  /**
   * 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;
902}
903interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {
904}
905/**
* Matches the given routes to a location and returns the match data.
*
* @example
* import { matchRoutes } from "react-router";
*
* let routes = [{
*   path: "/",
*   Component: Root,
*   children: [{
*     path: "dashboard",
*     Component: Dashboard,
*   }]
* }];
*
* matchRoutes(routes, "/dashboard"); // [rootMatch, dashboardMatch]
*
* @public
* @category Utils
* @param routes The array of route objects to match against.
* @param locationArg The location to match against, either a string path or a
* partial {@link Location} object
* @param basename Optional base path to strip from the location before matching.
* Defaults to `/`.
* @returns An array of matched routes, or `null` if no matches were found.
*/
931declare function matchRoutes<RouteObjectType extends RouteObject = RouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): RouteMatch<string, RouteObjectType>[] | null;
932interface 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: RouteMatch["params"];
  /**
   * The return value from the matched route's loader or clientLoader. This might
   * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
   * an error and we're currently displaying an `ErrorBoundary`.
   *
   * @deprecated Use `UIMatch.loaderData` instead
   */
  data: Data | undefined;
  /**
   * The return value from the matched route's loader or clientLoader. This might
   * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
   * an error and we're currently displaying an `ErrorBoundary`.
   */
  loaderData: Data | undefined;
  /**
   * The {@link https://reactrouter.com/start/framework/route-module#handle handle object}
   * exported from the matched route module
   */
  handle: Handle;
958}
959interface RouteMeta<RouteObjectType extends RouteObject = RouteObject> {
  relativePath: string;
  caseSensitive: boolean;
  childrenIndex: number;
  route: RouteObjectType;
964}
965/**
* @private
* PRIVATE - DO NOT USE
*
* A "branch" of routes that match a given route pattern.
* This is an internal interface not intended for direct external usage.
*/
972interface RouteBranch<RouteObjectType extends RouteObject = RouteObject> {
  path: string;
  score: number;
  routesMeta: RouteMeta<RouteObjectType>[];
976}
977/**
* Returns a path with params interpolated.
*
* @example
* import { generatePath } from "react-router";
*
* generatePath("/users/:id", { id: "123" }); // "/users/123"
*
* @public
* @category Utils
* @param originalPath The original path to generate.
* @param params The parameters to interpolate into the path.
* @returns The generated path with parameters interpolated.
*/
991declare function generatePath<Path extends string>(originalPath: Path, params?: GeneratePathParams<Path>): string;
992/**
* Used to match on some portion of a URL pathname.
*/
995interface PathPattern<Path extends string = string> {
  /**
   * A string to match against a URL pathname. May contain `:id`-style segments
   * to indicate placeholders for dynamic parameters. It May also end with `/*`
   * to indicate matching the rest of the URL pathname.
   */
  path: Path;
  /**
   * Should be `true` if the static portions of the `path` should be matched in
   * the same case.
   */
  caseSensitive?: boolean;
  /**
   * Should be `true` if this pattern should match the entire URL pathname.
   */
  end?: boolean;
1011}
1012/**
* Contains info about how a {@link PathPattern} matched on a URL pathname.
*/
1015interface 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;
1032}
1033/**
* Performs pattern matching on a URL pathname and returns information about
* the match.
*
* @public
* @category Utils
* @param pattern The pattern to match against the URL pathname. This can be a
* string or a {@link PathPattern} object. If a string is provided, it will be
* treated as a pattern with `caseSensitive` set to `false` and `end` set to
* `true`.
* @param pathname The URL pathname to match against the pattern.
* @returns A path match object if the pattern matches the pathname,
* or `null` if it does not match.
*/
1047declare function matchPath<Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamParseKey<Path>> | null;
1048/**
* Returns a resolved {@link Path} object relative to the given pathname.
*
* @public
* @category Utils
* @param to The path to resolve, either a string or a partial {@link Path}
* object.
* @param fromPathname The pathname to resolve the path from. Defaults to `/`.
* @returns A {@link Path} object with the resolved pathname, search, and hash.
*/
1058declare function resolvePath(to: To, fromPathname?: string): Path;
1059declare class DataWithResponseInit<D> {
  type: string;
  data: D;
  init: ResponseInit | null;
  constructor(data: D, init?: ResponseInit);
1064}
1065/**
* Create "responses" that contain `headers`/`status` without forcing
* serialization into an actual [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
*
* @example
* import { data } from "react-router";
*
* export async function action({ request }: Route.ActionArgs) {
*   let formData = await request.formData();
*   let item = await createItem(formData);
*   return data(item, {
*     headers: { "X-Custom-Header": "value" }
*     status: 201,
*   });
* }
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param data The data to be included in the response.
* @param init The status code or a `ResponseInit` object to be included in the
* response.
* @returns A {@link DataWithResponseInit} instance containing the data and
* response init.
*/
1091declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
1092interface TrackedPromise extends Promise<any> {
  _tracked?: boolean;
  _data?: any;
  _error?: any;
1096}
1097type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
1098/**
* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
* Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
*
* This utility accepts absolute URLs and can navigate to external domains, so
* the application should validate any user-supplied inputs to redirects.
*
* @example
* import { redirect } from "react-router";
*
* export async function loader({ request }: Route.LoaderArgs) {
*   if (!isLoggedIn(request))
*     throw redirect("/login");
*   }
*
*   // ...
* }
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param url The URL to redirect to.
* @param init The status code or a `ResponseInit` object to be included in the
* response.
* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header.
*/
1128declare const redirect: RedirectFunction;
1129/**
* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* that will force a document reload to the new location. Sets the status code
* and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
*
* This utility accepts absolute URLs and can navigate to external domains, so
* the application should validate any user-supplied inputs to redirects.
*
* ```tsx filename=routes/logout.tsx
* import { redirectDocument } from "react-router";
*
* import { destroySession } from "../sessions.server";
*
* export async function action({ request }: Route.ActionArgs) {
*   let session = await getSession(request.headers.get("Cookie"));
*   return redirectDocument("/", {
*     headers: { "Set-Cookie": await destroySession(session) }
*   });
* }
* ```
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param url The URL to redirect to.
* @param init The status code or a `ResponseInit` object to be included in the
* response.
* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header.
*/
1162declare const redirectDocument: RedirectFunction;
1163/**
* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* that will perform a [`history.replaceState`](https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState)
* instead of a [`history.pushState`](https://developer.mozilla.org/en-US/docs/Web/API/History/pushState)
* for client-side navigation redirects. Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
*
* @example
* import { replace } from "react-router";
*
* export async function loader() {
*   return replace("/new-location");
* }
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param url The URL to redirect to.
* @param init The status code or a `ResponseInit` object to be included in the
* response.
* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
* header.
*/
1188declare const replace: RedirectFunction;
1189type ErrorResponse = {
  status: number;
  statusText: string;
  data: any;
1193};
1194declare class ErrorResponseImpl implements ErrorResponse {
  status: number;
  statusText: string;
  data: any;
  private error?;
  private internal;
  constructor(status: number, statusText: string | undefined, data: any, internal?: boolean);
1201}
1202/**
* Check if the given error is an {@link ErrorResponse} generated from a 4xx/5xx
* [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
* thrown from an [`action`](../../start/framework/route-module#action) or
* [`loader`](../../start/framework/route-module#loader) function.
*
* @example
* import { isRouteErrorResponse } from "react-router";
*
* export function ErrorBoundary({ error }: Route.ErrorBoundaryProps) {
*   if (isRouteErrorResponse(error)) {
*     return (
*       <>
*         <p>Error: `${error.status}: ${error.statusText}`</p>
*         <p>{error.data}</p>
*       </>
*     );
*   }
*
*   return (
*     <p>Error: {error instanceof Error ? error.message : "Unknown Error"}</p>
*   );
* }
*
* @public
* @category Utils
* @mode framework
* @mode data
* @param error The error to check.
* @returns `true` if the error is an {@link ErrorResponse}, `false` otherwise.
*/
1233declare function isRouteErrorResponse(error: any): error is ErrorResponse;
1234
1235type Primitive = null | undefined | string | number | boolean | symbol | bigint;
1236type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
1237interface 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;
1299}
1300interface 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;
1322}
1323/**
* Represents a `<link>` element.
*
* WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
*/
1328type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
  imageSizes?: never;
1330});
1331interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
  /**
   * A [`nonce`](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/nonce)
   * attribute to render on the [`<link>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link)
   * element
   */
  nonce?: string | undefined;
  /**
   * The absolute path of the page to prefetch, e.g. `/absolute/path`.
   */
  page: string;
1342}
1343type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
1344
1345type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
  [key: PropertyKey]: Serializable;
1347} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
1348
1349type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
1350type IsAny<T> = 0 extends 1 & T ? true : false;
1351type Func = (...args: any[]) => unknown;
1352type Pretty<T> = {
  [K in keyof T]: T[K];
1354} & {};
1355type Normalize<T> = _Normalize<UnionKeys<T>, T>;
1356type _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;
1358} & {
  [K in Key as K extends keyof U ? undefined extends U[K] ? K : never : never]?: K extends keyof U ? U[K] : never;
1360} & {
  [K in Key as K extends keyof U ? never : K]?: undefined;
1362}> : never;
1363type UnionKeys<T> = T extends any ? keyof T : never;
1364
1365type 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;
1377};
1378
1379/**
* 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.
*/
1385type unstable_SerializesTo<T> = {
  unstable__ReactRouter_SerializesTo: [T];
1387};
1388
1389type Serialize<T> = T extends unstable_SerializesTo<infer To> ? To : T extends Serializable ? T : T extends (...args: any[]) => unknown ? undefined : T extends Promise<infer U> ? Promise<Serialize<U>> : T extends Map<infer K, infer V> ? Map<Serialize<K>, Serialize<V>> : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<Serialize<K>, Serialize<V>> : T extends Set<infer U> ? Set<Serialize<U>> : T extends ReadonlySet<infer U> ? ReadonlySet<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? {
  [K in keyof T]: Serialize<T[K]>;
1391} : undefined;
1392type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
1393type DataFrom<T> = IsAny<T> extends true ? undefined : T extends Func ? VoidToUndefined<Awaited<ReturnType<T>>> : undefined;
1394type ClientData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? U : T;
1395type ServerData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? Serialize<U> : Serialize<T>;
1396type ServerDataFrom<T> = ServerData<DataFrom<T>>;
1397type ClientDataFrom<T> = ClientData<DataFrom<T>>;
1398type 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;
  /**
   * A URL instance representing the application location being navigated to or
   * fetched. By default, this matches `request.url`.
   *
   * In Framework mode with `future.v8_passThroughRequests` enabled, this is a
   * normalized URL with React-Router-specific implementation details removed
   * (`.data` suffixes, `index`/`_routes` search params).
   */
  url: URL;
  /**
   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
   * @example
   * // app/routes.ts
   * route("teams/:teamId", "./team.tsx"),
   *
   * // app/team.tsx
   * export function clientLoader({
   *   params,
   * }: Route.ClientLoaderArgs) {
   *   params.teamId;
   *   //        ^ string
   * }
   **/
  params: Params;
  /**
   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
   */
  pattern: string;
  /**
   * When `future.v8_middleware` is not enabled, this is undefined.
   *
   * When `future.v8_middleware` is enabled, this is an instance of
   * `RouterContextProvider` and can be used to access context values
   * from your route middlewares.  You may pass in initial context values in your
   * `<HydratedRouter getContext>` prop
   */
  context: Readonly<RouterContextProvider>;
1443};
1444type 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;
  /**
   * A URL instance representing the application location being navigated to or
   * fetched. By default, this matches `request.url`.
   *
   * In Framework mode with `future.v8_passThroughRequests` enabled, this is a
   * normalized URL with React-Router-specific implementation details removed
   * (`.data` suffixes, `index`/`_routes` search params).
   */
  url: URL;
  /**
   * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
   * @example
   * // app/routes.ts
   * route("teams/:teamId", "./team.tsx"),
   *
   * // app/team.tsx
   * export function loader({
   *   params,
   * }: Route.LoaderArgs) {
   *   params.teamId;
   *   //        ^ string
   * }
   **/
  params: Params;
  /**
   * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
   * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
   */
  pattern: string;
  /**
   * Without `future.v8_middleware` enabled, this is the context passed in
   * to your server adapter's `getLoadContext` function. It's a way to bridge the
   * gap between the adapter's request/response API with your React Router app.
   * It is only applicable if you are using a custom server adapter.
   *
   * With `future.v8_middleware` enabled, this is an instance of
   * `RouterContextProvider` and can be used for type-safe access to
   * context value set in your route middlewares.  If you are using a custom
   * server adapter, you may provide an initial set of context values from your
   * `getLoadContext` function.
   */
  context: MiddlewareEnabled extends true ? Readonly<RouterContextProvider> : AppLoadContext;
1489};
1490type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
  ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
1492] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
1493type IsDefined<T> = Equal<T, undefined> extends true ? false : true;
1494type IsHydrate<ClientLoader> = ClientLoader extends {
  hydrate: true;
1496} ? true : ClientLoader extends {
  hydrate: false;
1498} ? false : false;
1499type GetLoaderData<T extends RouteModule$1> = _DataLoaderData<ServerDataFrom<T["loader"]>, ClientDataFrom<T["clientLoader"]>, IsHydrate<T["clientLoader"]>, T extends {
  HydrateFallback: Func;
1501} ? true : false>;
1502type _DataLoaderData<ServerLoaderData, ClientLoaderData, ClientLoaderHydrate extends boolean, HasHydrateFallback> = [
  HasHydrateFallback,
  ClientLoaderHydrate
1505] extends [true, true] ? IsDefined<ClientLoaderData> extends true ? ClientLoaderData : undefined : [
  IsDefined<ClientLoaderData>,
  IsDefined<ServerLoaderData>
1508] extends [true, true] ? ServerLoaderData | ClientLoaderData : IsDefined<ClientLoaderData> extends true ? ClientLoaderData : IsDefined<ServerLoaderData> extends true ? ServerLoaderData : undefined;
1509type GetActionData<T extends RouteModule$1> = _DataActionData<ServerDataFrom<T["action"]>, ClientDataFrom<T["clientAction"]>>;
1510type _DataActionData<ServerActionData, ClientActionData> = Awaited<[
  IsDefined<ServerActionData>,
  IsDefined<ClientActionData>
1513] extends [true, true] ? ServerActionData | ClientActionData : IsDefined<ClientActionData> extends true ? ClientActionData : IsDefined<ServerActionData> extends true ? ServerActionData : undefined>;
1514
1515interface RouteModules {
  [routeId: string]: RouteModule | undefined;
1517}
1518/**
* The shape of a route module shipped to the client
*/
1521interface RouteModule {
  clientAction?: ClientActionFunction;
  clientLoader?: ClientLoaderFunction;
  clientMiddleware?: MiddlewareFunction<Record<string, DataStrategyResult>>[];
  ErrorBoundary?: ErrorBoundaryComponent;
  HydrateFallback?: HydrateFallbackComponent;
  Layout?: LayoutComponent;
  default: RouteComponent;
  handle?: RouteHandle;
  links?: LinksFunction;
  meta?: MetaFunction;
  shouldRevalidate?: ShouldRevalidateFunction;
1533}
1534/**
* The shape of a route module on the server
*/
1537interface ServerRouteModule extends RouteModule {
  action?: ActionFunction;
  headers?: HeadersFunction | {
      [name: string]: string;
  };
  loader?: LoaderFunction;
  middleware?: MiddlewareFunction<Response>[];
1544}
1545/**
* A function that handles data mutations for a route on the client
*/
1548type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<ActionFunction>;
1549/**
* Arguments passed to a route `clientAction` function
*/
1552type ClientActionFunctionArgs = ActionFunctionArgs & {
  serverAction: <T = unknown>() => Promise<SerializeFrom<T>>;
1554};
1555/**
* A function that loads data for a route on the client
*/
1558type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<LoaderFunction>) & {
  hydrate?: boolean;
1560};
1561/**
* Arguments passed to a route `clientLoader` function
*/
1564type ClientLoaderFunctionArgs = LoaderFunctionArgs & {
  serverLoader: <T = unknown>() => Promise<SerializeFrom<T>>;
1566};
1567/**
* ErrorBoundary to display for this route
*/
1570type ErrorBoundaryComponent = ComponentType;
1571type HeadersArgs = {
  loaderHeaders: Headers;
  parentHeaders: Headers;
  actionHeaders: Headers;
  errorHeaders: Headers | undefined;
1576};
1577/**
* 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.
*/
1581interface HeadersFunction {
  (args: HeadersArgs): Headers | HeadersInit;
1583}
1584/**
* `<Route HydrateFallback>` component to render on initial loads
* when client loaders are present
*/
1588type HydrateFallbackComponent = ComponentType;
1589/**
* 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
*/
1594type LayoutComponent = ComponentType<{
  children: ReactElement<unknown, ErrorBoundaryComponent | HydrateFallbackComponent | RouteComponent>;
1596}>;
1597/**
* A function that defines `<link>` tags to be inserted into the `<head>` of
* the document on route transitions.
*
* @see https://reactrouter.com/start/framework/route-module#meta
*/
1603interface LinksFunction {
  (): LinkDescriptor[];
1605}
1606interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
  id: RouteId;
  pathname: DataRouteMatch["pathname"];
  /** @deprecated Use `MetaMatch.loaderData` instead */
  data: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
  loaderData: Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown;
  handle?: RouteHandle;
  params: DataRouteMatch["params"];
  meta: MetaDescriptor[];
  error?: unknown;
1616}
1617type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> = Array<{
  [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
1619}[keyof MatchLoaders]>;
1620interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
  /** @deprecated Use `MetaArgs.loaderData` instead */
  data: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
  loaderData: (Loader extends LoaderFunction | ClientLoaderFunction ? SerializeFrom<Loader> : unknown) | undefined;
  params: Params;
  location: Location;
  matches: MetaMatches<MatchLoaders>;
  error?: unknown;
1628}
1629/**
* 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"
* }
* ```
*/
1679interface MetaFunction<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
  (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
1681}
1682type MetaDescriptor = {
  charSet: "utf-8";
1684} | {
  title: string;
1686} | {
  name: string;
  content: string;
1689} | {
  property: string;
  content: string;
1692} | {
  httpEquiv: string;
  content: string;
1695} | {
  "script:ld+json": LdJsonObject;
1697} | {
  tagName: "meta" | "link";
  [name: string]: string;
1700} | {
  [name: string]: unknown;
1702};
1703type LdJsonObject = {
  [Key in string]: LdJsonValue;
1705} & {
  [Key in string]?: LdJsonValue | undefined;
1707};
1708type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
1709type LdJsonPrimitive = string | number | boolean | null;
1710type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
1711/**
* A React component that is rendered for a route.
*/
1714type RouteComponent = ComponentType<{}>;
1715/**
* An arbitrary object that is associated with a route.
*
* @see https://reactrouter.com/how-to/using-handle
*/
1720type RouteHandle = unknown;
1721
1722/**
* 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
*/
1728interface AppLoadContext {
  [key: string]: unknown;
1730}
1731
1732export { type Equal as $, type ActionFunction as A, type MiddlewareNextFunction as B, type ClientActionFunction as C, type DataRouteMatch as D, type ClientDataFunctionArgs as E, type FormEncType as F, type GetLoaderData as G, type HeadersFunction as H, type DataStrategyResult as I, type ServerDataFrom as J, type GetActionData as K, type Location as L, type MetaFunction as M, type Normalize as N, type RouteModules as O, type Params as P, type SerializeFrom as Q, type RouteModule$1 as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type PathPattern as V, type PathMatch as W, type ParamParseKey as X, type InitialEntry as Y, type IndexRouteObject as Z, type NonIndexRouteObject as _, type ClientLoaderFunction as a, type ActionFunctionArgs as a0, type BaseRouteObject as a1, type DataStrategyFunctionArgs as a2, type DataStrategyMatch as a3, DataWithResponseInit as a4, type ErrorResponse as a5, type FormMethod as a6, type LazyRouteFunction as a7, type MiddlewareFunction as a8, type PatchRoutesOnNavigationFunctionArgs as a9, createBrowserHistory as aA, createHashHistory as aB, invariant as aC, ErrorResponseImpl as aD, type ServerRouteModule as aE, type TrackedPromise as aF, type PathParam as aa, type RedirectFunction as ab, type RouteMatch as ac, type RouterContext as ad, type ShouldRevalidateFunctionArgs as ae, createContext as af, createPath as ag, parsePath as ah, data as ai, generatePath as aj, isRouteErrorResponse as ak, matchPath as al, matchRoutes as am, redirect as an, redirectDocument as ao, replace as ap, resolvePath as aq, type ClientActionFunctionArgs as ar, type ClientLoaderFunctionArgs as as, type HeadersArgs as at, type MetaArgs as au, type PageLinkDescriptor as av, type HtmlLinkDescriptor as aw, type Future as ax, type unstable_SerializesTo as ay, createMemoryHistory as az, type LinksFunction as b, RouterContextProvider as c, type LoaderFunction as d, type RouteObject as e, type History as f, type MaybePromise as g, type MapRoutePropertiesFunction as h, Action as i, type Submission as j, type RouteData as k, type DataStrategyFunction as l, type PatchRoutesOnNavigationFunction as m, type DataRouteObject as n, type RouteBranch as o, type RouteManifest as p, type HTMLFormMethod as q, type Path as r, type LoaderFunctionArgs as s, type MiddlewareEnabled as t, type AppLoadContext as u, type LinkDescriptor as v, type Func as w, type Pretty as x, type MetaDescriptor as y, type ServerDataFunctionArgs as z };