react-router 7.18.0 → 8.0.0-pre.1

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

@@ -1,184 +0,0 @@
-import { R as RouteModule, e as LinkDescriptor, L as Location, F as Func, f as Pretty, g as MetaDescriptor, G as GetLoaderData, h as ServerDataFunctionArgs, i as MiddlewareNextFunction, j as ClientDataFunctionArgs, D as DataStrategyResult, k as ServerDataFrom, N as Normalize, l as GetActionData } from '../../data-DEjBmEfD.mjs';
-import { R as RouteFiles, P as Pages } from '../../register-CmkRspdl.mjs';
-import 'react';
-
-type MaybePromise<T> = T | Promise<T>;
-type Props = {
-    params: unknown;
-    loaderData: unknown;
-    actionData: unknown;
-};
-type RouteInfo = Props & {
-    module: RouteModule;
-    matches: Array<MatchInfo>;
-};
-type MatchInfo = {
-    id: string;
-    module: RouteModule;
-};
-type MetaMatch<T extends MatchInfo> = Pretty<{
-    id: T["id"];
-    params: Record<string, string | undefined>;
-    pathname: string;
-    meta: MetaDescriptor[];
-    /** @deprecated Use `MetaMatch.loaderData` instead */
-    data: GetLoaderData<T["module"]>;
-    loaderData: GetLoaderData<T["module"]>;
-    handle?: unknown;
-    error?: unknown;
-}>;
-type MetaMatches<T extends Array<MatchInfo>> = T extends [infer F extends MatchInfo, ...infer R extends Array<MatchInfo>] ? [MetaMatch<F>, ...MetaMatches<R>] : Array<MetaMatch<MatchInfo> | undefined>;
-type HasErrorBoundary<T extends RouteInfo> = T["module"] extends {
-    ErrorBoundary: Func;
-} ? true : false;
-type CreateMetaArgs<T extends RouteInfo> = {
-    /** This is the current router `Location` object. This is useful for generating tags for routes at specific paths or query parameters. */
-    location: Location;
-    /** {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route. */
-    params: T["params"];
-    /**
-     * The return value for this route's server loader function
-     *
-     * @deprecated Use `Route.MetaArgs.loaderData` instead
-     */
-    data: T["loaderData"] | (HasErrorBoundary<T> extends true ? undefined : never);
-    /** The return value for this route's server loader function */
-    loaderData: T["loaderData"] | (HasErrorBoundary<T> extends true ? undefined : never);
-    /** Thrown errors that trigger error boundaries will be passed to the meta function. This is useful for generating metadata for error pages. */
-    error?: unknown;
-    /** An array of the current {@link https://api.reactrouter.com/v7/interfaces/react-router.UIMatch.html route matches}, including parent route matches. */
-    matches: MetaMatches<T["matches"]>;
-};
-type MetaDescriptors = MetaDescriptor[];
-type HeadersArgs = {
-    loaderHeaders: Headers;
-    parentHeaders: Headers;
-    actionHeaders: Headers;
-    errorHeaders: Headers | undefined;
-};
-type CreateServerMiddlewareFunction<T extends RouteInfo> = (args: ServerDataFunctionArgs<T["params"]>, next: MiddlewareNextFunction<Response>) => MaybePromise<Response | void>;
-type CreateClientMiddlewareFunction<T extends RouteInfo> = (args: ClientDataFunctionArgs<T["params"]>, next: MiddlewareNextFunction<Record<string, DataStrategyResult>>) => MaybePromise<Record<string, DataStrategyResult> | void>;
-type CreateServerLoaderArgs<T extends RouteInfo> = ServerDataFunctionArgs<T["params"]>;
-type CreateClientLoaderArgs<T extends RouteInfo> = ClientDataFunctionArgs<T["params"]> & {
-    /** This is an asynchronous function to get the data from the server loader for this route. On client-side navigations, this will make a {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server loader. If you opt-into running your clientLoader on hydration, then this function will return the data that was already loaded on the server (via Promise.resolve). */
-    serverLoader: () => Promise<ServerDataFrom<T["module"]["loader"]>>;
-};
-type CreateServerActionArgs<T extends RouteInfo> = ServerDataFunctionArgs<T["params"]>;
-type CreateClientActionArgs<T extends RouteInfo> = ClientDataFunctionArgs<T["params"]> & {
-    /** This is an asynchronous function that makes the {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API fetch} call to the React Router server action for this route. */
-    serverAction: () => Promise<ServerDataFrom<T["module"]["action"]>>;
-};
-type CreateHydrateFallbackProps<T extends RouteInfo, RSCEnabled extends boolean> = {
-    params: T["params"];
-} & (RSCEnabled extends true ? {
-    /** The data returned from the `loader` */
-    loaderData?: ServerDataFrom<T["module"]["loader"]>;
-    /** The data returned from the `action` following an action submission. */
-    actionData?: ServerDataFrom<T["module"]["action"]>;
-} : {
-    /** The data returned from the `loader` or `clientLoader` */
-    loaderData?: T["loaderData"];
-    /** The data returned from the `action` or `clientAction` following an action submission. */
-    actionData?: T["actionData"];
-});
-type Match<T extends MatchInfo> = Pretty<{
-    id: T["id"];
-    params: Record<string, string | undefined>;
-    pathname: string;
-    /** @deprecated Use `Match.loaderData` instead */
-    data: GetLoaderData<T["module"]>;
-    loaderData: GetLoaderData<T["module"]>;
-    handle: unknown;
-}>;
-type Matches<T extends Array<MatchInfo>> = T extends [infer F extends MatchInfo, ...infer R extends Array<MatchInfo>] ? [Match<F>, ...Matches<R>] : Array<Match<MatchInfo> | undefined>;
-type CreateComponentProps<T extends RouteInfo, RSCEnabled extends boolean> = {
-    /**
-     * {@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 default function Component({
-     *   params,
-     * }: Route.ComponentProps) {
-     *   params.teamId;
-     *   //        ^ string
-     * }
-     **/
-    params: T["params"];
-    /** An array of the current {@link https://api.reactrouter.com/v7/interfaces/react-router.UIMatch.html route matches}, including parent route matches. */
-    matches: Matches<T["matches"]>;
-} & (RSCEnabled extends true ? {
-    /** The data returned from the `loader` */
-    loaderData: ServerDataFrom<T["module"]["loader"]>;
-    /** The data returned from the `action` following an action submission. */
-    actionData?: ServerDataFrom<T["module"]["action"]>;
-} : {
-    /** The data returned from the `loader` or `clientLoader` */
-    loaderData: T["loaderData"];
-    /** The data returned from the `action` or `clientAction` following an action submission. */
-    actionData?: T["actionData"];
-});
-type CreateErrorBoundaryProps<T extends RouteInfo, RSCEnabled extends boolean> = {
-    /**
-     * {@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 ErrorBoundary({
-     *   params,
-     * }: Route.ErrorBoundaryProps) {
-     *   params.teamId;
-     *   //        ^ string
-     * }
-     **/
-    params: T["params"];
-    error: unknown;
-} & (RSCEnabled extends true ? {
-    /** The data returned from the `loader` */
-    loaderData?: ServerDataFrom<T["module"]["loader"]>;
-    /** The data returned from the `action` following an action submission. */
-    actionData?: ServerDataFrom<T["module"]["action"]>;
-} : {
-    /** The data returned from the `loader` or `clientLoader` */
-    loaderData?: T["loaderData"];
-    /** The data returned from the `action` or `clientAction` following an action submission. */
-    actionData?: T["actionData"];
-});
-type GetAnnotations<Info extends RouteInfo> = {
-    LinkDescriptors: LinkDescriptor[];
-    LinksFunction: () => LinkDescriptor[];
-    MetaArgs: CreateMetaArgs<Info>;
-    MetaDescriptors: MetaDescriptors;
-    MetaFunction: (args: CreateMetaArgs<Info>) => MetaDescriptors;
-    HeadersArgs: HeadersArgs;
-    HeadersFunction: (args: HeadersArgs) => Headers | HeadersInit;
-    MiddlewareFunction: CreateServerMiddlewareFunction<Info>;
-    ClientMiddlewareFunction: CreateClientMiddlewareFunction<Info>;
-    LoaderArgs: CreateServerLoaderArgs<Info>;
-    ClientLoaderArgs: CreateClientLoaderArgs<Info>;
-    ActionArgs: CreateServerActionArgs<Info>;
-    ClientActionArgs: CreateClientActionArgs<Info>;
-    HydrateFallbackProps: CreateHydrateFallbackProps<Info, false>;
-    ServerHydrateFallbackProps: CreateHydrateFallbackProps<Info, true>;
-    ComponentProps: CreateComponentProps<Info, false>;
-    ServerComponentProps: CreateComponentProps<Info, true>;
-    ErrorBoundaryProps: CreateErrorBoundaryProps<Info, false>;
-    ServerErrorBoundaryProps: CreateErrorBoundaryProps<Info, true>;
-};
-
-type Params<RouteFile extends keyof RouteFiles> = Normalize<Pages[RouteFiles[RouteFile]["page"]]["params"]>;
-
-type GetInfo<T extends {
-    file: keyof RouteFiles;
-    module: RouteModule;
-}> = {
-    params: Params<T["file"]>;
-    loaderData: GetLoaderData<T["module"]>;
-    actionData: GetActionData<T["module"]>;
-};
-
-export type { GetAnnotations, GetInfo };

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

