react-router 0.0.0-experimental-c19b79d → 0.0.0-experimental-31a822c5f

package/dist/development/index.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-c19b79d
+ * react-router v0.0.0-experimental-31a822c5f
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -11,11 +11,9 @@
 "use client";
 import {
   RSCDefaultRootErrorBoundary,
-  RSCHydratedRouter,
   RSCStaticRouter,
   ServerMode,
   ServerRouter,
-  createCallServer,
   createCookie,
   createCookieSessionStorage,
   createMemorySessionStorage,
@@ -25,13 +23,12 @@ import {
   createSessionStorage,
   deserializeErrors,
   getHydrationData,
-  getRSCStream,
   href,
   isCookie,
   isSession,
   routeRSCServerRequest,
   setDevServerHooks
-} from "./chunk-AGOH44BE.mjs";
+} from "./chunk-FXUONXY4.mjs";
 import {
   Action,
   Await,
@@ -142,7 +139,7 @@ import {
   withComponentProps,
   withErrorBoundaryProps,
   withHydrateFallbackProps
-} from "./chunk-IMKEG5CI.mjs";
+} from "./chunk-WTUOISGV.mjs";
 export {
   Await,
   BrowserRouter,
@@ -237,10 +234,7 @@ export {
   replace,
   resolvePath,
   HistoryRouter as unstable_HistoryRouter,
-  RSCHydratedRouter as unstable_RSCHydratedRouter,
   RSCStaticRouter as unstable_RSCStaticRouter,
-  createCallServer as unstable_createCallServer,
-  getRSCStream as unstable_getRSCStream,
   routeRSCServerRequest as unstable_routeRSCServerRequest,
   setDevServerHooks as unstable_setDevServerHooks,
   usePrompt as unstable_usePrompt,

package/dist/development/lib/types/internal.d.mts

@@ -1,6 +1,5 @@
-import { R as RouteModule, L as LinkDescriptor, F as Func, P as Pretty, M as MetaDescriptor, G as GetLoaderData, S as ServerDataFunctionArgs, C as ClientDataFunctionArgs, a as ServerDataFrom, N as Normalize, b as GetActionData } from '../../route-data-CDwqkzPE.mjs';
-import { L as Location, M as MiddlewareNextFunction, D as DataStrategyResult } from '../../context-BqL5Eckq.mjs';
-import { R as RouteFiles, P as Pages } from '../../register-BrVEYTED.mjs';
+import { R as RouteModule, g as LinkDescriptor, L as Location, F as Func, h as Pretty, i as MetaDescriptor, G as GetLoaderData, j as ServerDataFunctionArgs, k as MiddlewareNextFunction, l as ClientDataFunctionArgs, D as DataStrategyResult, m as ServerDataFrom, N as Normalize, n as GetActionData } from '../../route-data-nQS6GSUI.mjs';
+import { R as RouteFiles, P as Pages } from '../../register-BblEgJPm.mjs';
 import 'react';
 
 type MaybePromise<T> = T | Promise<T>;

package/dist/development/lib/types/internal.d.ts

@@ -1,5 +1,5 @@
-import { R as RouteModule, L as LinkDescriptor, a as Location, F as Func, P as Pretty, M as MetaDescriptor, G as GetLoaderData, S as ServerDataFunctionArgs, b as MiddlewareNextFunction, C as ClientDataFunctionArgs, D as DataStrategyResult, c as ServerDataFrom, N as Normalize, d as GetActionData } from '../../routeModules-BmVo7q9e.js';
-import { R as RouteFiles, P as Pages } from '../../register-D8NQoPsO.js';
+import { R as RouteModule, f as LinkDescriptor, L as Location, F as Func, g as Pretty, h as MetaDescriptor, G as GetLoaderData, i as ServerDataFunctionArgs, j as MiddlewareNextFunction, k as ClientDataFunctionArgs, D as DataStrategyResult, l as ServerDataFrom, N as Normalize, m as GetActionData } from '../../routeModules-9wlxglVk.js';
+import { R as RouteFiles, P as Pages } from '../../register-D18raRVf.js';
 import 'react';
 
 type MaybePromise<T> = T | Promise<T>;

package/dist/development/lib/types/internal.js

@@ -1,5 +1,5 @@
 "use strict";/**
- * react-router v0.0.0-experimental-c19b79d
+ * react-router v0.0.0-experimental-31a822c5f
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/development/lib/types/internal.mjs

@@ -1,5 +1,5 @@
 /**
- * react-router v0.0.0-experimental-c19b79d
+ * react-router v0.0.0-experimental-31a822c5f
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/{production/register-BrVEYTED.d.mts → development/register-BblEgJPm.d.mts}

@@ -1,4 +1,4 @@
-import { R as RouteModule } from './route-data-CDwqkzPE.mjs';
+import { R as RouteModule } from './route-data-nQS6GSUI.mjs';
 
 /**
  * Apps can use this interface to "register" app-wide types for React Router via interface declaration merging and module augmentation.

package/dist/development/{register-D8NQoPsO.d.ts → register-D18raRVf.d.ts}

@@ -1,4 +1,4 @@
-import { R as RouteModule } from './routeModules-BmVo7q9e.js';
+import { R as RouteModule } from './routeModules-9wlxglVk.js';
 
 /**
  * Apps can use this interface to "register" app-wide types for React Router via interface declaration merging and module augmentation.

package/dist/development/{context-BqL5Eckq.d.mts → route-data-nQS6GSUI.d.mts}

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { ComponentType, ReactElement } from 'react';
 
 /**
  * Actions represent the type of change to a location value.
@@ -2178,7 +2179,7 @@ interface RoutesProps {
  * <Routes>
  *   <Route index element={<StepOne />} />
  *   <Route path="step-2" element={<StepTwo />} />
- *   <Route path="step-3" element={<StepThree />}>
+ *   <Route path="step-3" element={<StepThree />} />
  * </Routes>
  *
  * @public
@@ -2565,4 +2566,473 @@ interface RouteContextObject {
 }
 declare const RouteContext: React.Context<RouteContextObject>;
 
-export { type DataStrategyMatch as $, type ActionFunctionArgs as A, type BlockerFunction as B, type PatchRoutesOnNavigationFunction as C, type DataStrategyResult as D, type ErrorBoundaryType as E, type DataRouteObject as F, type StaticHandler as G, type HydrationState as H, type InitialEntry as I, type GetScrollPositionFunction as J, type GetScrollRestorationKeyFunction as K, type Location as L, type MiddlewareNextFunction as M, type NavigateOptions as N, type StaticHandlerContext as O, type Params as P, type Fetcher as Q, type RouterProviderProps as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type NavigationStates as V, type RouterSubscriber as W, type RouterNavigateOptions as X, type RouterFetchOptions as Y, type RevalidationState as Z, type DataStrategyFunctionArgs as _, type RouterInit as a, hydrationRouteProperties as a$, type ErrorResponse as a0, type FormEncType as a1, type FormMethod as a2, type HTMLFormMethod as a3, type LazyRouteFunction as a4, type PathParam as a5, type RedirectFunction as a6, type RouterContext as a7, type ShouldRevalidateFunctionArgs as a8, createContext as a9, type RouteProps as aA, type RouterProps as aB, type RoutesProps as aC, Await as aD, MemoryRouter as aE, Navigate as aF, Outlet as aG, Route as aH, Router as aI, RouterProvider as aJ, Routes as aK, createMemoryRouter as aL, createRoutesFromChildren as aM, createRoutesFromElements as aN, renderMatches as aO, type Future as aP, createBrowserHistory as aQ, invariant as aR, createRouter as aS, ErrorResponseImpl as aT, DataRouterContext as aU, DataRouterStateContext as aV, FetchersContext as aW, LocationContext as aX, NavigationContext as aY, RouteContext as aZ, ViewTransitionContext as a_, createPath as aa, parsePath as ab, IDLE_NAVIGATION as ac, IDLE_FETCHER as ad, IDLE_BLOCKER as ae, data as af, generatePath as ag, isRouteErrorResponse as ah, matchPath as ai, matchRoutes as aj, redirect as ak, redirectDocument as al, replace as am, resolvePath as an, type Navigator as ao, type PatchRoutesOnNavigationFunctionArgs as ap, type RouteMatch as aq, AwaitContextProvider as ar, type AwaitProps as as, type IndexRouteProps as at, type LayoutRouteProps as au, type MemoryRouterOpts as av, type MemoryRouterProps as aw, type NavigateProps as ax, type OutletProps as ay, type PathRouteProps as az, type LoaderFunctionArgs as b, mapRouteProperties as b0, WithComponentProps as b1, withComponentProps as b2, WithHydrateFallbackProps as b3, withHydrateFallbackProps as b4, WithErrorBoundaryProps as b5, withErrorBoundaryProps as b6, type RouteManifest as b7, type History as b8, type FutureConfig as b9, type CreateStaticHandlerOptions as ba, type ActionFunction as c, type LoaderFunction as d, type DataRouteMatch as e, type MiddlewareFunction as f, RouterContextProvider as g, DataWithResponseInit as h, type MiddlewareEnabled as i, type Router$1 as j, type DataStrategyFunction as k, type Blocker as l, type RelativeRoutingType as m, type ParamParseKey as n, type Path as o, type PathPattern as p, type PathMatch as q, type Navigation as r, Action as s, type RouteObject as t, type unstable_ClientOnErrorFunction as u, type IndexRouteObject as v, type RouteComponentType as w, type HydrateFallbackType as x, type NonIndexRouteObject as y, type RouterState as z };
+/**
+ * An object of unknown type for route loaders and actions provided by the
+ * server's `getLoadContext()` function.  This is defined as an empty interface
+ * specifically so apps can leverage declaration merging to augment this type
+ * globally: https://www.typescriptlang.org/docs/handbook/declaration-merging.html
+ */
+interface AppLoadContext {
+    [key: string]: unknown;
+}
+
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+interface HtmlLinkProps {
+    /**
+     * Address of the hyperlink
+     */
+    href?: string;
+    /**
+     * How the element handles crossorigin requests
+     */
+    crossOrigin?: "anonymous" | "use-credentials";
+    /**
+     * Relationship between the document containing the hyperlink and the destination resource
+     */
+    rel: LiteralUnion<"alternate" | "dns-prefetch" | "icon" | "manifest" | "modulepreload" | "next" | "pingback" | "preconnect" | "prefetch" | "preload" | "prerender" | "search" | "stylesheet", string>;
+    /**
+     * Applicable media: "screen", "print", "(max-width: 764px)"
+     */
+    media?: string;
+    /**
+     * Integrity metadata used in Subresource Integrity checks
+     */
+    integrity?: string;
+    /**
+     * Language of the linked resource
+     */
+    hrefLang?: string;
+    /**
+     * Hint for the type of the referenced resource
+     */
+    type?: string;
+    /**
+     * Referrer policy for fetches initiated by the element
+     */
+    referrerPolicy?: "" | "no-referrer" | "no-referrer-when-downgrade" | "same-origin" | "origin" | "strict-origin" | "origin-when-cross-origin" | "strict-origin-when-cross-origin" | "unsafe-url";
+    /**
+     * Sizes of the icons (for rel="icon")
+     */
+    sizes?: string;
+    /**
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+     */
+    as?: LiteralUnion<"audio" | "audioworklet" | "document" | "embed" | "fetch" | "font" | "frame" | "iframe" | "image" | "manifest" | "object" | "paintworklet" | "report" | "script" | "serviceworker" | "sharedworker" | "style" | "track" | "video" | "worker" | "xslt", string>;
+    /**
+     * Color to use when customizing a site's icon (for rel="mask-icon")
+     */
+    color?: string;
+    /**
+     * Whether the link is disabled
+     */
+    disabled?: boolean;
+    /**
+     * The title attribute has special semantics on this element: Title of the link; CSS style sheet set name.
+     */
+    title?: string;
+    /**
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
+     */
+    imageSrcSet?: string;
+    /**
+     * Image sizes for different page layouts (for rel="preload")
+     */
+    imageSizes?: string;
+}
+interface HtmlLinkPreloadImage extends HtmlLinkProps {
+    /**
+     * Relationship between the document containing the hyperlink and the destination resource
+     */
+    rel: "preload";
+    /**
+     * Potential destination for a preload request (for rel="preload" and rel="modulepreload")
+     */
+    as: "image";
+    /**
+     * Address of the hyperlink
+     */
+    href?: string;
+    /**
+     * Images to use in different situations, e.g., high-resolution displays,
+     * small monitors, etc. (for rel="preload")
+     */
+    imageSrcSet: string;
+    /**
+     * Image sizes for different page layouts (for rel="preload")
+     */
+    imageSizes?: string;
+}
+/**
+ * Represents a `<link>` element.
+ *
+ * WHATWG Specification: https://html.spec.whatwg.org/multipage/semantics.html#the-link-element
+ */
+type HtmlLinkDescriptor = (HtmlLinkProps & Pick<Required<HtmlLinkProps>, "href">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "imageSizes">) | (HtmlLinkPreloadImage & Pick<Required<HtmlLinkPreloadImage>, "href"> & {
+    imageSizes?: never;
+});
+interface PageLinkDescriptor extends Omit<HtmlLinkDescriptor, "href" | "rel" | "type" | "sizes" | "imageSrcSet" | "imageSizes" | "as" | "color" | "title"> {
+    /**
+     * 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;
+}
+type LinkDescriptor = HtmlLinkDescriptor | PageLinkDescriptor;
+
+interface RouteModules {
+    [routeId: string]: RouteModule$1 | undefined;
+}
+/**
+ * The shape of a route module shipped to the client
+ */
+interface RouteModule$1 {
+    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;
+}
+/**
+ * The shape of a route module on the server
+ */
+interface ServerRouteModule extends RouteModule$1 {
+    action?: ActionFunction;
+    headers?: HeadersFunction | {
+        [name: string]: string;
+    };
+    loader?: LoaderFunction;
+    middleware?: MiddlewareFunction<Response>[];
+}
+/**
+ * A function that handles data mutations for a route on the client
+ */
+type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<ActionFunction>;
+/**
+ * Arguments passed to a route `clientAction` function
+ */
+type ClientActionFunctionArgs = ActionFunctionArgs & {
+    serverAction: <T = unknown>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * A function that loads data for a route on the client
+ */
+type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<LoaderFunction>) & {
+    hydrate?: boolean;
+};
+/**
+ * Arguments passed to a route `clientLoader` function
+ */
+type ClientLoaderFunctionArgs = LoaderFunctionArgs & {
+    serverLoader: <T = unknown>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * ErrorBoundary to display for this route
+ */
+type ErrorBoundaryComponent = ComponentType;
+type HeadersArgs = {
+    loaderHeaders: Headers;
+    parentHeaders: Headers;
+    actionHeaders: Headers;
+    errorHeaders: Headers | undefined;
+};
+/**
+ * A function that returns HTTP headers to be used for a route. These headers
+ * will be merged with (and take precedence over) headers from parent routes.
+ */
+interface HeadersFunction {
+    (args: HeadersArgs): Headers | HeadersInit;
+}
+/**
+ * `<Route HydrateFallback>` component to render on initial loads
+ * when client loaders are present
+ */
+type HydrateFallbackComponent = ComponentType;
+/**
+ * Optional, root-only `<Route Layout>` component to wrap the root content in.
+ * Useful for defining the <html>/<head>/<body> document shell shared by the
+ * Component, HydrateFallback, and ErrorBoundary
+ */
+type LayoutComponent = ComponentType<{
+    children: ReactElement<unknown, ErrorBoundaryComponent | HydrateFallbackComponent | RouteComponent>;
+}>;
+/**
+ * A function that defines `<link>` tags to be inserted into the `<head>` of
+ * the document on route transitions.
+ *
+ * @see https://remix.run/route/meta
+ */
+interface LinksFunction {
+    (): LinkDescriptor[];
+}
+interface MetaMatch<RouteId extends string = string, Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown> {
+    id: RouteId;
+    pathname: DataRouteMatch["pathname"];
+    /** @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;
+}
+type MetaMatches<MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> = Array<{
+    [K in keyof MatchLoaders]: MetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
+}[keyof MatchLoaders]>;
+interface MetaArgs<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
+    /** @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;
+}
+/**
+ * A function that returns an array of data objects to use for rendering
+ * metadata HTML tags in a route. These tags are not rendered on descendant
+ * routes in the route hierarchy. In other words, they will only be rendered on
+ * the route in which they are exported.
+ *
+ * @param Loader - The type of the current route's loader function
+ * @param MatchLoaders - Mapping from a parent route's filepath to its loader
+ * function type
+ *
+ * Note that parent route filepaths are relative to the `app/` directory.
+ *
+ * For example, if this meta function is for `/sales/customers/$customerId`:
+ *
+ * ```ts
+ * // app/root.tsx
+ * const loader = () => ({ hello: "world" })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales.tsx
+ * const loader = () => ({ salesCount: 1074 })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers.tsx
+ * const loader = () => ({ customerCount: 74 })
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers/$customersId.tsx
+ * import type { Loader as RootLoader } from "../../../root"
+ * import type { Loader as SalesLoader } from "../../sales"
+ * import type { Loader as CustomersLoader } from "../../sales/customers"
+ *
+ * const loader = () => ({ name: "Customer name" })
+ *
+ * const meta: MetaFunction<typeof loader, {
+ *  "root": RootLoader,
+ *  "routes/sales": SalesLoader,
+ *  "routes/sales/customers": CustomersLoader,
+ * }> = ({ data, matches }) => {
+ *   const { name } = data
+ *   //      ^? string
+ *   const { customerCount } = matches.find((match) => match.id === "routes/sales/customers").data
+ *   //      ^? number
+ *   const { salesCount } = matches.find((match) => match.id === "routes/sales").data
+ *   //      ^? number
+ *   const { hello } = matches.find((match) => match.id === "root").data
+ *   //      ^? "world"
+ * }
+ * ```
+ */
+interface MetaFunction<Loader extends LoaderFunction | ClientLoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | ClientLoaderFunction | unknown> = Record<string, unknown>> {
+    (args: MetaArgs<Loader, MatchLoaders>): MetaDescriptor[] | undefined;
+}
+type MetaDescriptor = {
+    charSet: "utf-8";
+} | {
+    title: string;
+} | {
+    name: string;
+    content: string;
+} | {
+    property: string;
+    content: string;
+} | {
+    httpEquiv: string;
+    content: string;
+} | {
+    "script:ld+json": LdJsonObject;
+} | {
+    tagName: "meta" | "link";
+    [name: string]: string;
+} | {
+    [name: string]: unknown;
+};
+type LdJsonObject = {
+    [Key in string]: LdJsonValue;
+} & {
+    [Key in string]?: LdJsonValue | undefined;
+};
+type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
+type LdJsonPrimitive = string | number | boolean | null;
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
+/**
+ * A React component that is rendered for a route.
+ */
+type RouteComponent = ComponentType<{}>;
+/**
+ * An arbitrary object that is associated with a route.
+ *
+ * @see https://remix.run/route/handle
+ */
+type RouteHandle = unknown;
+
+type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
+    [key: PropertyKey]: Serializable;
+} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
+
+type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Func = (...args: any[]) => unknown;
+type Pretty<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Normalize<T> = _Normalize<UnionKeys<T>, T>;
+type _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;
+} & {
+    [K in Key as K extends keyof U ? undefined extends U[K] ? K : never : never]?: K extends keyof U ? U[K] : never;
+} & {
+    [K in Key as K extends keyof U ? never : K]?: undefined;
+}> : never;
+type UnionKeys<T> = T extends any ? keyof T : never;
+
+type RouteModule = {
+    meta?: Func;
+    links?: Func;
+    headers?: Func;
+    loader?: Func;
+    clientLoader?: Func;
+    action?: Func;
+    clientAction?: Func;
+    HydrateFallback?: Func;
+    default?: Func;
+    ErrorBoundary?: Func;
+    [key: string]: unknown;
+};
+
+/**
+ * A brand that can be applied to a type to indicate that it will serialize
+ * to a specific type when transported to the client from a loader.
+ * Only use this if you have additional serialization/deserialization logic
+ * in your application.
+ */
+type unstable_SerializesTo<T> = {
+    unstable__ReactRouter_SerializesTo: [T];
+};
+
+type 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]>;
+} : undefined;
+type VoidToUndefined<T> = Equal<T, void> extends true ? undefined : T;
+type DataFrom<T> = IsAny<T> extends true ? undefined : T extends Func ? VoidToUndefined<Awaited<ReturnType<T>>> : undefined;
+type ClientData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? U : T;
+type ServerData<T> = T extends Response ? never : T extends DataWithResponseInit<infer U> ? Serialize<U> : Serialize<T>;
+type ServerDataFrom<T> = ServerData<DataFrom<T>>;
+type ClientDataFrom<T> = ClientData<DataFrom<T>>;
+type 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.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>;
+};
+type ServerDataFunctionArgs<Params> = {
+    /** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read the url, method, headers (such as cookies), and request body from the request. */
+    request: Request;
+    /**
+     * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+     * @example
+     * // app/routes.ts
+     * route("teams/:teamId", "./team.tsx"),
+     *
+     * // app/team.tsx
+     * export function loader({
+     *   params,
+     * }: Route.LoaderArgs) {
+     *   params.teamId;
+     *   //        ^ string
+     * }
+     **/
+    params: Params;
+    /**
+     * Without `future.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;
+};
+type SerializeFrom<T> = T extends (...args: infer Args) => unknown ? Args extends [
+    ClientLoaderFunctionArgs | ClientActionFunctionArgs | ClientDataFunctionArgs<unknown>
+] ? ClientDataFrom<T> : ServerDataFrom<T> : T;
+type IsDefined<T> = Equal<T, undefined> extends true ? false : true;
+type IsHydrate<ClientLoader> = ClientLoader extends {
+    hydrate: true;
+} ? true : ClientLoader extends {
+    hydrate: false;
+} ? false : false;
+type GetLoaderData<T extends RouteModule> = _DataLoaderData<ServerDataFrom<T["loader"]>, ClientDataFrom<T["clientLoader"]>, IsHydrate<T["clientLoader"]>, T extends {
+    HydrateFallback: Func;
+} ? true : false>;
+type _DataLoaderData<ServerLoaderData, ClientLoaderData, ClientLoaderHydrate extends boolean, HasHydrateFallback> = [
+    HasHydrateFallback,
+    ClientLoaderHydrate
+] extends [true, true] ? IsDefined<ClientLoaderData> extends true ? ClientLoaderData : undefined : [
+    IsDefined<ClientLoaderData>,
+    IsDefined<ServerLoaderData>
+] extends [true, true] ? ServerLoaderData | ClientLoaderData : IsDefined<ClientLoaderData> extends true ? ClientLoaderData : IsDefined<ServerLoaderData> extends true ? ServerLoaderData : undefined;
+type GetActionData<T extends RouteModule> = _DataActionData<ServerDataFrom<T["action"]>, ClientDataFrom<T["clientAction"]>>;
+type _DataActionData<ServerActionData, ClientActionData> = Awaited<[
+    IsDefined<ServerActionData>,
+    IsDefined<ClientActionData>
+] extends [true, true] ? ServerActionData | ClientActionData : IsDefined<ClientActionData> extends true ? ClientActionData : IsDefined<ServerActionData> extends true ? ServerActionData : undefined>;
+
+export { type Equal as $, type ActionFunction as A, type BlockerFunction as B, type ClientActionFunction as C, type DataStrategyResult as D, type Navigation as E, type Func as F, type GetLoaderData as G, type HeadersFunction as H, Action as I, type RouteObject as J, type InitialEntry as K, type Location as L, type MetaFunction as M, type Normalize as N, type HydrationState as O, type Params as P, type IndexRouteObject as Q, type RouteModule as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type RouteComponentType as V, type HydrateFallbackType as W, type ErrorBoundaryType as X, type NonIndexRouteObject as Y, type AppLoadContext as Z, type MiddlewareEnabled as _, type ClientLoaderFunction as a, Route as a$, type RouterState as a0, type PatchRoutesOnNavigationFunction as a1, type DataRouteObject as a2, type StaticHandler as a3, type GetScrollPositionFunction as a4, type GetScrollRestorationKeyFunction as a5, type StaticHandlerContext as a6, type Fetcher as a7, type NavigationStates as a8, type RouterSubscriber as a9, isRouteErrorResponse as aA, matchPath as aB, matchRoutes as aC, redirect as aD, redirectDocument as aE, replace as aF, resolvePath as aG, type DataRouteMatch as aH, type Navigator as aI, type PatchRoutesOnNavigationFunctionArgs as aJ, type RouteMatch as aK, AwaitContextProvider as aL, type AwaitProps as aM, type IndexRouteProps as aN, type LayoutRouteProps as aO, type MemoryRouterOpts as aP, type MemoryRouterProps as aQ, type NavigateProps as aR, type OutletProps as aS, type PathRouteProps as aT, type RouteProps as aU, type RouterProps as aV, type RoutesProps as aW, Await as aX, MemoryRouter as aY, Navigate as aZ, Outlet as a_, type RouterNavigateOptions as aa, type RouterFetchOptions as ab, type RevalidationState as ac, type ActionFunctionArgs as ad, type DataStrategyFunctionArgs as ae, type DataStrategyMatch as af, DataWithResponseInit as ag, type ErrorResponse as ah, type FormEncType as ai, type FormMethod as aj, type HTMLFormMethod as ak, type LazyRouteFunction as al, type LoaderFunctionArgs as am, type MiddlewareFunction as an, type PathParam as ao, type RedirectFunction as ap, type RouterContext as aq, type ShouldRevalidateFunctionArgs as ar, createContext as as, createPath as at, parsePath as au, IDLE_NAVIGATION as av, IDLE_FETCHER as aw, IDLE_BLOCKER as ax, data as ay, generatePath as az, type LinksFunction as b, Router as b0, RouterProvider as b1, Routes as b2, createMemoryRouter as b3, createRoutesFromChildren as b4, createRoutesFromElements as b5, renderMatches as b6, type ClientActionFunctionArgs as b7, type ClientLoaderFunctionArgs as b8, type HeadersArgs as b9, type History as bA, type FutureConfig as bB, type CreateStaticHandlerOptions as bC, type MetaArgs as ba, type PageLinkDescriptor as bb, type HtmlLinkDescriptor as bc, type Future as bd, type unstable_SerializesTo as be, createBrowserHistory as bf, invariant as bg, createRouter as bh, ErrorResponseImpl as bi, DataRouterContext as bj, DataRouterStateContext as bk, FetchersContext as bl, LocationContext as bm, NavigationContext as bn, RouteContext as bo, ViewTransitionContext as bp, hydrationRouteProperties as bq, mapRouteProperties as br, WithComponentProps as bs, withComponentProps as bt, WithHydrateFallbackProps as bu, withHydrateFallbackProps as bv, WithErrorBoundaryProps as bw, withErrorBoundaryProps as bx, type RouteManifest as by, type ServerRouteModule as bz, RouterContextProvider as c, type LoaderFunction as d, type RouterInit as e, type RouterProviderProps as f, type LinkDescriptor as g, type Pretty as h, type MetaDescriptor as i, type ServerDataFunctionArgs as j, type MiddlewareNextFunction as k, type ClientDataFunctionArgs as l, type ServerDataFrom as m, type GetActionData as n, type Router$1 as o, type RouteModules as p, type DataStrategyFunction as q, type NavigateOptions as r, type Blocker as s, type SerializeFrom as t, type unstable_ClientOnErrorFunction as u, type RelativeRoutingType as v, type ParamParseKey as w, type Path as x, type PathPattern as y, type PathMatch as z };