@farm.js/core 0.1.0-beta.6 → 0.1.0-beta.8

package/dist/client.d.mts

@@ -0,0 +1,447 @@
+import { p as ClientOptions, g as APIResult } from './client-BT1mFQas.mjs';
+export { r as APIClient, h as APIClientError, b as APIClientOptions, i as APIClientSystemError, c as APIClientWithoutIntegrationsOptions, X as InferIntegrationOperationBody, Y as InferIntegrationOperationQuery, Z as InferIntegrationOperationResponse, T as IntegrationAPI, L as IntegrationClient, M as IntegrationClientAliases, V as IntegrationClientData, y as IntegrationClientError, P as IntegrationClientOptions, Q as IntegrationClientRequestOptions, N as IntegrationClientRoot, U as IntegrationClients, W as IntegrationOperationResult, _ as IntegrationServerClient, $ as IntegrationServerClientAliases, a0 as IntegrationServerClientOptions, a1 as IntegrationServerClientRequestOptions, a2 as IntegrationServerClientRoot, a3 as IntegrationServerRequestLike, q as RouteAPIClient, s as ServerAPIClient, S as ServerAPIClientOptions, d as ServerAPIClientWithoutIntegrationsOptions, t as createAPIClient, z as createIntegrationApi, x as createIntegrationClient, B as createIntegrationClients, E as createIntegrationServerClient, D as createIntegrations, w as createServerAPIClient, G as getIntegrationAPIManifest, H as integrationClients, J as integrationsClient, K as integrationsServer } from './client-BT1mFQas.mjs';
+export { F as FarmAPIStream } from './transport-BmbGTXA5.mjs';
+import React__default, { ComponentType, FormHTMLAttributes, FormEvent, AnchorHTMLAttributes, RefObject } from 'react';
+export { ServerQueryFetchOptions, UseServerQueryOptions, UseServerQueryResult, fetchServerQuery, prefetchServerQuery, useServerQuery } from './server-query-client.mjs';
+export { F as FarmIntegrationAPI, e as FarmIntegrationAPIBodyFormat, f as FarmIntegrationAPIMethod, a as FarmIntegrationAPIOperation, g as FarmIntegrationAPIResponseFormat, b as api, d as defineIntegrationAPI, c as defineIntegrationAPIOperation, i as endpoint } from './integration-api-CHT2OKAf.mjs';
+import { FarmRouterPathParams, FarmRouterPathParam, FarmRouterBuildOptions, FarmRouterRouteInput } from './router.mjs';
+import { F as FarmClientPluginManager } from './plugin-BJDf43dc.mjs';
+export { a as FarmClientHydrationCompleteEvent, b as FarmClientHydrationEvent, d as FarmClientHydrationMode, e as FarmClientHydrationSession, f as FarmClientLocation, g as FarmClientNavigationAction, h as FarmClientNavigationErrorEvent, i as FarmClientNavigationEvent, j as FarmClientNavigationLoadedEvent, k as FarmClientNavigationResolvedEvent, l as FarmClientNavigationSession, m as FarmClientPerformanceEvent, n as FarmClientPlugin, o as FarmClientPluginCloseEvent, p as FarmClientPluginEnforce, q as FarmClientPluginErrorEvent, r as FarmClientPluginErrorPhase, s as FarmClientPluginManagerOptions, t as FarmClientPluginMetadata, u as FarmClientPluginRegistration, v as FarmClientPluginRouter, w as FarmClientPluginSetupEvent, x as FarmClientPluginStateEvent, c as createClientPluginManager } from './plugin-BJDf43dc.mjs';
+import { a as FarmI18nClientSnapshot, c as FarmI18nLocale } from './types-BMxWr97v.mjs';
+export { F as FarmChunkRecoveryOptions, i as installChunkErrorRecovery, a as isChunkLoadError } from './production-runtime-C_B79w2P.mjs';
+import './client-cache-D-EZ7XVW.mjs';
+import './cache.mjs';
+import './server-query.mjs';
+import './server-fn.mjs';
+
+type MutationStatus = "idle" | "pending" | "success" | "error";
+type AnyMutationTarget = (...args: any[]) => Promise<any>;
+type InferMutationVariables<TTarget extends AnyMutationTarget> = Parameters<TTarget> extends [] ? undefined : Parameters<TTarget>[0];
+type InferMutationData<TTarget extends AnyMutationTarget> = TTarget extends {
+    readonly __farmRouteData: infer TData;
+} ? TData : Awaited<ReturnType<TTarget>>;
+type InferMutationError<TTarget extends AnyMutationTarget> = TTarget extends (...args: any[]) => Promise<APIResult<any, infer TError>> ? TError : Error;
+type MutationOptimisticContext<TVariables, TData> = {
+    variables: TVariables | undefined;
+    current: TData | null;
+};
+type UseMutationOptions<TVariables, TData, TError = Error> = {
+    initialData?: TData | null;
+    resetOnMutate?: boolean;
+    optimistic?: (context: MutationOptimisticContext<TVariables, TData>) => TData | null | undefined;
+    rollbackOnError?: boolean;
+    /**
+     * Options forwarded to generated `api.route.method` clients.
+     * Server functions ignore this field.
+     */
+    request?: ClientOptions<TData, TError>;
+    onSuccess?: (data: TData, variables: TVariables | undefined) => void;
+    onError?: (error: TError, variables: TVariables | undefined) => void;
+    onSettled?: (data: TData | null, error: TError | null, variables: TVariables | undefined) => void;
+};
+type MutationInput<TTarget extends AnyMutationTarget> = InferMutationVariables<TTarget>;
+type MutationData<TTarget extends AnyMutationTarget> = InferMutationData<TTarget>;
+type MutationError<TTarget extends AnyMutationTarget> = InferMutationError<TTarget>;
+type MutationAsync<TTarget extends AnyMutationTarget, TData = MutationData<TTarget>> = [
+] extends Parameters<TTarget> ? (variables?: MutationInput<TTarget>) => Promise<TData> : (variables: MutationInput<TTarget>) => Promise<TData>;
+type MutationTrigger<TTarget extends AnyMutationTarget> = [
+] extends Parameters<TTarget> ? (variables?: MutationInput<TTarget>) => void : (variables: MutationInput<TTarget>) => void;
+type UseMutationReturn<TTarget extends AnyMutationTarget, TData = MutationData<TTarget>, TError = MutationError<TTarget>> = {
+    pending: boolean;
+    status: MutationStatus;
+    data: TData | null;
+    error: TError | null;
+    variables: MutationInput<TTarget> | undefined;
+    mutate: MutationTrigger<TTarget>;
+    mutateAsync: MutationAsync<TTarget, TData>;
+    reset: () => void;
+};
+/**
+ * Track a generated API route mutation or a Farm server function with one
+ * React lifecycle.
+ *
+ * API routes keep using their existing fetch transport and request options.
+ * Server functions keep using their configured server-function transport.
+ */
+declare function useMutation<TTarget extends AnyMutationTarget>(target: TTarget, options?: UseMutationOptions<MutationInput<TTarget>, MutationData<TTarget>, MutationError<TTarget>>): UseMutationReturn<TTarget>;
+
+type FetcherState = "idle" | "submitting";
+type FetcherFormDataContext = {
+    form: HTMLFormElement | null;
+    submitter: HTMLElement | null;
+};
+type UseFetcherOptions<TTarget extends AnyMutationTarget> = UseMutationOptions<InferMutationVariables<TTarget>, InferMutationData<TTarget>, InferMutationError<TTarget>> & {
+    /**
+     * Convert browser FormData into the target's typed variables.
+     *
+     * Generated API routes default to `{ body: Object.fromEntries(formData) }`
+     * (or `{ query: ... }` for GET/HEAD). Server functions receive FormData
+     * directly so their input schema remains authoritative.
+     */
+    mapFormData?: (formData: FormData, context: FetcherFormDataContext) => InferMutationVariables<TTarget>;
+};
+type FetcherFormProps = Omit<FormHTMLAttributes<HTMLFormElement>, "action" | "onSubmit"> & {
+    /**
+     * Override the native form fallback. By default server functions remain the
+     * action and generated GET/POST API routes use their real URL.
+     */
+    action?: string | ((formData: FormData) => void | Promise<void>);
+    onSubmit?: (event: FormEvent<HTMLFormElement>) => void;
+};
+type FetcherInput<TTarget extends AnyMutationTarget> = InferMutationVariables<TTarget> | FormData;
+type FetcherSubmitAsync<TTarget extends AnyMutationTarget> = [
+] extends Parameters<TTarget> ? (input?: FetcherInput<TTarget>) => Promise<InferMutationData<TTarget>> : (input: FetcherInput<TTarget>) => Promise<InferMutationData<TTarget>>;
+type FetcherSubmit<TTarget extends AnyMutationTarget> = [
+] extends Parameters<TTarget> ? (input?: FetcherInput<TTarget>) => void : (input: FetcherInput<TTarget>) => void;
+type UseFetcherReturn<TTarget extends AnyMutationTarget> = {
+    state: FetcherState;
+    status: MutationStatus;
+    pending: boolean;
+    data: InferMutationData<TTarget> | null;
+    error: InferMutationError<TTarget> | null;
+    variables: InferMutationVariables<TTarget> | undefined;
+    formData: FormData | null;
+    submit: FetcherSubmit<TTarget>;
+    submitAsync: FetcherSubmitAsync<TTarget>;
+    Form: ComponentType<FetcherFormProps>;
+    reset: () => void;
+};
+/**
+ * Run a typed server function or generated API operation without navigating.
+ *
+ * `fetcher.Form` progressively keeps a server function as the native form
+ * action, while hydration intercepts submissions into this fetcher lifecycle.
+ */
+declare function useFetcher<TTarget extends AnyMutationTarget>(target: TTarget, options?: UseFetcherOptions<TTarget>): UseFetcherReturn<TTarget>;
+
+type StoreState = Record<string, any>;
+type StoreValueUpdater<T> = T | ((previous: T) => T);
+type StorePatch<T extends StoreState> = Partial<T> | ((state: T) => Partial<T>);
+type StoreListener<T extends StoreState> = (state: T, previousState: T) => void;
+type StoreKeyListener<T extends StoreState, K extends keyof T> = (value: T[K], previousValue: T[K]) => void;
+type StoreKeysListener<T extends StoreState, K extends keyof T> = (value: Pick<T, K>, previousValue: Pick<T, K>) => void;
+type FieldAccessor<T extends StoreState, K extends keyof T> = {
+    (): T[K];
+    get(): T[K];
+    set(value: StoreValueUpdater<T[K]>): T[K];
+    subscribe(listener: StoreKeyListener<T, K>): () => void;
+};
+type StoreFields<T extends StoreState> = {
+    [K in keyof T]: FieldAccessor<T, K>;
+};
+interface StoreApi<T extends StoreState> {
+    use(): T;
+    use<K extends keyof T>(key: K): T[K];
+    use<K extends keyof T>(keys: readonly K[]): Pick<T, K>;
+    get(): T;
+    get<K extends keyof T>(key: K): T[K];
+    set<K extends keyof T>(key: K, value: StoreValueUpdater<T[K]>): T[K];
+    set(patch: StorePatch<T>): T;
+    replace(nextState: T | ((state: T) => T)): T;
+    reset(): T;
+    subscribe(listener: StoreListener<T>): () => void;
+    subscribe<K extends keyof T>(key: K, listener: StoreKeyListener<T, K>): () => void;
+    subscribe<K extends keyof T>(keys: readonly K[], listener: StoreKeysListener<T, K>): () => void;
+}
+type Store<T extends StoreState, TMethods extends Record<string, any> = {}> = StoreApi<T> & StoreFields<T> & TMethods;
+declare function createStore<T extends StoreState, TMethods extends Record<string, any> = {}>(initialState: T, extend?: (store: Store<T>) => TMethods): Store<T, TMethods>;
+
+/**
+ * Farm.js SPA Router
+ *
+ * Provides client-side navigation without full page reloads.
+ * Features:
+ * - Prefetch on viewport intersection
+ * - Prefetch on hover
+ * - Page caching
+ * - History API integration
+ * - Scroll restoration
+ */
+interface PageData {
+    props: Record<string, any>;
+    modulePath: string;
+    canonicalPath?: string;
+    isClientComponent?: boolean;
+    shouldHydrate?: boolean;
+    metadata?: {
+        title?: string;
+        description?: string;
+    };
+    layoutModules?: string[];
+    routeSlots?: RouteSlotPageData[];
+    interception?: {
+        from?: string;
+        slots: string[];
+    };
+    i18n?: FarmI18nClientSnapshot;
+}
+interface RouteSlotPageData {
+    name: string;
+    ownerPattern: string;
+    containerId: string;
+    interception: boolean;
+    fallback: boolean;
+    modulePath: string;
+    isClientComponent: boolean;
+    shouldHydrate: boolean;
+    props: Record<string, any>;
+}
+interface RouterOptions {
+    prefetchTimeout?: number;
+    cacheMaxAge?: number;
+    scrollRestoration?: boolean;
+    shouldUseDocumentNavigation?: (pathname: string) => boolean;
+    deploymentId?: string;
+}
+interface FarmNavigationBlockerContext {
+    from: string;
+    to: string;
+    action: "push" | "replace" | "pop";
+}
+type FarmNavigationBlocker = (context: FarmNavigationBlockerContext) => boolean | void | Promise<boolean | void>;
+type FarmViewTransitionMode = boolean | "auto";
+interface FarmNavigateOptions {
+    replace?: boolean;
+    scroll?: boolean;
+    state?: unknown;
+    viewTransition?: FarmViewTransitionMode;
+}
+interface FarmNavigationLocation {
+    href: string;
+    pathname: string;
+    search: string;
+    hash: string;
+}
+interface FarmNavigationState {
+    state: "idle" | "loading";
+    pending: boolean;
+    from: string | null;
+    to: FarmNavigationLocation | null;
+    action: FarmNavigationBlockerContext["action"] | null;
+    startedAt: number | null;
+}
+type FarmNavigationListener = (state: FarmNavigationState) => void;
+declare class SPARouter {
+    private cache;
+    private prefetchingUrls;
+    private observers;
+    private blockers;
+    private navigationListeners;
+    private navigationState;
+    private scrollElements;
+    private options;
+    private onNavigate?;
+    private clientPlugins?;
+    constructor(options?: RouterOptions);
+    /**
+     * Set the navigation handler that updates React
+     */
+    setNavigationHandler(handler: (data: PageData) => Promise<void>): void;
+    /**
+     * Connect Farm's browser plugin lifecycle to SPA navigation.
+     */
+    setClientPluginManager(manager: FarmClientPluginManager): void;
+    /**
+     * Navigate to a new URL
+     */
+    navigate(href: string, options?: FarmNavigateOptions): Promise<void>;
+    /**
+     * Prefetch a URL
+     */
+    prefetch(href: string): Promise<void>;
+    /**
+     * Observe an element for viewport intersection (prefetch when visible)
+     */
+    observeForPrefetch(element: HTMLAnchorElement): void;
+    /**
+     * Stop observing an element
+     */
+    unobserveForPrefetch(element: HTMLAnchorElement): void;
+    addBlocker(blocker: FarmNavigationBlocker): () => void;
+    getNavigationState(): FarmNavigationState;
+    subscribeNavigation(listener: FarmNavigationListener): () => void;
+    registerScrollElement(key: string, element: HTMLElement): () => void;
+    pushState(state: unknown, href?: string): void;
+    replaceState(state: unknown, href?: string): void;
+    private commitNavigation;
+    private runViewTransition;
+    /**
+     * Fetch page data from cache or server
+     */
+    private fetchPageData;
+    /**
+     * Handle browser back/forward navigation
+     */
+    private handlePopState;
+    /**
+     * Check if URL is cached
+     */
+    private isCached;
+    /**
+     * Check if URL is external
+     */
+    private isExternalUrl;
+    private shouldBlockNavigation;
+    private startNavigation;
+    private finishNavigation;
+    private setNavigationState;
+    private writePageState;
+    /**
+     * Save scroll position for a path
+     */
+    private saveScrollPosition;
+    /**
+     * Restore scroll position for a path
+     */
+    private restoreScrollPosition;
+    private restoreScrollElement;
+    /**
+     * Clear the page cache
+     */
+    clearCache(): void;
+}
+/**
+ * Get or create the global router instance
+ */
+declare function getRouter(): SPARouter;
+/**
+ * Navigate to a URL using the SPA router
+ */
+declare function navigateTo(href: string, options?: FarmNavigateOptions): Promise<void>;
+/**
+ * Prefetch a URL
+ */
+declare function prefetch(href: string): Promise<void>;
+declare function pushState(state: unknown, href?: string): void;
+declare function replaceState(state: unknown, href?: string): void;
+declare function readPageState<TState = unknown>(): TState | null;
+
+/**
+ * Prefetch strategy (TanStack Router–style):
+ * - "intent": prefetch on hover and touchstart (with prefetchDelay)
+ * - "viewport": prefetch when link enters viewport (IntersectionObserver)
+ * - "render": prefetch as soon as the link is mounted
+ * - "none" | false: no prefetch
+ */
+type PrefetchBehavior = false | "intent" | "viewport" | "render" | "none";
+/** @internal Legacy prefetch mode for backward compatibility */
+type PrefetchLegacy = boolean | "hover" | "viewport" | "none";
+/**
+ * Augment this interface via the generated farm.d.ts so Link href is typed
+ * without passing a generic. Defaults to string when not augmented.
+ */
+interface LinkDefaultRoute {
+}
+type DefaultRoutePath = LinkDefaultRoute extends {
+    _: infer TRoute extends string;
+} ? TRoute : string;
+type DefaultRoutePattern = LinkDefaultRoute extends {
+    pattern: infer TRoute extends string;
+} ? TRoute : DefaultRoutePath;
+type DefaultRouteHref = DefaultRoutePath | DefaultRoutePattern;
+type RouteHref<TRoute extends string> = TRoute | `${TRoute}?${string}` | `${TRoute}#${string}` | `${TRoute}?${string}#${string}`;
+type RouteParamValue = Exclude<FarmRouterPathParam, null | undefined>;
+type RouteOptionalParamValue = FarmRouterPathParam;
+type RouteParams<TRoute extends string> = string extends TRoute ? FarmRouterPathParams : ExtractRouteParams<StripRouteSuffix<TRoute>>;
+/** External URLs; these are never type-checked as routes. */
+type ExternalHref = `http://${string}` | `https://${string}` | `//${string}` | `mailto:${string}`;
+type StripRouteSuffix<TRoute extends string> = TRoute extends `${infer Path}?${string}` ? StripRouteSuffix<Path> : TRoute extends `${infer Path}#${string}` ? StripRouteSuffix<Path> : TRoute;
+type ExtractRouteParams<TRoute extends string> = Simplify<ExtractOptionalCatchAllParams<TRoute> & ExtractCatchAllParams<TRoute> & ExtractDynamicParams<TRoute>>;
+type ExtractOptionalCatchAllParams<TRoute extends string> = TRoute extends `${string}[[...${infer Param}]]${infer Rest}` ? {
+    [Key in Param]?: RouteOptionalParamValue;
+} & ExtractOptionalCatchAllParams<Rest> : {};
+type ExtractCatchAllParams<TRoute extends string> = TRoute extends `${string}[...${infer Param}]${infer Rest}` ? Param extends `[...${string}` ? ExtractCatchAllParams<Rest> : {
+    [Key in Param]: RouteParamValue;
+} & ExtractCatchAllParams<Rest> : {};
+type ExtractDynamicParams<TRoute extends string> = TRoute extends `${string}[${infer Param}]${infer Rest}` ? Param extends `...${string}` | `[...${string}` ? ExtractDynamicParams<Rest> : {
+    [Key in Param]: RouteParamValue;
+} & ExtractDynamicParams<Rest> : {};
+type Simplify<T> = {
+    [Key in keyof T]: T[Key];
+} & {};
+type HasRouteParams<TRoute extends string> = keyof RouteParams<TRoute> extends never ? false : true;
+type RoutesWithRequiredParams<TRoute extends string> = TRoute extends string ? HasRouteParams<TRoute> extends true ? TRoute : never : never;
+type LinkRouteParamsProps<TRoute extends string> = string extends TRoute ? {
+    params?: FarmRouterPathParams;
+} : HasRouteParams<TRoute> extends true ? {
+    params: RouteParams<TRoute>;
+} : {
+    params?: FarmRouterPathParams;
+};
+type LinkRouteTargetProps<TRoute extends string> = [RoutesWithRequiredParams<TRoute>] extends [
+    never
+] ? {
+    /** Internal route path with all params already resolved. */
+    href: RouteHref<TRoute>;
+    params?: FarmRouterPathParams;
+} : TRoute extends string ? {
+    /** Internal route path or route pattern. */
+    href: RouteHref<TRoute>;
+} & LinkRouteParamsProps<TRoute> : never;
+type LinkExternalTargetProps = {
+    /** External URL; these are never type-checked as app routes. */
+    href: ExternalHref;
+    params?: never;
+};
+type LinkTargetProps<TRoute extends string> = LinkExternalTargetProps | LinkRouteTargetProps<TRoute>;
+type LinkProps<TRoute extends string = DefaultRouteHref> = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & LinkTargetProps<TRoute> & {
+    /**
+     * When to prefetch. TanStack-style: "intent" (hover+touch), "viewport", "render", or "none".
+     * Legacy: true (intent+viewport), "hover" (intent), "viewport", false/"none".
+     */
+    prefetch?: PrefetchBehavior | PrefetchLegacy;
+    /** Search params appended after route params are resolved. */
+    query?: FarmRouterBuildOptions["query"];
+    /** Hash appended after route params and search params are resolved. */
+    hash?: string;
+    /** Add a trailing slash to the generated internal href. */
+    trailingSlash?: boolean;
+    /** Delay in ms before intent-based prefetch (hover/touch). Default 50. */
+    prefetchDelay?: number;
+    /** Replace current history entry instead of pushing */
+    replace?: boolean;
+    /** Scroll to top after navigation (default: true) */
+    scroll?: boolean;
+    /** Wrap this SPA navigation in a browser View Transition when supported. */
+    viewTransition?: FarmViewTransitionMode;
+    /** Preserve the active locale by default, or navigate using this locale. */
+    locale?: FarmI18nLocale;
+};
+type LinkComponentType = <TRoute extends string = DefaultRouteHref>(props: LinkProps<TRoute> & {
+    ref?: React__default.ForwardedRef<HTMLAnchorElement>;
+}) => React__default.ReactElement;
+declare const Link: LinkComponentType;
+
+interface UseRouterOptions {
+    basePath?: string;
+    routes?: FarmRouterRouteInput[];
+}
+interface UseBlockerOptions {
+    when: boolean | ((context: FarmNavigationBlockerContext) => boolean);
+    message?: string;
+    shouldBlock?: (context: FarmNavigationBlockerContext) => boolean | Promise<boolean>;
+}
+interface UseBlockerReturn {
+    active: boolean;
+}
+/**
+ * Hook for accessing router state and navigation
+ */
+declare function useRouter(options?: UseRouterOptions): {
+    push: (href: string) => void;
+    replace: (href: string) => void;
+    pushState: <TState>(pageState: TState, href?: string) => void;
+    replaceState: <TState>(pageState: TState, href?: string) => void;
+    back: () => void;
+    forward: () => void;
+    pathname: string;
+    searchParams: URLSearchParams;
+    params: Record<string, string>;
+    pageState: unknown;
+};
+declare function usePageState<TState = unknown>(): TState | null;
+declare function useNavigation(): FarmNavigationState;
+declare function useBlocker(options: UseBlockerOptions): UseBlockerReturn;
+declare function useScrollRestoration<TElement extends HTMLElement = HTMLElement>(key: string): RefObject<TElement | null>;
+
+export { type AnyMutationTarget, type DefaultRouteHref, type DefaultRoutePath, type DefaultRoutePattern, type ExternalHref, FarmClientPluginManager, type FarmNavigateOptions, type FarmNavigationBlocker, type FarmNavigationBlockerContext, type FarmNavigationListener, type FarmNavigationLocation, type FarmNavigationState, type FarmViewTransitionMode, type FetcherFormDataContext, type FetcherFormProps, type FetcherState, type FetcherSubmit, type FetcherSubmitAsync, type InferMutationData, type InferMutationError, type InferMutationVariables, Link, type LinkDefaultRoute, type LinkProps, type MutationAsync, type MutationOptimisticContext, type MutationStatus, type MutationTrigger, type PrefetchBehavior, type RouteHref, type RouteOptionalParamValue, type RouteParamValue, type RouteParams, SPARouter, type Store, type StoreApi, type StoreFields, type StoreKeyListener, type StoreKeysListener, type StoreListener, type StorePatch, type StoreState, type StoreValueUpdater, type UseBlockerOptions, type UseBlockerReturn, type UseFetcherOptions, type UseFetcherReturn, type UseMutationOptions, type UseMutationReturn, type UseRouterOptions, createStore, getRouter, navigateTo, prefetch, pushState, readPageState, replaceState, useBlocker, useFetcher, useMutation, useNavigation, usePageState, useRouter, useScrollRestoration };