react-router 7.6.1 → 7.6.2

package/dist/{production/lib-B8x_tOvL.d.mts → development/lib-C1JSsICm.d.mts}

@@ -1,5 +1,505 @@
+import { aR as RouteManifest, aS as ServerRouteModule, h as MiddlewareEnabled, a9 as unstable_RouterContextProvider, i as AppLoadContext, Y as LoaderFunctionArgs, y as ActionFunctionArgs, S as StaticHandlerContext, b as RouteModules, H as HydrationState, k as DataRouteObject, l as ClientLoaderFunction, T as To, r as RelativeRoutingType, L as Location, aa as Action, _ as ParamParseKey, m as Path, a2 as PathPattern, a0 as PathMatch, aq as NavigateOptions, $ as Params, c as RouteObject, p as Navigation, a as Router$1, a7 as UIMatch, aT as SerializeFrom, s as BlockerFunction, B as Blocker, R as RouterInit, F as FutureConfig$1, I as InitialEntry, D as DataStrategyFunction, P as PatchRoutesOnNavigationFunction, N as NonIndexRouteObject, X as LazyRouteFunction, e as IndexRouteObject, ar as Navigator, at as RouteMatch, W as HTMLFormMethod, U as FormEncType, aB as PageLinkDescriptor, aU as History, n as GetScrollRestorationKeyFunction, o as Fetcher } from './route-data-ByAYLHuM.mjs';
 import * as React from 'react';
