import { r as ClientOptions, g as APIResult } from './api-client-C1YzJu3J.js';
export { t as APIClient, h as APIClientError, b as APIClientOptions, i as APIClientSystemError, c as APIClientWithoutIntegrationsOptions, v as ApiClients, J as ClientHeaders, K as ClientLifecycleHooks, L as ClientRequestEvent, M as ClientResponseEvent, a7 as InferIntegrationOperationBody, a8 as InferIntegrationOperationQuery, a9 as InferIntegrationOperationResponse, a3 as IntegrationAPI, _ as IntegrationClient, $ as IntegrationClientAliases, a5 as IntegrationClientData, P as IntegrationClientError, a1 as IntegrationClientOptions, a2 as IntegrationClientRequestOptions, a0 as IntegrationClientRoot, a4 as IntegrationClients, a6 as IntegrationOperationResult, aa as IntegrationServerClient, ab as IntegrationServerClientAliases, ac as IntegrationServerClientOptions, ad as IntegrationServerClientRequestOptions, ae as IntegrationServerClientRoot, af as IntegrationServerRequestLike, s as RouteAPIClient, u as ServerAPIClient, S as ServerAPIClientOptions, d as ServerAPIClientWithoutIntegrationsOptions, x as createAPIClient, w as createApiClients, Q as createIntegrationApi, N as createIntegrationClient, T as createIntegrationClients, V as createIntegrationServerClient, U as createIntegrations, B as createServerAPIClient, W as getIntegrationAPIManifest, X as integrationClients, Y as integrationsClient, Z as integrationsServer } from './api-client-C1YzJu3J.js';
export { y as FarmAPIStream } from './route-CZkTBD-s.js';
import React__default, { ComponentType, FormHTMLAttributes, FormEvent, AnchorHTMLAttributes, RefObject } from 'react';
export { RouteActionTarget, UseActionFormProps, UseActionReturn, UseServerFnOptions, useAction } from './server-fn-client.js';
export { UseServerQueryOptions, UseServerQueryResult, useServerQuery } from './server-query-client.js';
export { a as FarmClientCacheEntry, b as FarmClientCacheKey, F as FarmClientCacheStatus, g as getFarmClientDataCache, n as normalizeFarmClientCacheKey } from './client-cache-BwNdIy9R.js';
export { F as FarmIntegrationAPI, c as FarmIntegrationAPIBodyFormat, e as FarmIntegrationAPIMethod, f as FarmIntegrationAPIOperation, g as FarmIntegrationAPIResponseFormat, a as api, d as defineIntegrationAPI, b as defineIntegrationAPIOperation, i as endpoint } from './integration-api-BbaiokCC.js';
export { UseThemeResult, useTheme } from './theme/client.js';
import { FarmRouterPathParams, FarmRouterPathParam, FarmRouterBuildOptions, FarmRouterRouteInput } from './router.js';
import { i as FarmViewTransitionMode, e as FarmNavigationBlockerContext, F as FarmNavigationState } from './spa-router-CqSJjuIQ.js';
export { a as FarmNavigateOptions, d as FarmNavigationBlocker, f as FarmNavigationListener, h as FarmNavigationLocation, S as SPARouter, g as getRouter, n as navigateTo, p as prefetch, b as pushState, r as readPageState, c as replaceState } from './spa-router-CqSJjuIQ.js';
import { b as FarmI18nLocale } from './types-CnH8DOqo.js';
export { F as FarmChunkRecoveryOptions, i as installChunkErrorRecovery, a as isChunkLoadError } from './chunk-recovery-lnQFzcQP.js';
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, F as FarmClientPluginManager, s as FarmClientPluginManagerOptions, t as FarmClientPluginMetadata, u as FarmClientPluginRegistration, v as FarmClientPluginRouter, w as FarmClientPluginSetupEvent, x as FarmClientPluginStateEvent, c as createClientPluginManager } from './lifecycle-De0vQG45.js';
export { S as ServerQueryFetchOptions, f as fetchServerQuery, p as prefetchServerQuery } from './server-query-runtime-DXRNhX_3.js';
export { getTheme, setTheme, toggleTheme } from './theme/runtime.js';
import './cache.js';
import './server-fn.js';
import './server-fn-error-DDh14a0V.js';
import './server-query.js';
import './types-DQnyD3VD.js';
import './client-plugins-IR4yJ6w3.js';
import './renderer.js';
import 'http';
import './types-Cc8l9IqS.js';
import 'db0';
import 'unstorage';
import './schema.js';
import '@farming-labs/orm';
import './types-CKwggz9n.js';
import '@farming-labs/docs';
import './markdown.js';
import './observability.js';
import '@opentelemetry/api';
import 'vite';
import './workflows-BantWytQ.js';
import './cron.js';
import './env.js';
import './navigation-errors-Dvwpzaer.js';
import './server-action-security.js';
import 'esbuild';
import './image-config-Duob7wER.js';
import './font.js';
import './after.js';
import 'node:http';
import './island-CfGru1MO.js';
import './render-plan-CWfyp4ZG.js';

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 {
    readonly __farmServerFnError: infer TError;
} ? TError : TTarget extends (...args: any[]) => Promise<APIResult<any, infer TError>> ? TError : Error;
type MutationOptimisticContext<TVariables, TData> = {
    variables: TVariables | undefined;
    current: TData | null;
};
type MutationNetworkMode = "always" | "online";
type UseMutationOptions<TVariables, TData, TError = Error> = {
    initialData?: TData | null;
    resetOnMutate?: boolean;
    /**
     * `"always"` (default) dispatches regardless of connectivity, preserving
     * existing behavior. `"online"` pauses a submission while the browser is
     * offline — including one whose dispatch failed while offline — and resumes
     * it on the `online` event instead of failing it.
     */
    networkMode?: MutationNetworkMode;
    optimistic?: (context: MutationOptimisticContext<TVariables, TData>) => TData | null | undefined;
    rollbackOnError?: boolean;
    /**
     * Options forwarded to generated `api.route.method` clients.
     * Server-function targets honor `request.retry`, key-targeted
     * `request.optimistic` updates, and key-targeted `request.invalidate`;
     * the remaining request options apply to API routes only.
     */
    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;
    /** True while a submission is waiting for the browser to come back online. */
    paused: 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";
/** Local form conversion failed before the target was called. */
declare class FetcherInputError extends Error {
    readonly name: "FetcherInputError";
    readonly code: "input_error";
    readonly status: 0;
    readonly data: undefined;
    readonly cause: unknown;
    constructor(cause: unknown);
}
type FetcherFormDataContext = {
    form: HTMLFormElement | null;
    submitter: HTMLElement | null;
};
type UseFetcherOptions<TTarget extends AnyMutationTarget> = Omit<UseMutationOptions<InferMutationVariables<TTarget>, InferMutationData<TTarget>, InferMutationError<TTarget> | FetcherInputError>, "request"> & {
    request?: UseMutationOptions<InferMutationVariables<TTarget>, InferMutationData<TTarget>, InferMutationError<TTarget>>["request"];
    /**
     * Convert browser FormData into the target's typed variables.
     *
     * Generated API routes preserve multipart forms and file values as a FormData
     * body; text-only submissions default to a JSON object (or query for GET/HEAD).
     * Server functions receive FormData directly. This mapper overrides defaults.
     */
    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;
    /** True while a submission is waiting for the browser to come back online. */
    paused: boolean;
    data: InferMutationData<TTarget> | null;
    error: InferMutationError<TTarget> | FetcherInputError | 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>;

declare const FARM_CACHE_INVALIDATION_CHANNEL = "farm:cache-invalidation";
type CrossTabCacheInvalidationOptions = {
    /** Override the BroadcastChannel name, e.g. to isolate multiple apps on one origin. */
    channelName?: string;
};
/**
 * Bridge the cache invalidation bus across tabs of the same origin.
 *
 * Local invalidations are posted to a BroadcastChannel and applied in every
 * other tab through the normal invalidation path, so mounted stale queries
 * there refetch on their own. Only invalidation keys cross the channel, never
 * cached data, which keeps private and credentialed cache scoping untouched.
 *
 * Opt-in and idempotent. Returns a disposer; a no-op where BroadcastChannel
 * is unavailable (server rendering, older browsers).
 */
declare function enableCrossTabCacheInvalidation(options?: CrossTabCacheInvalidationOptions): () => void;

/**
 * Protocol version stamped into every persisted entry. Bump when the
 * persisted shape changes; mismatched entries are dropped on load.
 */
declare const FARM_CLIENT_CACHE_PERSIST_VERSION = "1";
/** Snapshot of a confirmed cache entry as stored by an adapter. */
type PersistedEntry = {
    data: unknown;
    updatedAt: number;
    staleAt: number;
    gcAt?: number;
    version: string;
};
/**
 * Storage contract for client cache persistence. Implement these callbacks
 * over any storage: IndexedDB, localStorage, OPFS, a native bridge. Farm owns
 * every policy decision (what, when, and whether to persist); the adapter is
 * plain keyed storage. `set` is an upsert.
 */
type FarmClientCacheAdapter = {
    keys(): Promise<string[]>;
    get(key: string): Promise<PersistedEntry | null>;
    set(key: string, entry: PersistedEntry): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
    /** Optional batch fast paths; the engine prefers them when present. */
    getMany?(keys: string[]): Promise<Array<PersistedEntry | null>>;
    setMany?(entries: Array<[string, PersistedEntry]>): Promise<void>;
};
/** Key-value client shape accepted by {@link storageClientCacheAdapter}. */
type FarmClientCacheStorage = {
    getItem<T = unknown>(key: string): Promise<T | null>;
    setItem<T = unknown>(key: string, value: T): Promise<unknown>;
    removeItem(key: string): Promise<unknown>;
    getKeys?(base?: string): Promise<string[]>;
    keys?(base?: string): Promise<string[]>;
    clear?(base?: string): Promise<unknown>;
};
type ClientCachePersistenceOptions = {
    /**
     * Extra version salt, typically an app build or deploy id. Entries written
     * under a different value are dropped on load.
     */
    version?: string;
    /** Coarse additional filter on top of per-declaration `persist: true`. */
    persistKey?: (key: string) => boolean;
    /** Debounce for write-behind flushes. */
    flushDelayMs?: number;
};
/**
 * Validate and type an adapter definition. Identity at runtime beyond shape
 * checking, mirroring `defineConfig`-style helpers.
 */
declare function defineClientCacheAdapter(adapter: FarmClientCacheAdapter): FarmClientCacheAdapter;
/**
 * Adapt any Farm/unstorage-compatible key-value client to the client cache
 * adapter contract, mirroring the server's `storageCacheAdapter`. Without a
 * key enumeration method the adapter still persists but cannot warm-start.
 */
declare function storageClientCacheAdapter(storage: FarmClientCacheStorage, options?: {
    base?: string;
}): FarmClientCacheAdapter;
/**
 * @internal Wire an adapter to the shared client cache. Called by the
 * generated client entry from the `cache.client.adapter` configuration; not
 * part of the public API. Returns a disposer.
 */
declare function initPersistedClientCache(adapter: FarmClientCacheAdapter, options?: ClientCachePersistenceOptions): () => void;
/**
 * @internal Entry point used by the generated client entries for the
 * `cache.client.adapter` configuration. Accepts the imported module namespace
 * and reports a misconfigured adapter without breaking application startup:
 * persistence is optional capability and must never block hydration.
 */
declare function initConfiguredClientCachePersistence(adapterModule: unknown, options?: ClientCachePersistenceOptions): void;
/**
 * Remove every persisted cache entry. Call on logout or any session change so
 * the next visitor on this device cannot warm-start into another user's data.
 * Safe to call when persistence is not configured.
 */
declare function clearPersistedCache(): Promise<void>;

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>;

/**
 * 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>>;
/** URI schemes recognized as typed external Link targets. Apps may augment this interface. */
interface LinkExternalUriSchemes {
    about: true;
    blob: true;
    data: true;
    file: true;
    ftp: true;
    ftps: true;
    geo: true;
    git: true;
    http: true;
    https: true;
    im: true;
    intent: true;
    irc: true;
    ircs: true;
    magnet: true;
    mailto: true;
    market: true;
    sms: true;
    ssh: true;
    tel: true;
    urn: true;
    vscode: true;
    webcal: true;
    ws: true;
    wss: true;
}
type ExternalUriScheme = Extract<keyof LinkExternalUriSchemes, string>;
type UriSchemeLetter = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z";
type UriSchemeStart = UriSchemeLetter | Uppercase<UriSchemeLetter>;
type UriSchemeCharacter = UriSchemeStart | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "+" | "-" | ".";
type IsUriSchemeTail<TValue extends string> = TValue extends "" ? true : TValue extends `${infer First}${infer Rest}` ? First extends UriSchemeCharacter ? IsUriSchemeTail<Rest> : false : false;
type IsUriScheme<TValue extends string> = TValue extends `${infer First}${infer Rest}` ? First extends UriSchemeStart ? IsUriSchemeTail<Rest> : false : false;
type KnownExternalHref = `//${string}` | `${ExternalUriScheme}:${string}`;
/** External URLs; these are never type-checked as routes. */
type ExternalHref<THref extends string = string> = string extends THref ? KnownExternalHref : THref extends `//${string}` ? THref : THref extends `${infer Scheme}:${string}` ? IsUriScheme<Scheme> extends true ? THref : never : never;
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<THref extends string = string> = {
    /** External URL; these are never type-checked as app routes. */
    href: ExternalHref<THref>;
    params?: never;
};
type LinkTargetProps<TRoute extends string, THref extends string> = LinkExternalTargetProps<THref> | LinkRouteTargetProps<TRoute>;
type LinkProps<TRoute extends string = DefaultRouteHref, THref extends string = string> = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & LinkTargetProps<TRoute, THref> & {
    /**
     * 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, THref extends string = string>(props: LinkProps<TRoute, THref> & {
    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;
}
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 ClientCachePersistenceOptions, type CrossTabCacheInvalidationOptions, type DefaultRouteHref, type DefaultRoutePath, type DefaultRoutePattern, type ExternalHref, FARM_CACHE_INVALIDATION_CHANNEL, FARM_CLIENT_CACHE_PERSIST_VERSION, type FarmClientCacheAdapter, type FarmClientCacheStorage, FarmNavigationBlockerContext, FarmNavigationState, FarmViewTransitionMode, type FetcherFormDataContext, type FetcherFormProps, FetcherInputError, type FetcherState, type FetcherSubmit, type FetcherSubmitAsync, type InferMutationData, type InferMutationError, type InferMutationVariables, Link, type LinkDefaultRoute, type LinkExternalUriSchemes, type LinkProps, type MutationAsync, type MutationNetworkMode, type MutationOptimisticContext, type MutationStatus, type MutationTrigger, type PersistedEntry, type PrefetchBehavior, type RouteHref, type RouteOptionalParamValue, type RouteParamValue, type RouteParams, 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, clearPersistedCache, createStore, defineClientCacheAdapter, enableCrossTabCacheInvalidation, initConfiguredClientCachePersistence, initPersistedClientCache, storageClientCacheAdapter, useBlocker, useFetcher, useMutation, useNavigation, usePageState, useRouter, useScrollRestoration };