react-router 7.7.1 → 7.8.0-pre.1

package/dist/{production/route-data-CqEmXQub.d.mts → development/context-DohQKLID.d.mts}

@@ -1,5 +1,4 @@
 import * as React from 'react';
-import { ComponentType, ReactElement } from 'react';
 
 /**
  * Actions represent the type of change to a location value.
@@ -271,35 +270,122 @@ type Submission = {
     json: undefined;
     text: string;
 };
+/**
+ * A context instance used as the key for the `get`/`set` methods of a
+ * {@link unstable_RouterContextProvider}. Accepts an optional default
+ * value to be returned if no value has been set.
+ */
 interface unstable_RouterContext<T = unknown> {
     defaultValue?: T;
 }
 /**
- * Creates a context object that may be used to store and retrieve arbitrary values.
+ * Creates a type-safe {@link unstable_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 { unstable_createContext } from "react-router";
  *
- * 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.
+ * // Create a context for user data
+ * export const userContext =
+ *   unstable_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);
+ * };
+ * ```
  *
- * @param defaultValue The default value for the context
- * @returns A context object
+ * ```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 unstable_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).
  */
 declare function unstable_createContext<T>(defaultValue?: T): unstable_RouterContext<T>;
 /**
- * A Map of RouterContext objects to their initial values - used to populate a
- * fresh `context` value per request/navigation/fetch
- */
-type unstable_InitialContext = Map<unstable_RouterContext, unknown>;
-/**
- * Provides methods for writing/reading values in application context in a typesafe way.
+ * Provides methods for writing/reading values in application context in a
+ * type-safe way. Primarily for usage with [middleware](../../how-to/middleware).
+ *
+ * @example
+ * import {
+ *   unstable_createContext,
+ *   unstable_RouterContextProvider
+ * } from "react-router";
+ *
+ * const userContext = unstable_createContext<User | null>(null);
+ * const contextProvider = new unstable_RouterContextProvider();
+ * contextProvider.set(userContext, getUser());
+ * //                               ^ Type-safe
+ * const user = contextProvider.get(userContext);
+ * //    ^ User
+ *
+ * @public
+ * @category Utils
+ * @mode framework
+ * @mode data
  */
 declare class unstable_RouterContextProvider {
     #private;
-    constructor(init?: unstable_InitialContext);
+    /**
+     * Create a new `unstable_RouterContextProvider` instance
+     * @param init An optional initial context map to populate the provider with
+     */
+    constructor(init?: Map<unstable_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: unstable_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 unstable_RouterContext>(context: C, value: C extends unstable_RouterContext<infer T> ? T : never): void;
 }
-type DefaultContext = MiddlewareEnabled extends true ? unstable_RouterContextProvider : any;
+type DefaultContext = MiddlewareEnabled extends true ? Readonly<unstable_RouterContextProvider> : any;
 /**
  * @private
  * Arguments passed to route loader/action functions.  Same for now but we keep
@@ -321,7 +407,7 @@ interface DataFunctionArgs<Context> {
      *   params.teamId;
      *   //        ^ string
      * }
-     **/
+     */
     params: Params;
     /**
      * This is the context passed in to your server adapter's getLoadContext() function.
@@ -335,7 +421,7 @@ interface DataFunctionArgs<Context> {
  * middlewares from the bottom-up
  */
 interface unstable_MiddlewareNextFunction<Result = unknown> {
-    (): MaybePromise<Result>;
+    (): Promise<Result>;
 }
 /**
  * Route middleware function signature.  Receives the same "data" arguments as a
@@ -343,7 +429,7 @@ interface unstable_MiddlewareNextFunction<Result = unknown> {
  * a `next` function as the second parameter which will call downstream handlers
  * and then complete middlewares from the bottom-up
  */
-type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<unstable_RouterContextProvider>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
+type unstable_MiddlewareFunction<Result = unknown> = (args: DataFunctionArgs<Readonly<unstable_RouterContextProvider>>, next: unstable_MiddlewareNextFunction<Result>) => MaybePromise<Result | void>;
 /**
  * Arguments passed to loader functions
  */
@@ -449,34 +535,39 @@ interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRoute
         route: Promise<void> | undefined;
     };
     /**
-     * A boolean value indicating whether this route handler should be called in this pass.
+     * 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.
+     * 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.
+     * `shouldLoad` is usually only interesting if you are skipping the route
+     * handler entirely and implementing custom handler logic - since it lets you
+     * determine if that custom logic should run for this route or not.
      *
      * For example:
      *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
      *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
      *    will have `shouldLoad=true` because the data for `parent` and `child` is
      *    already loaded
-     *  - If you are on `/parent/child/a` and you submit to `a`'s `action`, then only
-     *    `a` will have `shouldLoad=true` for the action execution of `dataStrategy`
-     *  - After the `action`, `dataStrategy` will be called again for the `loader`
-     *    revalidation, and all matches will have `shouldLoad=true` (assuming no custom
-     *   `shouldRevalidate` implementations)
+     *  - 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;
     unstable_shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
     unstable_shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
     /**
      * An async function that will resolve any `route.lazy` implementations and
-     * execute the route's handler (if necessary), returning a `DataStrategyResult`
+     * execute the route's handler (if necessary), returning a {@link DataStrategyResult}
      *
-     * - Calling `match.resolve` does not mean you're calling the `loader`/`action`
+     * - 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
@@ -643,7 +734,28 @@ interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticData
 /**
  * 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.
  */
 declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
 interface UIMatch<Data = unknown, Handle = unknown> {
@@ -651,29 +763,53 @@ interface UIMatch<Data = unknown, Handle = unknown> {
     pathname: string;
     /**
      * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the matched route.
-     **/
+     */
     params: AgnosticRouteMatch["params"];
-    /** The return value from the matched route's loader or clientLoader */
-    data: Data;
-    /** The {@link https://reactrouter.com/start/framework/route-module#handle handle object} exported from the matched route module */
+    /**
+     * 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;
 }
 /**
  * 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.
  */
 declare function generatePath<Path extends string>(originalPath: Path, params?: {
     [key in PathParam<Path>]: string | null;
 }): string;
 /**
- * A PathPattern is used to match on some portion of a URL pathname.
+ * Used to match on some portion of a URL pathname.
  */
 interface PathPattern<Path extends string = string> {
     /**
      * A string to match against a URL pathname. May contain `:id`-style segments
-     * to indicate placeholders for dynamic parameters. May also end with `/*` to
-     * indicate matching the rest of the URL pathname.
+     * to indicate placeholders for dynamic parameters. It May also end with `/*`
+     * to indicate matching the rest of the URL pathname.
      */
     path: Path;
     /**
@@ -687,7 +823,7 @@ interface PathPattern<Path extends string = string> {
     end?: boolean;
 }
 /**
- * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+ * Contains info about how a {@link PathPattern} matched on a URL pathname.
  */
 interface PathMatch<ParamKey extends string = string> {
     /**
@@ -711,13 +847,26 @@ interface PathMatch<ParamKey extends string = string> {
  * 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.
  */
 declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
 /**
- * Returns a resolved path object relative to the given pathname.
+ * 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.
  */
 declare function resolvePath(to: To, fromPathname?: string): Path;
 declare class DataWithResponseInit<D> {
@@ -727,35 +876,116 @@ declare class DataWithResponseInit<D> {
     constructor(data: D, init?: ResponseInit);
 }
 /**
- * Create "responses" that contain `status`/`headers` without forcing
- * serialization into an actual `Response` - used by Remix single fetch
+ * 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.
  */
 declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
 type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
 /**
- * A redirect response. Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
+ * Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
  *
+ * @example
+ * import { redirect } from "react-router";
+ *
+ * export async function loader({ request }: Route.LoaderArgs) {
+ *   if (!isLoggedIn(request))
+ *     throw redirect("/login");
+ *   }
+ *
+ *   // ...
+ * }
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param url The URL to redirect to.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header.
  */
 declare const redirect: RedirectFunction;
 /**
- * A redirect response that will force a document reload to the new location.
- * Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * that will force a document reload to the new location. Sets the status code
+ * and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
  *
+ * ```tsx filename=routes/logout.tsx
+ * import { redirectDocument } from "react-router";
+ *
+ * import { destroySession } from "../sessions.server";
+ *
+ * export async function action({ request }: Route.ActionArgs) {
+ *   let session = await getSession(request.headers.get("Cookie"));
+ *   return redirectDocument("/", {
+ *     headers: { "Set-Cookie": await destroySession(session) }
+ *   });
+ * }
+ * ```
+ *
+ * @public
  * @category Utils
+ * @mode framework
+ * @mode data
+ * @param url The URL to redirect to.
+ * @param init The status code or a `ResponseInit` object to be included in the
+ * response.
+ * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+ * header.
  */
 declare const redirectDocument: RedirectFunction;
 /**
- * A redirect response that will perform a `history.replaceState` instead of a
- * `history.pushState` for client-side navigation redirects.
- * Sets the status code and the `Location` header.
- * Defaults to "302 Found".
+ * 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.
  */
 declare const replace: RedirectFunction;
 type ErrorResponse = {
@@ -763,14 +993,6 @@ type ErrorResponse = {
     statusText: string;
     data: any;
 };
-/**
- * @private
- * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
- *
- * We don't export the class for public use since it's an implementation
- * detail, but we export the interface above so folks can build their own
- * abstractions around instances via isRouteErrorResponse()
- */
 declare class ErrorResponseImpl implements ErrorResponse {
     status: number;
     statusText: string;
@@ -780,10 +1002,35 @@ declare class ErrorResponseImpl implements ErrorResponse {
     constructor(status: number, statusText: string | undefined, data: any, internal?: boolean);
 }
 /**
- * Check if the given error is an ErrorResponse generated from a 4xx/5xx
- * Response thrown from an action/loader
+ * 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)/[`loader`](../../start/framework/route-module#loader)
+ *
+ * @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.
+ *
  */
 declare function isRouteErrorResponse(error: any): error is ErrorResponse;
 
@@ -1061,7 +1308,7 @@ interface RouterInit {
     routes: AgnosticRouteObject[];
     history: History;
     basename?: string;
-    unstable_getContext?: () => MaybePromise<unstable_InitialContext>;
+    unstable_getContext?: () => MaybePromise<unstable_RouterContextProvider>;
     mapRouteProperties?: MapRoutePropertiesFunction;
     future?: Partial<FutureConfig>;
     hydrationRouteProperties?: string[];
@@ -1096,14 +1343,13 @@ interface StaticHandler {
         skipLoaderErrorBubbling?: boolean;
         skipRevalidation?: boolean;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_respond?: (staticContext: StaticHandlerContext) => MaybePromise<Response>;
-        unstable_stream?: (context: unstable_RouterContextProvider, query: (r: Request) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
+        unstable_generateMiddlewareResponse?: (query: (r: Request) => Promise<StaticHandlerContext | Response>) => MaybePromise<Response>;
     }): Promise<StaticHandlerContext | Response>;
     queryRoute(request: Request, opts?: {
         routeId?: string;
         requestContext?: unknown;
         dataStrategy?: DataStrategyFunction<unknown>;
-        unstable_respond?: (res: Response) => MaybePromise<Response>;
+        unstable_generateMiddlewareResponse?: (queryRoute: (r: Request) => Promise<Response>) => MaybePromise<Response>;
     }): Promise<any>;
 }
 type ViewTransitionOpts = {
@@ -1454,463 +1700,4 @@ interface RouteContextObject {
 }
 declare const RouteContext: React.Context<RouteContextObject>;
 
-/**
- * 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"> {
-    /**
-     * The absolute path of the page to prefetch.
-     */
-    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;
-    unstable_clientMiddleware?: unstable_MiddlewareFunction<undefined>[];
-    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;
-    unstable_middleware?: unstable_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"];
-    data: 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>> {
-    data: (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 Set<infer U> ? Set<Serialize<U>> : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [Serialize<F>, ...Serialize<R>] : T extends Array<infer U> ? Array<Serialize<U>> : T extends readonly unknown[] ? readonly Serialize<T[number]>[] : T extends Record<any, any> ? {
-    [K in keyof T]: Serialize<T[K]>;
-} : 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.unstable_middleware` is not enabled, this is undefined.
-     *
-     * When `future.unstable_middleware` is enabled, this is an instance of
-     * `unstable_RouterContextProvider` and can be used to access context values
-     * from your route middlewares.  You may pass in initial context values in your
-     * `<HydratedRouter unstable_getContext>` prop
-     */
-    context: unstable_RouterContextProvider;
-};
-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.unstable_middleware` enabled, this is the context passed in
-     * to your server adapter's `getLoadContext` function. It's a way to bridge the
-     * gap between the adapter's request/response API with your React Router app.
-     * It is only applicable if you are using a custom server adapter.
-     *
-     * With `future.unstable_middleware` enabled, this is an instance of
-     * `unstable_RouterContextProvider` and can be used for type-safe access to
-     * context value set in your route middlewares.  If you are using a custom
-     * server adapter, you may provide an initial set of context values from your
-     * `getLoadContext` function.
-     */
-    context: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext;
-};
-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 RouterState as $, Action as A, type BlockerFunction as B, type ClientActionFunction as C, type DataStrategyFunction as D, type Blocker as E, type FutureConfig as F, type GetLoaderData as G, type HydrationState as H, type InitialEntry as I, type SerializeFrom as J, type ParamParseKey as K, type LazyRouteFunction as L, type MetaFunction as M, type NonIndexRouteObject as N, type Path as O, type PatchRoutesOnNavigationFunction as P, type PathPattern as Q, type Router as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type PathMatch as V, type Navigation as W, type AppLoadContext as X, type MiddlewareEnabled as Y, type unstable_InitialContext as Z, type Equal as _, type RelativeRoutingType as a, type ServerRouteModule as a$, type DataRouteObject as a0, type StaticHandler as a1, type GetScrollPositionFunction as a2, type GetScrollRestorationKeyFunction as a3, type StaticHandlerContext as a4, type Fetcher as a5, type NavigationStates as a6, type RouterSubscriber as a7, type RouterNavigateOptions as a8, type RouterFetchOptions as a9, matchRoutes as aA, redirect as aB, redirectDocument as aC, replace as aD, resolvePath as aE, type DataRouteMatch as aF, type PatchRoutesOnNavigationFunctionArgs as aG, type ClientActionFunctionArgs as aH, type ClientLoaderFunctionArgs as aI, type HeadersArgs as aJ, type MetaArgs as aK, type PageLinkDescriptor as aL, type HtmlLinkDescriptor as aM, type Future as aN, type unstable_SerializesTo as aO, createBrowserHistory as aP, invariant as aQ, createRouter as aR, ErrorResponseImpl as aS, DataRouterContext as aT, DataRouterStateContext as aU, FetchersContext as aV, LocationContext as aW, NavigationContext as aX, RouteContext as aY, ViewTransitionContext as aZ, type RouteManifest as a_, type RevalidationState as aa, type ActionFunctionArgs as ab, type DataStrategyFunctionArgs as ac, type DataStrategyMatch as ad, type DataStrategyResult as ae, DataWithResponseInit as af, type ErrorResponse as ag, type FormEncType as ah, type FormMethod as ai, type HTMLFormMethod as aj, type LoaderFunctionArgs as ak, type unstable_MiddlewareFunction as al, type PathParam as am, type RedirectFunction as an, type unstable_RouterContext as ao, type ShouldRevalidateFunctionArgs as ap, unstable_createContext as aq, createPath as ar, parsePath as as, IDLE_NAVIGATION as at, IDLE_FETCHER as au, IDLE_BLOCKER as av, data as aw, generatePath as ax, isRouteErrorResponse as ay, matchPath as az, type IndexRouteObject as b, type History as b0, type CreateStaticHandlerOptions as b1, type Location as c, type Navigator as d, type RouterInit as e, type RouteObject as f, type RouteMatch as g, type Params as h, type ActionFunction as i, type ClientLoaderFunction as j, type HeadersFunction as k, type LinksFunction as l, type LoaderFunction as m, type RouteModule as n, type LinkDescriptor as o, type Pretty as p, type MetaDescriptor as q, type ServerDataFunctionArgs as r, type unstable_MiddlewareNextFunction as s, type ClientDataFunctionArgs as t, unstable_RouterContextProvider as u, type ServerDataFrom as v, type Normalize as w, type GetActionData as x, type RouteModules as y, type NavigateOptions as z };
+export { type ErrorResponse as $, Action as A, type BlockerFunction as B, type StaticHandler as C, type DataStrategyFunction as D, type GetScrollRestorationKeyFunction as E, type FutureConfig as F, type GetScrollPositionFunction as G, type HydrationState as H, type InitialEntry as I, type StaticHandlerContext as J, type Fetcher as K, type LazyRouteFunction as L, type MiddlewareEnabled as M, type NonIndexRouteObject as N, type NavigationStates as O, type PatchRoutesOnNavigationFunction as P, type RouterSubscriber as Q, type Router as R, type ShouldRevalidateFunction as S, type To as T, type UIMatch as U, type RouterNavigateOptions as V, type RouterFetchOptions as W, type RevalidationState as X, type DataStrategyFunctionArgs as Y, type DataStrategyMatch as Z, type DataStrategyResult as _, type RelativeRoutingType as a, type FormEncType as a0, type FormMethod as a1, type HTMLFormMethod as a2, type PathParam as a3, type RedirectFunction as a4, type unstable_RouterContext as a5, type ShouldRevalidateFunctionArgs as a6, unstable_createContext as a7, createPath as a8, parsePath as a9, type History as aA, type CreateStaticHandlerOptions as aB, IDLE_NAVIGATION as aa, IDLE_FETCHER as ab, IDLE_BLOCKER as ac, data as ad, generatePath as ae, isRouteErrorResponse as af, matchPath as ag, matchRoutes as ah, redirect as ai, redirectDocument as aj, replace as ak, resolvePath as al, type PatchRoutesOnNavigationFunctionArgs as am, type Future as an, createBrowserHistory as ao, invariant as ap, createRouter as aq, ErrorResponseImpl as ar, DataRouterContext as as, DataRouterStateContext as at, FetchersContext as au, LocationContext as av, NavigationContext as aw, RouteContext as ax, ViewTransitionContext as ay, type RouteManifest as az, type IndexRouteObject as b, type Location as c, type Navigator as d, type RouterInit as e, type RouteObject as f, type RouteMatch as g, type Params as h, type ActionFunctionArgs as i, type LoaderFunctionArgs as j, type ActionFunction as k, type LoaderFunction as l, type DataRouteMatch as m, type unstable_MiddlewareFunction as n, unstable_RouterContextProvider as o, DataWithResponseInit as p, type NavigateOptions as q, type Blocker as r, type ParamParseKey as s, type Path as t, type unstable_MiddlewareNextFunction as u, type PathPattern as v, type PathMatch as w, type Navigation as x, type RouterState as y, type DataRouteObject as z };