@@ -1,10 +0,0 @@
-/**
- * react-router v7.18.0
- *
- * Copyright (c) Remix Software Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */

package/dist/development/register-CmkRspdl.d.mts

@@ -1,30 +0,0 @@
-import { R as RouteModule } from './data-DEjBmEfD.mjs';
-
-/**
- * Apps can use this interface to "register" app-wide types for React Router via interface declaration merging and module augmentation.
- * React Router should handle this for you via type generation.
- *
- * For more on declaration merging and module augmentation, see https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation .
- */
-interface Register {
-}
-type AnyParams = Record<string, string | undefined>;
-type AnyPages = Record<string, {
-    params: AnyParams;
-}>;
-type Pages = Register extends {
-    pages: infer Registered extends AnyPages;
-} ? Registered : AnyPages;
-type AnyRouteFiles = Record<string, {
-    id: string;
-    page: string;
-}>;
-type RouteFiles = Register extends {
-    routeFiles: infer Registered extends AnyRouteFiles;
-} ? Registered : AnyRouteFiles;
-type AnyRouteModules = Record<string, RouteModule>;
-type RouteModules = Register extends {
-    routeModules: infer Registered extends AnyRouteModules;
-} ? Registered : AnyRouteModules;
-
-export type { Pages as P, RouteFiles as R, RouteModules as a, Register as b };