-import { h as RouteObject, R as RouterInit, F as FutureConfig$1, H as HydrationState, I as InitialEntry, D as DataStrategyFunction, v as PatchRoutesOnNavigationFunction, a as Router$1, T as To, c as RelativeRoutingType, n as NonIndexRouteObject, a3 as LazyRouteFunction, m as IndexRouteObject, L as Location, A as Action, as as Navigator, au as RouteMatch, aS as RouteManifest, aT as ServerRouteModule, r as MiddlewareEnabled, ac as unstable_RouterContextProvider, s as AppLoadContext, a4 as LoaderFunctionArgs, W as ActionFunctionArgs, k as StaticHandlerContext, b as RouteModules, w as DataRouteObject, x as ClientLoaderFunction, a2 as HTMLFormMethod, a0 as FormEncType, aC as PageLinkDescriptor, aU as History, y as GetScrollRestorationKeyFunction, N as NavigateOptions, z as Fetcher, S as SerializeFrom, B as BlockerFunction } from './route-data-WyrduLgj.mjs';
+
+type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
+interface ServerRoute extends Route$1 {
+    children: ServerRoute[];
+    module: ServerRouteModule;
+}
+
+type OptionalCriticalCss = CriticalCss | undefined;
+/**
+ * The output of the compiler for the server build.
+ */
+interface ServerBuild {
+    entry: {
+        module: ServerEntryModule;
+    };
+    routes: ServerRouteManifest;
+    assets: AssetsManifest;
+    basename?: string;
+    publicPath: string;
+    assetsBuildDirectory: string;
+    future: FutureConfig;
+    ssr: boolean;
+    unstable_getCriticalCss?: (args: {
+        pathname: string;
+    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
+    /**
+     * @deprecated This is now done via a custom header during prerendering
+     */
+    isSpaMode: boolean;
+    prerender: string[];
+    routeDiscovery: {
+        mode: "lazy" | "initial";
+        manifestPath: string;
+    };
+}
+interface HandleDocumentRequestFunction {
+    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext): Promise<Response> | Response;
+}
+interface HandleDataRequestFunction {
+    (response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
+}
+interface HandleErrorFunction {
+    (error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
+}
+/**
+ * A module that serves as the entry point for a Remix app during server
+ * rendering.
+ */
+interface ServerEntryModule {
+    default: HandleDocumentRequestFunction;
+    handleDataRequest?: HandleDataRequestFunction;
+    handleError?: HandleErrorFunction;
+    streamTimeout?: number;
+}
+
+type SerializedError = {
+    message: string;
+    stack?: string;
+};
+interface FrameworkContextObject {
+    manifest: AssetsManifest;
+    routeModules: RouteModules;
+    criticalCss?: CriticalCss;
+    serverHandoffString?: string;
+    future: FutureConfig;
+    ssr: boolean;
+    isSpaMode: boolean;
+    routeDiscovery: ServerBuild["routeDiscovery"];
+    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 {
+    unstable_subResourceIntegrity: boolean;
+    unstable_middleware: boolean;
+}
+type CriticalCss = string | {
+    rel: "stylesheet";
+    href: string;
+};
+interface AssetsManifest {
+    entry: {
+        imports: string[];
+        module: string;
+    };
+    routes: RouteManifest<EntryRoute>;
+    url: string;
+    version: string;
+    hmr?: {
+        timestamp?: number;
+        runtime: string;
+    };
+    sri?: Record<string, string> | true;
+}
+
+interface Route$1 {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
+}
+interface EntryRoute extends Route$1 {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasClientMiddleware: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    clientActionModule: string | undefined;
+    clientLoaderModule: string | undefined;
+    clientMiddlewareModule: string | undefined;
+    hydrateFallbackModule: string | undefined;
+    parentId?: string;
+}
+declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
+declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
+declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
+
+/**
+  Resolves a URL against the current location.
+
+  ```tsx
+  import { useHref } from "react-router"
+
+  function SomeComponent() {
+    let href = useHref("some/where");
+    // "/resolved/some/where"
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useHref(to: To, { relative }?: {
+    relative?: RelativeRoutingType;
+}): string;
+/**
+ * Returns true if this component is a descendant of a Router, useful to ensure
+ * a component is used within a Router.
+ *
+ * @category Hooks
+ */
+declare function useInRouterContext(): boolean;
+/**
+  Returns the current {@link Location}. This can be useful if you'd like to perform some side effect whenever it changes.
+
+  ```tsx
+  import * as React from 'react'
+  import { useLocation } from 'react-router'
+
+  function SomeComponent() {
+    let location = useLocation()
+
+    React.useEffect(() => {
+      // Google Analytics
+      ga('send', 'pageview')
+    }, [location]);
+
+    return (
+      // ...
+    );
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useLocation(): Location;
+/**
+ * Returns the current navigation action which describes how the router came to
+ * the current location, either by a pop, push, or replace on the history stack.
+ *
+ * @category Hooks
+ */
+declare function useNavigationType(): Action;
+/**
+ * Returns a PathMatch object if the given pattern matches the current URL.
+ * This is useful for components that need to know "active" state, e.g.
+ * `<NavLink>`.
+ *
+ * @category Hooks
+ */
+declare function useMatch<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null;
+/**
+ * The interface for the navigate() function returned from useNavigate().
+ */
+interface NavigateFunction {
+    (to: To, options?: NavigateOptions): void | Promise<void>;
+    (delta: number): void | Promise<void>;
+}
+/**
+  Returns a function that lets you navigate programmatically in the browser in response to user interactions or effects.
+
+  ```tsx
+  import { useNavigate } from "react-router";
+
+  function SomeComponent() {
+    let navigate = useNavigate();
+    return (
+      <button
+        onClick={() => {
+          navigate(-1);
+        }}
+      />
+    );
+  }
+  ```
+
+  It's often better to use {@link redirect} in {@link ActionFunction | actions} and {@link LoaderFunction | loaders} than this hook.
+
+  @category Hooks
+ */
+declare function useNavigate(): NavigateFunction;
+/**
+ * Returns the parent route {@link OutletProps.context | `<Outlet context>`}.
+ *
+ * @category Hooks
+ */
+declare function useOutletContext<Context = unknown>(): Context;
+/**
+ * Returns the element for the child route at this level of the route
+ * hierarchy. Used internally by `<Outlet>` to render child routes.
+ *
+ * @category Hooks
+ */
+declare function useOutlet(context?: unknown): React.ReactElement | null;
+/**
+  Returns an object of key/value pairs of the dynamic params from the current URL that were matched by the routes. Child routes inherit all params from their parent routes.
+
+  ```tsx
+  import { useParams } from "react-router"
+
+  function SomeComponent() {
+    let params = useParams()
+    params.postId
+  }
+  ```
+
+  Assuming a route pattern like `/posts/:postId` is matched by `/posts/123` then `params.postId` will be `"123"`.
+
+  @category Hooks
+ */
+declare function useParams<ParamsOrKey extends string | Record<string, string | undefined> = string>(): Readonly<[
+    ParamsOrKey
+] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>>;
+/**
+  Resolves the pathname of the given `to` value against the current location. Similar to {@link useHref}, but returns a {@link Path} instead of a string.
+
+  ```tsx
+  import { useResolvedPath } from "react-router"
+
+  function SomeComponent() {
+    // if the user is at /dashboard/profile
+    let path = useResolvedPath("../accounts")
+    path.pathname // "/dashboard/accounts"
+    path.search // ""
+    path.hash // ""
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useResolvedPath(to: To, { relative }?: {
+    relative?: RelativeRoutingType;
+}): Path;
+/**
+  Hook version of {@link Routes | `<Routes>`} that uses objects instead of components. These objects have the same properties as the component props.
+
+  The return value of `useRoutes` is either a valid React element you can use to render the route tree, or `null` if nothing matched.
+
+  ```tsx
+  import * as React from "react";
+  import { useRoutes } from "react-router";
+
+  function App() {
+    let element = useRoutes([
+      {
+        path: "/",
+        element: <Dashboard />,
+        children: [
+          {
+            path: "messages",
+            element: <DashboardMessages />,
+          },
+          { path: "tasks", element: <DashboardTasks /> },
+        ],
+      },
+      { path: "team", element: <AboutPage /> },
+    ]);
+
+    return element;
+  }
+  ```
+
+ @category Hooks
+ */
+declare function useRoutes(routes: RouteObject[], locationArg?: Partial<Location> | string): React.ReactElement | null;
+/**
+  Returns the current navigation, defaulting to an "idle" navigation when no navigation is in progress. You can use this to render pending UI (like a global spinner) or read FormData from a form navigation.
+
+  ```tsx
+  import { useNavigation } from "react-router"
+
+  function SomeComponent() {
+    let navigation = useNavigation();
+    navigation.state
+    navigation.formData
+    // etc.
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useNavigation(): Navigation;
+/**
+  Revalidate the data on the page for reasons outside of normal data mutations like window focus or polling on an interval.
+
+  ```tsx
+  import { useRevalidator } from "react-router";
+
+  function WindowFocusRevalidator() {
+    const revalidator = useRevalidator();
+
+    useFakeWindowFocus(() => {
+      revalidator.revalidate();
+    });
+
+    return (
+      <div hidden={revalidator.state === "idle"}>
+        Revalidating...
+      </div>
+    );
+  }
+  ```
+
+  Note that page data is already revalidated automatically after actions. If you find yourself using this for normal CRUD operations on your data in response to user interactions, you're probably not taking advantage of the other APIs like {@link useFetcher}, {@link Form}, {@link useSubmit} that do this automatically.
+
+  @category Hooks
+ */
+declare function useRevalidator(): {
+    revalidate: () => Promise<void>;
+    state: Router$1["state"]["revalidation"];
+};
+/**
+ * Returns the active route matches, useful for accessing loaderData for
+ * parent/child routes or the route "handle" property
+ *
+ * @category Hooks
+ */
+declare function useMatches(): UIMatch[];
+/**
+  Returns the data from the closest route {@link LoaderFunction | loader} or {@link ClientLoaderFunction | client loader}.
+
+  ```tsx
+  import { useLoaderData } from "react-router"
+
+  export async function loader() {
+    return await fakeDb.invoices.findAll();
+  }
+
+  export default function Invoices() {
+    let invoices = useLoaderData<typeof loader>();
+    // ...
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useLoaderData<T = any>(): SerializeFrom<T>;
+/**
+  Returns the loader data for a given route by route ID.
+
+  ```tsx
+  import { useRouteLoaderData } from "react-router";
+
+  function SomeComponent() {
+    const { user } = useRouteLoaderData("root");
+  }
+  ```
+
+  Route IDs are created automatically. They are simply the path of the route file relative to the app folder without the extension.
+
+  | Route Filename             | Route ID             |
+  | -------------------------- | -------------------- |
+  | `app/root.tsx`             | `"root"`             |
+  | `app/routes/teams.tsx`     | `"routes/teams"`     |
+  | `app/whatever/teams.$id.tsx` | `"whatever/teams.$id"` |
+
+  If you created an ID manually, you can use that instead:
+
+  ```tsx
+  route("/", "containers/app.tsx", { id: "app" }})
+  ```
+
+  @category Hooks
+ */
+declare function useRouteLoaderData<T = any>(routeId: string): SerializeFrom<T> | undefined;
+/**
+  Returns the action data from the most recent POST navigation form submission or `undefined` if there hasn't been one.
+
+  ```tsx
+  import { Form, useActionData } from "react-router"
+
+  export async function action({ request }) {
+    const body = await request.formData()
+    const name = body.get("visitorsName")
+    return { message: `Hello, ${name}` }
+  }
+
+  export default function Invoices() {
+    const data = useActionData()
+    return (
+      <Form method="post">
+        <input type="text" name="visitorsName" />
+        {data ? data.message : "Waiting..."}
+      </Form>
+    )
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useActionData<T = any>(): SerializeFrom<T> | undefined;
+/**
+  Accesses the error thrown during an {@link ActionFunction | action}, {@link LoaderFunction | loader}, or component render to be used in a route module Error Boundary.
+
+  ```tsx
+  export function ErrorBoundary() {
+    const error = useRouteError();
+    return <div>{error.message}</div>;
+  }
+  ```
+
+  @category Hooks
+ */
+declare function useRouteError(): unknown;
+/**
+  Returns the resolved promise value from the closest {@link Await | `<Await>`}.
+
+  ```tsx
+  function SomeDescendant() {
+    const value = useAsyncValue();
+    // ...
+  }
+
+  // somewhere in your app
+  <Await resolve={somePromise}>
+    <SomeDescendant />
+  </Await>
+  ```
+
+  @category Hooks
+ */
+declare function useAsyncValue(): unknown;
+/**
+  Returns the rejection value from the closest {@link Await | `<Await>`}.
+
+  ```tsx
+  import { Await, useAsyncError } from "react-router"
+
+  function ErrorElement() {
+    const error = useAsyncError();
+    return (
+      <p>Uh Oh, something went wrong! {error.message}</p>
+    );
+  }
+
+  // somewhere in your app
+  <Await
+    resolve={promiseThatRejects}
+    errorElement={<ErrorElement />}
+  />
+  ```
+
+  @category Hooks
+ */
+declare function useAsyncError(): unknown;
+/**
+ * Allow the application to block navigations within the SPA and present the
+ * user a confirmation dialog to confirm the navigation.  Mostly used to avoid
+ * using half-filled form data.  This does not handle hard-reloads or
+ * cross-origin navigations.
+ *
+ * @category Hooks
+ */
+declare function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker;
 
 /**
  * @private
@@ -193,7 +693,7 @@ type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;
  *
  * @category Components
  */
-declare function Route$1(_props: RouteProps): React.ReactElement | null;
+declare function Route(_props: RouteProps): React.ReactElement | null;
 /**
  * @category Types
  */
@@ -411,139 +911,40 @@ declare let createRoutesFromElements: typeof createRoutesFromChildren;
  * @category Utils
  */
 declare function renderMatches(matches: RouteMatch[] | null): React.ReactElement | null;
-
-type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
-interface ServerRoute extends Route {
-    children: ServerRoute[];
-    module: ServerRouteModule;
-}
-
-type OptionalCriticalCss = CriticalCss | undefined;
-/**
- * The output of the compiler for the server build.
- */
-interface ServerBuild {
-    entry: {
-        module: ServerEntryModule;
-    };
-    routes: ServerRouteManifest;
-    assets: AssetsManifest;
-    basename?: string;
-    publicPath: string;
-    assetsBuildDirectory: string;
-    future: FutureConfig;
-    ssr: boolean;
-    unstable_getCriticalCss?: (args: {
-        pathname: string;
-    }) => OptionalCriticalCss | Promise<OptionalCriticalCss>;
-    /**
-     * @deprecated This is now done via a custom header during prerendering
-     */
-    isSpaMode: boolean;
-    prerender: string[];
-    routeDiscovery: {
-        mode: "lazy" | "initial";
-        manifestPath: string;
-    };
-}
-interface HandleDocumentRequestFunction {
-    (request: Request, responseStatusCode: number, responseHeaders: Headers, context: EntryContext, loadContext: MiddlewareEnabled extends true ? unstable_RouterContextProvider : AppLoadContext): Promise<Response> | Response;
-}
-interface HandleDataRequestFunction {
-    (response: Response, args: LoaderFunctionArgs | ActionFunctionArgs): Promise<Response> | Response;
-}
-interface HandleErrorFunction {
-    (error: unknown, args: LoaderFunctionArgs | ActionFunctionArgs): void;
-}
-/**
- * A module that serves as the entry point for a Remix app during server
- * rendering.
- */
-interface ServerEntryModule {
-    default: HandleDocumentRequestFunction;
-    handleDataRequest?: HandleDataRequestFunction;
-    handleError?: HandleErrorFunction;
-    streamTimeout?: number;
-}
-
-type SerializedError = {
-    message: string;
-    stack?: string;
-};
-interface FrameworkContextObject {
-    manifest: AssetsManifest;
-    routeModules: RouteModules;
-    criticalCss?: CriticalCss;
-    serverHandoffString?: string;
-    future: FutureConfig;
-    ssr: boolean;
-    isSpaMode: boolean;
-    routeDiscovery: ServerBuild["routeDiscovery"];
-    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 {
-    unstable_subResourceIntegrity: boolean;
-    unstable_middleware: boolean;
-}
-type CriticalCss = string | {
-    rel: "stylesheet";
-    href: string;
-};
-interface AssetsManifest {
-    entry: {
-        imports: string[];
-        module: string;
-    };
-    routes: RouteManifest<EntryRoute>;
-    url: string;
-    version: string;
-    hmr?: {
-        timestamp?: number;
-        runtime: string;
-    };
-    sri?: Record<string, string> | true;
-}
-
-interface Route {
-    index?: boolean;
-    caseSensitive?: boolean;
-    id: string;
-    parentId?: string;
-    path?: string;
-}
-interface EntryRoute extends Route {
-    hasAction: boolean;
-    hasLoader: boolean;
-    hasClientAction: boolean;
-    hasClientLoader: boolean;
-    hasClientMiddleware: boolean;
-    hasErrorBoundary: boolean;
-    imports?: string[];
-    css?: string[];
-    module: string;
-    clientActionModule: string | undefined;
-    clientLoaderModule: string | undefined;
-    clientMiddlewareModule: string | undefined;
-    hydrateFallbackModule: string | undefined;
-    parentId?: string;
-}
-declare function createClientRoutesWithHMRRevalidationOptOut(needsRevalidation: Set<string>, manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState, ssr: boolean, isSpaMode: boolean): DataRouteObject[];
-declare function createClientRoutes(manifest: RouteManifest<EntryRoute>, routeModulesCache: RouteModules, initialState: HydrationState | null, ssr: boolean, isSpaMode: boolean, parentId?: string, routesByParentId?: Record<string, Omit<EntryRoute, "children">[]>, needsRevalidation?: Set<string>): DataRouteObject[];
-declare function shouldHydrateRouteLoader(routeId: string, clientLoader: ClientLoaderFunction | undefined, hasLoader: boolean, isSpaMode: boolean): boolean;
+type RouteComponentType = React.ComponentType<{
+    params: ReturnType<typeof useParams>;
+    loaderData: ReturnType<typeof useLoaderData>;
+    actionData: ReturnType<typeof useActionData>;
+    matches: ReturnType<typeof useMatches>;
+}>;
+declare function withComponentProps(Component: RouteComponentType): () => React.ReactElement<{
+    params: Readonly<Partial<string | Record<string, string | undefined>>>;
+    loaderData: unknown;
+    actionData: unknown;
+    matches: UIMatch<unknown, unknown>[];
+}, string | React.JSXElementConstructor<any>>;
+type HydrateFallbackType = React.ComponentType<{
+    params: ReturnType<typeof useParams>;
+    loaderData: ReturnType<typeof useLoaderData>;
+    actionData: ReturnType<typeof useActionData>;
+}>;
+declare function withHydrateFallbackProps(HydrateFallback: HydrateFallbackType): () => React.ReactElement<{
+    params: Readonly<Partial<string | Record<string, string | undefined>>>;
+    loaderData: unknown;
+    actionData: unknown;
+}, string | React.JSXElementConstructor<any>>;
+type ErrorBoundaryType = React.ComponentType<{
+    params: ReturnType<typeof useParams>;
+    loaderData: ReturnType<typeof useLoaderData>;
+    actionData: ReturnType<typeof useActionData>;
+    error: ReturnType<typeof useRouteError>;
+}>;
+declare function withErrorBoundaryProps(ErrorBoundary: ErrorBoundaryType): () => React.ReactElement<{
+    params: Readonly<Partial<string | Record<string, string | undefined>>>;
+    loaderData: unknown;
+    actionData: unknown;
+    error: unknown;
+}, string | React.JSXElementConstructor<any>>;
 
 type ParamKeyValuePair = [string, string];
 type URLSearchParamsInit = string | ParamKeyValuePair[] | Record<string, string | string[]> | URLSearchParams;
@@ -1733,4 +2134,4 @@ declare function useViewTransitionState(to: To, opts?: {
     relative?: RelativeRoutingType;
 }): boolean;
 
-export { useSubmit as $, type AssetsManifest as A, type BrowserRouterProps as B, type FetcherSubmitFunction as C, type DOMRouterOpts as D, type EntryContext as E, type FutureConfig as F, type FetcherWithComponents as G, type HashRouterProps as H, type IndexRouteProps as I, createBrowserRouter as J, createHashRouter as K, type LayoutRouteProps as L, type MemoryRouterOpts as M, type NavigateProps as N, type OutletProps as O, type PathRouteProps as P, BrowserRouter as Q, type RouterProviderProps as R, type ServerBuild as S, HashRouter as T, Link as U, HistoryRouter as V, NavLink as W, Form as X, ScrollRestoration as Y, useLinkClickHandler as Z, useSearchParams as _, type AwaitProps as a, useFormAction as a0, useFetcher as a1, useFetchers as a2, useBeforeUnload as a3, usePrompt as a4, useViewTransitionState as a5, type FetcherSubmitOptions as a6, type ParamKeyValuePair as a7, type SubmitOptions as a8, type URLSearchParamsInit as a9, type SubmitTarget as aa, createSearchParams as ab, Meta as ac, Links as ad, Scripts as ae, PrefetchPageLinks as af, type ScriptsProps as ag, type HandleDataRequestFunction as ah, type HandleDocumentRequestFunction as ai, type HandleErrorFunction as aj, type ServerEntryModule as ak, hydrationRouteProperties as al, mapRouteProperties as am, FrameworkContext as an, createClientRoutes as ao, createClientRoutesWithHMRRevalidationOptOut as ap, shouldHydrateRouteLoader as aq, useScrollRestoration as ar, type MemoryRouterProps 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, createRoutesFromElements as p, type HistoryRouterProps as q, renderMatches as r, type LinkProps as s, type NavLinkProps as t, type NavLinkRenderProps as u, type FetcherFormProps as v, type FormProps as w, type ScrollRestorationProps as x, type SetURLSearchParams as y, type SubmitFunction as z };
+export { type BrowserRouterProps as $, type AssetsManifest as A, useLoaderData as B, useLocation as C, useMatch as D, type EntryContext as E, type FutureConfig as F, useMatches as G, type HydrateFallbackType as H, type IndexRouteProps as I, useNavigate as J, useNavigation as K, type LayoutRouteProps as L, type MemoryRouterOpts as M, type NavigateProps as N, type OutletProps as O, type PathRouteProps as P, useNavigationType as Q, type RouterProviderProps as R, type ServerBuild as S, useOutlet as T, useOutletContext as U, useParams as V, useResolvedPath as W, useRevalidator as X, useRouteError as Y, useRouteLoaderData as Z, useRoutes as _, type RouteComponentType as a, type DOMRouterOpts as a0, type HashRouterProps as a1, type HistoryRouterProps as a2, type LinkProps as a3, type NavLinkProps as a4, type NavLinkRenderProps as a5, type FetcherFormProps as a6, type FormProps as a7, type ScrollRestorationProps as a8, type SetURLSearchParams as a9, createSearchParams as aA, Meta as aB, Links as aC, Scripts as aD, PrefetchPageLinks as aE, type ScriptsProps as aF, type HandleDataRequestFunction as aG, type HandleDocumentRequestFunction as aH, type HandleErrorFunction as aI, type ServerEntryModule as aJ, hydrationRouteProperties as aK, mapRouteProperties as aL, withComponentProps as aM, withHydrateFallbackProps as aN, withErrorBoundaryProps as aO, FrameworkContext as aP, createClientRoutes as aQ, createClientRoutesWithHMRRevalidationOptOut as aR, shouldHydrateRouteLoader as aS, useScrollRestoration as aT, type SubmitFunction as aa, type FetcherSubmitFunction as ab, type FetcherWithComponents as ac, createBrowserRouter as ad, createHashRouter as ae, BrowserRouter as af, HashRouter as ag, Link as ah, HistoryRouter as ai, NavLink as aj, Form as ak, ScrollRestoration as al, useLinkClickHandler as am, useSearchParams as an, useSubmit as ao, useFormAction as ap, useFetcher as aq, useFetchers as ar, useBeforeUnload as as, usePrompt as at, useViewTransitionState as au, type FetcherSubmitOptions as av, type ParamKeyValuePair as aw, type SubmitOptions as ax, type URLSearchParamsInit as ay, type SubmitTarget as az, type ErrorBoundaryType as b, type AwaitProps as c, type MemoryRouterProps as d, type RouteProps as e, type RouterProps as f, type RoutesProps as g, Await as h, MemoryRouter as i, Navigate as j, Outlet as k, Route as l, Router as m, RouterProvider as n, Routes as o, createMemoryRouter as p, createRoutesFromChildren as q, createRoutesFromElements as r, renderMatches as s, type NavigateFunction as t, useBlocker as u, useActionData as v, useAsyncError as w, useAsyncValue as x, useHref as y, useInRouterContext as z };