react-router 7.0.0-pre.1 → 7.0.0-pre.3

package/dist/{lib/dom/lib.d.ts → fog-of-war-BijhfqFM.d.ts}

@@ -1,14 +1,658 @@
-import * as React from "react";
-import type { History, To } from "../router/history";
-import type { BlockerFunction, Fetcher, FutureConfig, GetScrollRestorationKeyFunction, HydrationState, RelativeRoutingType, Router as DataRouter } from "../router/router";
-import type { DataStrategyFunction, HTMLFormMethod } from "../router/utils";
-import "./global";
-import type { SubmitOptions, URLSearchParamsInit, SubmitTarget, FetcherSubmitOptions } from "./dom";
-import type { DiscoverBehavior, PrefetchBehavior, ScriptsProps } from "./ssr/components";
-import type { RouteObject, NavigateOptions, PatchRoutesOnNavigationFunction } from "../context";
+import * as React from 'react';
+import { o as RouteObject, F as FutureConfig$1, H as HydrationState, I as InitialEntry, D as DataStrategyFunction, an as PatchRoutesOnNavigationFunction, a as Router$1, T as To, h as RelativeRoutingType, w as NonIndexRouteObject, a1 as LazyRouteFunction, v as IndexRouteObject, i as Location, j as Action, am as Navigator, ap as RouteMatch, s as StaticHandlerContext, d as RouteManifest, R as RouteModules, al as DataRouteObject, aI as RouteModule, a0 as HTMLFormMethod, _ as FormEncType, au as PageLinkDescriptor, aJ as History, y as GetScrollRestorationKeyFunction, N as NavigateOptions, z as Fetcher, S as SerializeFrom, B as BlockerFunction } from './types-BlYP8xpH.js';
+
+/**
+ * @private
+ */
+declare function mapRouteProperties(route: RouteObject): Partial<RouteObject> & {
+    hasErrorBoundary: boolean;
+};
+/**
+ * @category Routers
+ */
+declare function createMemoryRouter(routes: RouteObject[], opts?: {
+    basename?: string;
+    future?: Partial<FutureConfig$1>;
+    hydrationData?: HydrationState;
+    initialEntries?: InitialEntry[];
+    initialIndex?: number;
+    dataStrategy?: DataStrategyFunction;
+    patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
+}): Router$1;
+interface RouterProviderProps {
+    router: Router$1;
+    flushSync?: (fn: () => unknown) => undefined;
+}
+/**
+ * Given a Remix Router instance, render the appropriate UI
+ */
+declare function RouterProvider({ router, flushSync: reactDomFlushSyncImpl, }: RouterProviderProps): React.ReactElement;
+/**
+ * @category Types
+ */
+interface MemoryRouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    initialEntries?: InitialEntry[];
+    initialIndex?: number;
+}
+/**
+ * A `<Router>` that stores all entries in memory.
+ *
+ * @category Router Components
+ */
+declare function MemoryRouter({ basename, children, initialEntries, initialIndex, }: MemoryRouterProps): React.ReactElement;
+/**
+ * @category Types
+ */
+interface NavigateProps {
+    to: To;
+    replace?: boolean;
+    state?: any;
+    relative?: RelativeRoutingType;
+}
+/**
+ * A component-based version of {@link useNavigate} to use in a [`React.Component
+ * Class`](https://reactjs.org/docs/react-component.html) where hooks are not
+ * able to be used.
+ *
+ * It's recommended to avoid using this component in favor of {@link useNavigate}
+ *
+ * @category Components
+ */
+declare function Navigate({ to, replace, state, relative, }: NavigateProps): null;
+/**
+ * @category Types
+ */
+interface OutletProps {
+    /**
+      Provides a context value to the element tree below the outlet. Use when the parent route needs to provide values to child routes.
+  
+      ```tsx
+      <Outlet context={myContextValue} />
+      ```
+  
+      Access the context with {@link useOutletContext}.
+     */
+    context?: unknown;
+}
+/**
+  Renders the matching child route of a parent route or nothing if no child route matches.
+
+  ```tsx
+  import { Outlet } from "react-router"
+
+  export default function SomeParent() {
+    return (
+      <div>
+        <h1>Parent Content</h1>
+        <Outlet />
+      </div>
+    );
+  }
+  ```
+
+  @category Components
+ */
+declare function Outlet(props: OutletProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface PathRouteProps {
+    caseSensitive?: NonIndexRouteObject["caseSensitive"];
+    path?: NonIndexRouteObject["path"];
+    id?: NonIndexRouteObject["id"];
+    lazy?: LazyRouteFunction<NonIndexRouteObject>;
+    loader?: NonIndexRouteObject["loader"];
+    action?: NonIndexRouteObject["action"];
+    hasErrorBoundary?: NonIndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: NonIndexRouteObject["shouldRevalidate"];
+    handle?: NonIndexRouteObject["handle"];
+    index?: false;
+    children?: React.ReactNode;
+    element?: React.ReactNode | null;
+    hydrateFallbackElement?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    Component?: React.ComponentType | null;
+    HydrateFallback?: React.ComponentType | null;
+    ErrorBoundary?: React.ComponentType | null;
+}
+/**
+ * @category Types
+ */
+interface LayoutRouteProps extends PathRouteProps {
+}
+/**
+ * @category Types
+ */
+interface IndexRouteProps {
+    caseSensitive?: IndexRouteObject["caseSensitive"];
+    path?: IndexRouteObject["path"];
+    id?: IndexRouteObject["id"];
+    lazy?: LazyRouteFunction<IndexRouteObject>;
+    loader?: IndexRouteObject["loader"];
+    action?: IndexRouteObject["action"];
+    hasErrorBoundary?: IndexRouteObject["hasErrorBoundary"];
+    shouldRevalidate?: IndexRouteObject["shouldRevalidate"];
+    handle?: IndexRouteObject["handle"];
+    index: true;
+    children?: undefined;
+    element?: React.ReactNode | null;
+    hydrateFallbackElement?: React.ReactNode | null;
+    errorElement?: React.ReactNode | null;
+    Component?: React.ComponentType | null;
+    HydrateFallback?: React.ComponentType | null;
+    ErrorBoundary?: React.ComponentType | null;
+}
+type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;
+/**
+ * Configures an element to render when a pattern matches the current location.
+ * It must be rendered within a {@link Routes} element. Note that these routes
+ * do not participate in data loading, actions, code splitting, or any other
+ * route module features.
+ *
+ * @category Components
+ */
+declare function Route$1(_props: RouteProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface RouterProps {
+    basename?: string;
+    children?: React.ReactNode;
+    location: Partial<Location> | string;
+    navigationType?: Action;
+    navigator: Navigator;
+    static?: boolean;
+}
+/**
+ * Provides location context for the rest of the app.
+ *
+ * Note: You usually won't render a `<Router>` directly. Instead, you'll render a
+ * router that is more specific to your environment such as a `<BrowserRouter>`
+ * in web browsers or a `<StaticRouter>` for server rendering.
+ *
+ * @category Components
+ */
+declare function Router({ basename: basenameProp, children, location: locationProp, navigationType, navigator, static: staticProp, }: RouterProps): React.ReactElement | null;
+/**
+ * @category Types
+ */
+interface RoutesProps {
+    /**
+     * Nested {@link Route} elements
+     */
+    children?: React.ReactNode;
+    /**
+     * The location to match against. Defaults to the current location.
+     */
+    location?: Partial<Location> | string;
+}
+/**
+ Renders a branch of {@link Route | `<Routes>`} that best matches the current
+ location. Note that these routes do not participate in data loading, actions,
+ code splitting, or any other route module features.
+
+ ```tsx
+ import { Routes, Route } from "react-router"
+
+<Routes>
+  <Route index element={<StepOne />} />
+  <Route path="step-2" element={<StepTwo />} />
+  <Route path="step-3" element={<StepThree />}>
+</Routes>
+ ```
+
+ @category Components
+ */
+declare function Routes({ children, location, }: RoutesProps): React.ReactElement | null;
+interface AwaitResolveRenderFunction<Resolve = any> {
+    (data: Awaited<Resolve>): React.ReactNode;
+}
+/**
+ * @category Types
+ */
+interface AwaitProps<Resolve> {
+    /**
+    When using a function, the resolved value is provided as the parameter.
+  
+    ```tsx [2]
+    <Await resolve={reviewsPromise}>
+      {(resolvedReviews) => <Reviews items={resolvedReviews} />}
+    </Await>
+    ```
+  
+    When using React elements, {@link useAsyncValue} will provide the
+    resolved value:
+  
+    ```tsx [2]
+    <Await resolve={reviewsPromise}>
+      <Reviews />
+    </Await>
+  
+    function Reviews() {
+      const resolvedReviews = useAsyncValue()
+      return <div>...</div>
+    }
+    ```
+    */
+    children: React.ReactNode | AwaitResolveRenderFunction;
+    /**
+    The error element renders instead of the children when the promise rejects.
+  
+    ```tsx
+    <Await
+      errorElement={<div>Oops</div>}
+      resolve={reviewsPromise}
+    >
+      <Reviews />
+    </Await>
+    ```
+  
+    To provide a more contextual error, you can use the {@link useAsyncError} in a
+    child component
+  
+    ```tsx
+    <Await
+      errorElement={<ReviewsError />}
+      resolve={reviewsPromise}
+    >
+      <Reviews />
+    </Await>
+  
+    function ReviewsError() {
+      const error = useAsyncError()
+      return <div>Error loading reviews: {error.message}</div>
+    }
+    ```
+  
+    If you do not provide an errorElement, the rejected value will bubble up to
+    the nearest route-level {@link NonIndexRouteObject#ErrorBoundary | ErrorBoundary} and be accessible
+    via {@link useRouteError} hook.
+    */
+    errorElement?: React.ReactNode;
+    /**
+    Takes a promise returned from a {@link LoaderFunction | loader} value to be resolved and rendered.
+  
+    ```jsx
+    import { useLoaderData, Await } from "react-router"
+  
+    export async function loader() {
+      let reviews = getReviews() // not awaited
+      let book = await getBook()
+      return {
+        book,
+        reviews, // this is a promise
+      }
+    }
+  
+    export default function Book() {
+      const {
+        book,
+        reviews, // this is the same promise
+      } = useLoaderData()
+  
+      return (
+        <div>
+          <h1>{book.title}</h1>
+          <p>{book.description}</p>
+          <React.Suspense fallback={<ReviewsSkeleton />}>
+            <Await
+              // and is the promise we pass to Await
+              resolve={reviews}
+            >
+              <Reviews />
+            </Await>
+          </React.Suspense>
+        </div>
+      );
+    }
+    ```
+     */
+    resolve: Resolve;
+}
+/**
+Used to render promise values with automatic error handling.
+
+```tsx
+import { Await, useLoaderData } from "react-router";
+
+export function loader() {
+  // not awaited
+  const reviews = getReviews()
+  // awaited (blocks the transition)
+  const book = await fetch("/api/book").then((res) => res.json())
+  return { book, reviews }
+}
+
+function Book() {
+  const { book, reviews } = useLoaderData();
+  return (
+    <div>
+      <h1>{book.title}</h1>
+      <p>{book.description}</p>
+      <React.Suspense fallback={<ReviewsSkeleton />}>
+        <Await
+          resolve={reviews}
+          errorElement={
+            <div>Could not load reviews 😬</div>
+          }
+          children={(resolvedReviews) => (
+            <Reviews items={resolvedReviews} />
+          )}
+        />
+      </React.Suspense>
+    </div>
+  );
+}
+```
+
+**Note:** `<Await>` expects to be rendered inside of a `<React.Suspense>`
+
+@category Components
+
+*/
+declare function Await<Resolve>({ children, errorElement, resolve, }: AwaitProps<Resolve>): React.JSX.Element;
+/**
+ * Creates a route config from a React "children" object, which is usually
+ * either a `<Route>` element or an array of them. Used internally by
+ * `<Routes>` to create a route config from its children.
+ *
+ * @category Utils
+ */
+declare function createRoutesFromChildren(children: React.ReactNode, parentPath?: number[]): RouteObject[];
+/**
+ * Renders the result of `matchRoutes()` into a React element.
+ *
+ * @category Utils
+ */
+declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
+
+type SerializedError = {
+    message: string;
+    stack?: string;
+};
+interface FrameworkContextObject {
+    manifest: AssetsManifest;
+    routeModules: RouteModules;
+    criticalCss?: string;
+    serverHandoffString?: string;
+    future: FutureConfig;
+    isSpaMode: boolean;
+    abortDelay?: number;
+    serializeError?(error: Error): SerializedError;
+    renderMeta?: {
+        didRenderScripts?: boolean;
+        streamCache?: Record<number, Promise<void> & {
+            result?: {
+                done: boolean;
+                value: string;
+            };
+            error?: unknown;
+        }>;
+    };
+}
+interface EntryContext extends FrameworkContextObject {
+    staticHandlerContext: StaticHandlerContext;
+    serverHandoffStream?: ReadableStream<Uint8Array>;
+}
+interface FutureConfig {
+}
+interface AssetsManifest {
+    entry: {
+        imports: string[];
+        module: string;
+    };
+    routes: RouteManifest<EntryRoute>;
+    url: string;
+    version: string;
+    hmr?: {
+        timestamp?: number;
+        runtime: string;
+    };
+}
+
+interface Route {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
+}
+interface EntryRoute extends Route {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    parentId?: string;
+}
+declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, future: FutureConfig, isSpaMode: boolean): DataRouteObject[];
+declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
+declare function shouldHydrateRouteLoader(route: EntryRoute, routeModule: RouteModule, isSpaMode: boolean): boolean;
+
+type ParamKeyValuePair = [string, string];
+type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
+/**
+  Creates a URLSearchParams object using the given initializer.
+
+  This is identical to `new URLSearchParams(init)` except it also
+  supports arrays as values in the object form of the initializer
+  instead of just strings. This is convenient when you need multiple
+  values for a given key, but don't want to use an array initializer.
+
+  For example, instead of:
+
+  ```tsx
+  let searchParams = new URLSearchParams([
+    ['sort', 'name'],
+    ['sort', 'price']
+  ]);
+  ```
+  you can do:
+
+  ```
+  let searchParams = createSearchParams({
+    sort: ['name', 'price']
+  });
+  ```
+
+  @category Utils
+ */
+declare function createSearchParams(init?: URLSearchParamsInit): URLSearchParams;
+type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+type SubmitTarget = HTMLFormElement | HTMLButtonElement | HTMLInputElement | FormData | URLSearchParams | JsonValue | null;
+/**
+ * Submit options shared by both navigations and fetchers
+ */
+interface SharedSubmitOptions {
+    /**
+     * The HTTP method used to submit the form. Overrides `<form method>`.
+     * Defaults to "GET".
+     */
+    method?: HTMLFormMethod;
+    /**
+     * The action URL path used to submit the form. Overrides `<form action>`.
+     * Defaults to the path of the current route.
+     */
+    action?: string;
+    /**
+     * The encoding used to submit the form. Overrides `<form encType>`.
+     * Defaults to "application/x-www-form-urlencoded".
+     */
+    encType?: FormEncType;
+    /**
+     * Determines whether the form action is relative to the route hierarchy or
+     * the pathname.  Use this if you want to opt out of navigating the route
+     * hierarchy and want to instead route based on /-delimited URL segments
+     */
+    relative?: RelativeRoutingType;
+    /**
+     * In browser-based environments, prevent resetting scroll after this
+     * navigation when using the <ScrollRestoration> component
+     */
+    preventScrollReset?: boolean;
+    /**
+     * Enable flushSync for this submission's state updates
+     */
+    flushSync?: boolean;
+}
+/**
+ * Submit options available to fetchers
+ */
+interface FetcherSubmitOptions extends SharedSubmitOptions {
+}
+/**
+ * Submit options available to navigations
+ */
+interface SubmitOptions extends FetcherSubmitOptions {
+    /**
+     * Set `true` to replace the current entry in the browser's history stack
+     * instead of creating a new one (i.e. stay on "the same page"). Defaults
+     * to `false`.
+     */
+    replace?: boolean;
+    /**
+     * State object to add to the history stack entry for this navigation
+     */
+    state?: any;
+    /**
+     * Indicate a specific fetcherKey to use when using navigate=false
+     */
+    fetcherKey?: string;
+    /**
+     * navigate=false will use a fetcher instead of a navigation
+     */
+    navigate?: boolean;
+    /**
+     * Enable view transitions on this submission navigation
+     */
+    viewTransition?: boolean;
+}
+
+declare const FrameworkContext: React.Context<FrameworkContextObject | undefined>;
+/**
+ * Defines the discovery behavior of the link:
+ *
+ * - "render" - default, discover the route when the link renders
+ * - "none" - don't eagerly discover, only discover if the link is clicked
+ */
+type DiscoverBehavior = "render" | "none";
+/**
+ * Defines the prefetching behavior of the link:
+ *
+ * - "none": Never fetched
+ * - "intent": Fetched when the user focuses or hovers the link
+ * - "render": Fetched when the link is rendered
+ * - "viewport": Fetched when the link is in the viewport
+ */
+type PrefetchBehavior = "intent" | "render" | "none" | "viewport";
+/**
+  Renders all of the `<link>` tags created by route module {@link LinksFunction} export. You should render it inside the `<head>` of your document.
+
+  ```tsx
+  import { Links } from "react-router";
+
+  export default function Root() {
+    return (
+      <html>
+        <head>
+          <Links />
+        </head>
+        <body></body>
+      </html>
+    );
+  }
+  ```
+
+  @category Components
+ */
+declare function Links(): React.JSX.Element;
+/**
+  Renders `<link rel=prefetch|modulepreload>` tags for modules and data of another page to enable an instant navigation to that page. {@link LinkProps.prefetch | `<Link prefetch>`} uses this internally, but you can render it to prefetch a page for any other reason.
+
+  ```tsx
+  import { PrefetchPageLinks } from "react-router"
+
+  <PrefetchPageLinks page="/absolute/path" />
+  ```
+
+  For example, you may render one of this as the user types into a search field to prefetch search results before they click through to their selection.
+
+  @category Components
+ */
+declare function PrefetchPageLinks({ page, ...dataLinkProps }: PageLinkDescriptor): React.JSX.Element | null;
+/**
+  Renders all the `<meta>` tags created by route module {@link MetaFunction} exports. You should render it inside the `<head>` of your HTML.
+
+  ```tsx
+  import { Meta } from "react-router";
+
+  export default function Root() {
+    return (
+      <html>
+        <head>
+          <Meta />
+        </head>
+      </html>
+    );
+  }
+  ```
+
+  @category Components
+ */
+declare function Meta(): React.JSX.Element;
+/**
+  A couple common attributes:
+
+  - `<Scripts crossOrigin>` for hosting your static assets on a different server than your app.
+  - `<Scripts nonce>` to support a [content security policy for scripts](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src) with [nonce-sources](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/Sources#sources) for your `<script>` tags.
+
+  You cannot pass through attributes such as `async`, `defer`, `src`, `type`, `noModule` because they are managed by React Router internally.
+
+  @category Types
+ */
+type ScriptsProps = Omit<React.HTMLProps<HTMLScriptElement>, "children" | "async" | "defer" | "src" | "type" | "noModule" | "dangerouslySetInnerHTML" | "suppressHydrationWarning">;
+/**
+  Renders the client runtime of your app. It should be rendered inside the `<body>` of the document.
+
+  ```tsx
+  import { Scripts } from "react-router";
+
+  export default function Root() {
+    return (
+      <html>
+        <head />
+        <body>
+          <Scripts />
+        </body>
+      </html>
+    );
+  }
+  ```
+
+  If server rendering, you can omit `<Scripts/>` and the app will work as a traditional web app without JavaScript, relying solely on HTML and browser behaviors.
+
+  @category Components
+ */
+declare function Scripts(props: ScriptsProps): React.JSX.Element | null;
+
+declare global {
+    const REACT_ROUTER_VERSION: string;
+}
 interface DOMRouterOpts {
     basename?: string;
-    future?: Partial<FutureConfig>;
+    future?: Partial<FutureConfig$1>;
     hydrationData?: HydrationState;
     dataStrategy?: DataStrategyFunction;
     patchRoutesOnNavigation?: PatchRoutesOnNavigationFunction;
@@ -17,15 +661,15 @@ interface DOMRouterOpts {
 /**
  * @category Routers
  */
-export declare function createBrowserRouter(routes: RouteObject[], opts?: DOMRouterOpts): DataRouter;
+declare function createBrowserRouter(routes: RouteObject[], opts?: DOMRouterOpts): Router$1;
 /**
  * @category Routers
  */
-export declare function createHashRouter(routes: RouteObject[], opts?: DOMRouterOpts): DataRouter;
+declare function createHashRouter(routes: RouteObject[], opts?: DOMRouterOpts): Router$1;
 /**
  * @category Types
  */
-export interface BrowserRouterProps {
+interface BrowserRouterProps {
     basename?: string;
     children?: React.ReactNode;
     window?: Window;
@@ -35,11 +679,11 @@ export interface BrowserRouterProps {
  *
  * @category Router Components
  */
-export declare function BrowserRouter({ basename, children, window, }: BrowserRouterProps): React.JSX.Element;
+declare function BrowserRouter({ basename, children, window, }: BrowserRouterProps): React.JSX.Element;
 /**
  * @category Types
  */
-export interface HashRouterProps {
+interface HashRouterProps {
     basename?: string;
     children?: React.ReactNode;
     window?: Window;
@@ -50,11 +694,11 @@ export interface HashRouterProps {
  *
  * @category Router Components
  */
-export declare function HashRouter({ basename, children, window }: HashRouterProps): React.JSX.Element;
+declare function HashRouter({ basename, children, window }: HashRouterProps): React.JSX.Element;
 /**
  * @category Types
  */
-export interface HistoryRouterProps {
+interface HistoryRouterProps {
     basename?: string;
     children?: React.ReactNode;
     history: History;
@@ -68,14 +712,14 @@ export interface HistoryRouterProps {
  * @name unstable_HistoryRouter
  * @category Router Components
  */
-export declare function HistoryRouter({ basename, children, history, }: HistoryRouterProps): React.JSX.Element;
-export declare namespace HistoryRouter {
+declare function HistoryRouter({ basename, children, history, }: HistoryRouterProps): React.JSX.Element;
+declare namespace HistoryRouter {
     var displayName: string;
 }
 /**
  * @category Types
  */
-export interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
     /**
       Defines the link discovery behavior
   
@@ -233,7 +877,7 @@ export interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorEle
 
   @category Components
  */
-export declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
 /**
   The object passed to {@link NavLink} `children`, `className`, and `style` prop callbacks to render and style the link based on its state.
 
@@ -268,7 +912,7 @@ export declare const Link: React.ForwardRefExoticComponent<LinkProps & React.Ref
   ```
 
  */
-export type NavLinkRenderProps = {
+type NavLinkRenderProps = {
     /**
      * Indicates if the link's URL matches the current location.
      */
@@ -285,7 +929,7 @@ export type NavLinkRenderProps = {
 /**
  * @category Types
  */
-export interface NavLinkProps extends Omit<LinkProps, "className" | "style" | "children"> {
+interface NavLinkProps extends Omit<LinkProps, "className" | "style" | "children"> {
     /**
       Can be regular React children or a function that receives an object with the active and pending states of the link.
   
@@ -360,7 +1004,7 @@ export interface NavLinkProps extends Omit<LinkProps, "className" | "style" | "c
 
   @category Components
  */
-export declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
 /**
  * Form props shared by navigations and fetchers
  */
@@ -402,13 +1046,13 @@ interface SharedFormProps extends React.FormHTMLAttributes<HTMLFormElement> {
  * Form props available to fetchers
  * @category Types
  */
-export interface FetcherFormProps extends SharedFormProps {
+interface FetcherFormProps extends SharedFormProps {
 }
 /**
  * Form props available to navigations
  * @category Types
  */
-export interface FormProps extends SharedFormProps {
+interface FormProps extends SharedFormProps {
     discover?: DiscoverBehavior;
     /**
      * Indicates a specific fetcherKey to use when using `navigate={false}` so you
@@ -469,8 +1113,8 @@ function NewEvent() {
 
 @category Components
 */
-export declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
-export type ScrollRestorationProps = ScriptsProps & {
+declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
+type ScrollRestorationProps = ScriptsProps & {
     /**
       Defines the key used to restore scroll positions.
   
@@ -512,8 +1156,8 @@ export type ScrollRestorationProps = ScriptsProps & {
 
   @category Components
  */
-export declare function ScrollRestoration({ getKey, storageKey, ...props }: ScrollRestorationProps): React.JSX.Element | null;
-export declare namespace ScrollRestoration {
+declare function ScrollRestoration({ getKey, storageKey, ...props }: ScrollRestorationProps): React.JSX.Element | null;
+declare namespace ScrollRestoration {
     var displayName: string;
 }
 /**
@@ -523,7 +1167,7 @@ export declare namespace ScrollRestoration {
  *
  * @category Hooks
  */
-export declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to: To, { target, replace: replaceProp, state, preventScrollReset, relative, viewTransition, }?: {
+declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to: To, { target, replace: replaceProp, state, preventScrollReset, relative, viewTransition, }?: {
     target?: React.HTMLAttributeAnchorTarget;
     replace?: boolean;
     state?: any;
@@ -545,7 +1189,7 @@ export declare function useLinkClickHandler<E extends Element = HTMLAnchorElemen
 
  @category Hooks
  */
-export declare function useSearchParams(defaultInit?: URLSearchParamsInit): [URLSearchParams, SetURLSearchParams];
+declare function useSearchParams(defaultInit?: URLSearchParamsInit): [URLSearchParams, SetURLSearchParams];
 /**
   Sets new search params and causes a navigation when called.
 
@@ -574,11 +1218,11 @@ export declare function useSearchParams(defaultInit?: URLSearchParamsInit): [URL
   />
   ```
  */
-export type SetURLSearchParams = (nextInit?: URLSearchParamsInit | ((prev: URLSearchParams) => URLSearchParamsInit), navigateOpts?: NavigateOptions) => void;
+type SetURLSearchParams = (nextInit?: URLSearchParamsInit | ((prev: URLSearchParams) => URLSearchParamsInit), navigateOpts?: NavigateOptions) => void;
 /**
  * Submits a HTML `<form>` to the server without reloading the page.
  */
-export interface SubmitFunction {
+interface SubmitFunction {
     (
     /**
       Can be multiple types of elements and objects
@@ -626,7 +1270,7 @@ export interface SubmitFunction {
 /**
  * Submits a fetcher `<form>` to the server without reloading the page.
  */
-export interface FetcherSubmitFunction {
+interface FetcherSubmitFunction {
     (
     /**
       Can be multiple types of elements and objects
@@ -687,7 +1331,7 @@ export interface FetcherSubmitFunction {
 
   @category Hooks
  */
-export declare function useSubmit(): SubmitFunction;
+declare function useSubmit(): SubmitFunction;
 /**
   Resolves the URL to the closest route in the component hierarchy instead of the current URL of the app.
 
@@ -707,7 +1351,7 @@ export declare function useSubmit(): SubmitFunction;
 
   @category Hooks
  */
-export declare function useFormAction(
+declare function useFormAction(
 /**
  * The action to append to the closest route URL.
  */
@@ -721,7 +1365,7 @@ The return value of `useFetcher` that keeps track of the state of a fetcher.
 let fetcher = useFetcher();
 ```
  */
-export type FetcherWithComponents<TData> = Fetcher<TData> & {
+type FetcherWithComponents<TData> = Fetcher<TData> & {
     /**
       Just like {@link Form} except it doesn't cause a navigation.
   
@@ -834,7 +1478,7 @@ export type FetcherWithComponents<TData> = Fetcher<TData> & {
 
   @category Hooks
  */
-export declare function useFetcher<TData = any>({ key, }?: {
+declare function useFetcher<T = any>({ key, }?: {
     /**
       By default, `useFetcher` generate a unique fetcher scoped to that component. If you want to identify a fetcher with your own key such that you can access it from elsewhere in your app, you can do that with the `key` option:
   
@@ -853,7 +1497,7 @@ export declare function useFetcher<TData = any>({ key, }?: {
       ```
      */
     key?: string;
-}): FetcherWithComponents<TData>;
+}): FetcherWithComponents<SerializeFrom<T>>;
 /**
   Returns an array of all in-flight fetchers. This is useful for components throughout the app that didn't create the fetchers but want to use their submissions to participate in optimistic UI.
 
@@ -870,13 +1514,13 @@ export declare function useFetcher<TData = any>({ key, }?: {
 
   @category Hooks
  */
-export declare function useFetchers(): (Fetcher & {
+declare function useFetchers(): (Fetcher & {
     key: string;
 })[];
 /**
  * When rendered inside a RouterProvider, will restore scroll positions on navigations
  */
-export declare function useScrollRestoration({ getKey, storageKey, }?: {
+declare function useScrollRestoration({ getKey, storageKey, }?: {
     getKey?: GetScrollRestorationKeyFunction;
     storageKey?: string;
 }): void;
@@ -885,7 +1529,7 @@ export declare function useScrollRestoration({ getKey, storageKey, }?: {
  *
  * @category Hooks
  */
-export declare function useBeforeUnload(callback: (event: BeforeUnloadEvent) => any, options?: {
+declare function useBeforeUnload(callback: (event: BeforeUnloadEvent) => any, options?: {
     capture?: boolean;
 }): void;
 /**
@@ -924,7 +1568,7 @@ export declare function useBeforeUnload(callback: (event: BeforeUnloadEvent) =>
   @category Hooks
   @name unstable_usePrompt
  */
-export declare function usePrompt({ when, message, }: {
+declare function usePrompt({ when, message, }: {
     when: boolean | BlockerFunction;
     message: string;
 }): void;
@@ -934,7 +1578,18 @@ export declare function usePrompt({ when, message, }: {
   @category Hooks
   @name useViewTransitionState
  */
-export declare function useViewTransitionState(to: To, opts?: {
+declare function useViewTransitionState(to: To, opts?: {
     relative?: RelativeRoutingType;
 }): boolean;
-export {};
+
+declare global {
+    interface Navigator {
+        connection?: {
+            saveData: boolean;
+        };
+    }
+}
+declare function getPatchRoutesOnNavigationFunction(manifest: AssetsManifest, routeModules: RouteModules, isSpaMode: boolean, basename: string | undefined): PatchRoutesOnNavigationFunction | undefined;
+declare function useFogOFWarDiscovery(router: Router$1, manifest: AssetsManifest, routeModules: RouteModules, isSpaMode: boolean): void;
+
+export { useFetchers as $, type AssetsManifest as A, type BrowserRouterProps as B, createBrowserRouter as C, createHashRouter as D, type EntryContext as E, type FutureConfig as F, BrowserRouter as G, type HashRouterProps as H, type IndexRouteProps as I, HashRouter as J, Link as K, type LayoutRouteProps as L, type MemoryRouterProps as M, type NavigateProps as N, type OutletProps as O, type PathRouteProps as P, HistoryRouter as Q, type RouterProviderProps as R, type ScrollRestorationProps as S, NavLink as T, Form as U, ScrollRestoration as V, useLinkClickHandler as W, useSearchParams as X, useSubmit as Y, useFormAction as Z, useFetcher as _, type Route as a, useBeforeUnload as a0, usePrompt as a1, useViewTransitionState as a2, type FetcherSubmitOptions as a3, type ParamKeyValuePair as a4, type SubmitOptions as a5, type URLSearchParamsInit as a6, type SubmitTarget as a7, createSearchParams as a8, Meta as a9, Links as aa, Scripts as ab, PrefetchPageLinks as ac, type ScriptsProps as ad, mapRouteProperties as ae, FrameworkContext as af, getPatchRoutesOnNavigationFunction as ag, useFogOFWarDiscovery as ah, createClientRoutes as ai, createClientRoutesWithHMRRevalidationOptOut as aj, shouldHydrateRouteLoader as ak, useScrollRestoration as al, type AwaitProps as b, type RouteProps as c, type RouterProps as d, type RoutesProps as e, Await as f, MemoryRouter as g, Navigate as h, Outlet as i, Route$1 as j, Router as k, RouterProvider as l, Routes as m, createMemoryRouter as n, createRoutesFromChildren as o, type HistoryRouterProps as p, type LinkProps as q, renderMatches as r, type NavLinkProps as s, type NavLinkRenderProps as t, type FetcherFormProps as u, type FormProps as v, type SetURLSearchParams as w, type SubmitFunction as x, type FetcherSubmitFunction as y, type FetcherWithComponents as z };