package/dist/production/browser-B2PdsXXH.d.ts

@@ -1,318 +0,0 @@
-import * as React from 'react';
-import { R as RouterInit } from './instrumentation-Dkmpzd13.js';
-import { L as Location, C as ClientActionFunction, a as ClientLoaderFunction, b as LinksFunction, M as MetaFunction, S as ShouldRevalidateFunction, P as Params, c as RouterContextProvider, A as ActionFunction, H as HeadersFunction, d as LoaderFunction } from './data-CjO11-hU.js';
-
-declare function getRequest(): Request;
-type RSCRouteConfigEntryBase = {
-    action?: ActionFunction;
-    clientAction?: ClientActionFunction;
-    clientLoader?: ClientLoaderFunction;
-    ErrorBoundary?: React.ComponentType<any>;
-    handle?: any;
-    headers?: HeadersFunction;
-    HydrateFallback?: React.ComponentType<any>;
-    Layout?: React.ComponentType<any>;
-    links?: LinksFunction;
-    loader?: LoaderFunction;
-    meta?: MetaFunction;
-    shouldRevalidate?: ShouldRevalidateFunction;
-};
-type RSCRouteConfigEntry = RSCRouteConfigEntryBase & {
-    id: string;
-    path?: string;
-    Component?: React.ComponentType<any>;
-    lazy?: () => Promise<RSCRouteConfigEntryBase & ({
-        default?: React.ComponentType<any>;
-        Component?: never;
-    } | {
-        default?: never;
-        Component?: React.ComponentType<any>;
-    })>;
-} & ({
-    index: true;
-} | {
-    children?: RSCRouteConfigEntry[];
-});
-type RSCRouteConfig = Array<RSCRouteConfigEntry>;
-type RSCRouteManifest = {
-    clientAction?: ClientActionFunction;
-    clientLoader?: ClientLoaderFunction;
-    element?: React.ReactElement | false;
-    errorElement?: React.ReactElement;
-    handle?: any;
-    hasAction: boolean;
-    hasComponent: boolean;
-    hasErrorBoundary: boolean;
-    hasLoader: boolean;
-    hydrateFallbackElement?: React.ReactElement;
-    id: string;
-    index?: boolean;
-    links?: LinksFunction;
-    meta?: MetaFunction;
-    parentId?: string;
-    path?: string;
-    shouldRevalidate?: ShouldRevalidateFunction;
-};
-type RSCRouteMatch = RSCRouteManifest & {
-    params: Params;
-    pathname: string;
-    pathnameBase: string;
-};
-type RSCRenderPayload = {
-    type: "render";
-    actionData: Record<string, any> | null;
-    basename: string | undefined;
-    errors: Record<string, any> | null;
-    loaderData: Record<string, any>;
-    location: Location;
-    routeDiscovery: RouteDiscovery;
-    matches: RSCRouteMatch[];
-    patches?: Promise<RSCRouteManifest[]>;
-    nonce?: string;
-    formState?: unknown;
-};
-type RSCManifestPayload = {
-    type: "manifest";
-    patches: Promise<RSCRouteManifest[]>;
-};
-type RSCActionPayload = {
-    type: "action";
-    actionResult: Promise<unknown>;
-    rerender?: Promise<RSCRenderPayload | RSCRedirectPayload>;
-};
-type RSCRedirectPayload = {
-    type: "redirect";
-    status: number;
-    location: string;
-    replace: boolean;
-    reload: boolean;
-    actionResult?: Promise<unknown>;
-};
-type RSCPayload = RSCRenderPayload | RSCManifestPayload | RSCActionPayload | RSCRedirectPayload;
-type RSCMatch = {
-    statusCode: number;
-    headers: Headers;
-    payload: RSCPayload;
-};
-type DecodeActionFunction = (formData: FormData) => Promise<() => Promise<unknown>>;
-type DecodeFormStateFunction = (result: unknown, formData: FormData) => unknown;
-type DecodeReplyFunction = (reply: FormData | string, options: {
-    temporaryReferences: unknown;
-}) => Promise<unknown[]>;
-type LoadServerActionFunction = (id: string) => Promise<Function>;
-type RouteDiscovery = {
-    mode: "lazy";
-    manifestPath?: string | undefined;
-} | {
-    mode: "initial";
-};
-/**
- * Matches the given routes to a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
- * and returns an [RSC](https://react.dev/reference/rsc/server-components)
- * [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
- * encoding an {@link unstable_RSCPayload} for consumption by an [RSC](https://react.dev/reference/rsc/server-components)
- * enabled client router.
- *
- * @example
- * import {
- *   createTemporaryReferenceSet,
- *   decodeAction,
- *   decodeReply,
- *   loadServerAction,
- *   renderToReadableStream,
- * } from "@vitejs/plugin-rsc/rsc";
- * import { unstable_matchRSCServerRequest as matchRSCServerRequest } from "react-router";
- *
- * matchRSCServerRequest({
- *   createTemporaryReferenceSet,
- *   decodeAction,
- *   decodeFormState,
- *   decodeReply,
- *   loadServerAction,
- *   request,
- *   routes: routes(),
- *   generateResponse(match) {
- *     return new Response(
- *       renderToReadableStream(match.payload),
- *       {
- *         status: match.statusCode,
- *         headers: match.headers,
- *       }
- *     );
- *   },
- * });
- *
- * @name unstable_matchRSCServerRequest
- * @public
- * @category RSC
- * @mode data
- * @param opts Options
- * @param opts.allowedActionOrigins Origin patterns that are allowed to execute actions.
- * @param opts.basename The basename to use when matching the request.
- * @param opts.createTemporaryReferenceSet A function that returns a temporary
- * reference set for the request, used to track temporary references in the [RSC](https://react.dev/reference/rsc/server-components)
- * stream.
- * @param opts.decodeAction Your `react-server-dom-xyz/server`'s `decodeAction`
- * function, responsible for loading a server action.
- * @param opts.decodeFormState A function responsible for decoding form state for
- * progressively enhanceable forms with React's [`useActionState`](https://react.dev/reference/react/useActionState)
- * using your `react-server-dom-xyz/server`'s `decodeFormState`.
- * @param opts.decodeReply Your `react-server-dom-xyz/server`'s `decodeReply`
- * function, used to decode the server function's arguments and bind them to the
- * implementation for invocation by the router.
- * @param opts.generateResponse A function responsible for using your
- * `renderToReadableStream` to generate a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
- * encoding the {@link unstable_RSCPayload}.
- * @param opts.loadServerAction Your `react-server-dom-xyz/server`'s
- * `loadServerAction` function, used to load a server action by ID.
- * @param opts.onError An optional error handler that will be called with any
- * errors that occur during the request processing.
- * @param opts.request The [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
- * to match against.
- * @param opts.requestContext An instance of {@link RouterContextProvider}
- * that should be created per request, to be passed to [`action`](../../start/data/route-object#action)s,
- * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
- * @param opts.routeDiscovery The route discovery configuration, used to determine how the router should discover new routes during navigations.
- * @param opts.routes Your {@link unstable_RSCRouteConfigEntry | route definitions}.
- * @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
- * that contains the [RSC](https://react.dev/reference/rsc/server-components)
- * data for hydration.
- */
-declare function matchRSCServerRequest({ allowedActionOrigins, createTemporaryReferenceSet, basename, decodeReply, requestContext, routeDiscovery, loadServerAction, decodeAction, decodeFormState, onError, request, routes, generateResponse, }: {
-    allowedActionOrigins?: string[];
-    createTemporaryReferenceSet: () => unknown;
-    basename?: string;
-    decodeReply?: DecodeReplyFunction;
-    decodeAction?: DecodeActionFunction;
-    decodeFormState?: DecodeFormStateFunction;
-    requestContext?: RouterContextProvider;
-    loadServerAction?: LoadServerActionFunction;
-    onError?: (error: unknown) => void;
-    request: Request;
-    routes: RSCRouteConfigEntry[];
-    routeDiscovery?: RouteDiscovery;
-    generateResponse: (match: RSCMatch, { onError, temporaryReferences, }: {
-        onError(error: unknown): string | undefined;
-        temporaryReferences: unknown;
-    }) => Response;
-}): Promise<Response>;
-
-type BrowserCreateFromReadableStreamFunction = (body: ReadableStream<Uint8Array>, { temporaryReferences, }: {
-    temporaryReferences: unknown;
-}) => Promise<unknown>;
-type EncodeReplyFunction = (args: unknown[], options: {
-    temporaryReferences: unknown;
-}) => Promise<BodyInit>;
-/**
- * Create a React `callServer` implementation for React Router.
- *
- * @example
- * import {
- *   createFromReadableStream,
- *   createTemporaryReferenceSet,
- *   encodeReply,
- *   setServerCallback,
- * } from "@vitejs/plugin-rsc/browser";
- * import { unstable_createCallServer as createCallServer } from "react-router";
- *
- * setServerCallback(
- *   createCallServer({
- *     createFromReadableStream,
- *     createTemporaryReferenceSet,
- *     encodeReply,
- *   })
- * );
- *
- * @name unstable_createCallServer
- * @public
- * @category RSC
- * @mode data
- * @param opts Options
- * @param opts.createFromReadableStream Your `react-server-dom-xyz/client`'s
- * `createFromReadableStream`. Used to decode payloads from the server.
- * @param opts.createTemporaryReferenceSet A function that creates a temporary
- * reference set for the [RSC](https://react.dev/reference/rsc/server-components)
- * payload.
- * @param opts.encodeReply Your `react-server-dom-xyz/client`'s `encodeReply`.
- * Used when sending payloads to the server.
- * @param opts.fetch Optional [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)
- * implementation. Defaults to global [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch).
- * @returns A function that can be used to call server actions.
- */
-declare function createCallServer({ createFromReadableStream, createTemporaryReferenceSet, encodeReply, fetch: fetchImplementation, }: {
-    createFromReadableStream: BrowserCreateFromReadableStreamFunction;
-    createTemporaryReferenceSet: () => unknown;
-    encodeReply: EncodeReplyFunction;
-    fetch?: (request: Request) => Promise<Response>;
-}): (id: string, args: unknown[]) => Promise<unknown>;
-/**
- * Props for the {@link unstable_RSCHydratedRouter} component.
- *
- * @name unstable_RSCHydratedRouterProps
- * @category Types
- */
-interface RSCHydratedRouterProps {
-    /**
-     * Your `react-server-dom-xyz/client`'s `createFromReadableStream` function,
-     * used to decode payloads from the server.
-     */
-    createFromReadableStream: BrowserCreateFromReadableStreamFunction;
-    /**
-     * Optional fetch implementation. Defaults to global [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/fetch).
-     */
-    fetch?: (request: Request) => Promise<Response>;
-    /**
-     * The decoded {@link unstable_RSCPayload} to hydrate.
-     */
-    payload: RSCPayload;
-    /**
-     * A function that returns an {@link RouterContextProvider} instance
-     * which is provided as the `context` argument to client [`action`](../../start/data/route-object#action)s,
-     * [`loader`](../../start/data/route-object#loader)s and [middleware](../../how-to/middleware).
-     * This function is called to generate a fresh `context` instance on each
-     * navigation or fetcher call.
-     */
-    getContext?: RouterInit["getContext"];
-}
-/**
- * Hydrates a server rendered {@link unstable_RSCPayload} in the browser.
- *
- * @example
- * import { startTransition, StrictMode } from "react";
- * import { hydrateRoot } from "react-dom/client";
- * import {
- *   unstable_getRSCStream as getRSCStream,
- *   unstable_RSCHydratedRouter as RSCHydratedRouter,
- * } from "react-router";
- * import type { unstable_RSCPayload as RSCPayload } from "react-router";
- *
- * createFromReadableStream(getRSCStream()).then((payload) =>
- *   startTransition(async () => {
- *     hydrateRoot(
- *       document,
- *       <StrictMode>
- *         <RSCHydratedRouter
- *           createFromReadableStream={createFromReadableStream}
- *           payload={payload}
- *         />
- *       </StrictMode>,
- *       { formState: await getFormState(payload) },
- *     );
- *   }),
- * );
- *
- * @name unstable_RSCHydratedRouter
- * @public
- * @category RSC
- * @mode data
- * @param props Props
- * @param {unstable_RSCHydratedRouterProps.createFromReadableStream} props.createFromReadableStream n/a
- * @param {unstable_RSCHydratedRouterProps.fetch} props.fetch n/a
- * @param {unstable_RSCHydratedRouterProps.getContext} props.getContext n/a
- * @param {unstable_RSCHydratedRouterProps.payload} props.payload n/a
- * @returns A hydrated {@link DataRouter} that can be used to navigate and
- * render routes.
- */
-declare function RSCHydratedRouter({ createFromReadableStream, fetch: fetchImplementation, payload, getContext, }: RSCHydratedRouterProps): React.JSX.Element;
-
-export { type BrowserCreateFromReadableStreamFunction as B, type DecodeActionFunction as D, type EncodeReplyFunction as E, type LoadServerActionFunction as L, RSCHydratedRouter as R, type DecodeFormStateFunction as a, type DecodeReplyFunction as b, createCallServer as c, type RSCManifestPayload as d, type RSCPayload as e, type RSCRenderPayload as f, getRequest as g, type RSCHydratedRouterProps as h, type RSCMatch as i, type RSCRouteManifest as j, type RSCRouteMatch as k, type RSCRouteConfigEntry as l, matchRSCServerRequest as m, type RSCRouteConfig as n };