import { FarmRouterRouteInput } from './router.js';
import { F as FarmNavigationState, a as FarmNavigateOptions } from './spa-router-CqSJjuIQ.js';
import { F as FarmClientCacheStatus } from './client-cache-BwNdIy9R.js';
import { ServerFn } from './server-fn.js';
import { ServerQuery } from './server-query.js';
import { S as ServerQueryFetchOptions } from './server-query-runtime-DXRNhX_3.js';
import { F as FarmThemeSnapshot, a as FarmThemePreference } from './types-DQnyD3VD.js';
import { F as FarmI18nClientSnapshot, a as FarmTranslator, b as FarmI18nLocale } from './types-CnH8DOqo.js';
import './client-plugins-IR4yJ6w3.js';
import './lifecycle-De0vQG45.js';
import './route-CZkTBD-s.js';
import './cache.js';
import './renderer.js';
import 'http';
import './types-Cc8l9IqS.js';
import 'db0';
import 'unstorage';
import './schema.js';
import 'react';
import './integration-api-BbaiokCC.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 './server-fn-error-DDh14a0V.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';

interface FarmClientStore<TSnapshot> {
    getSnapshot(): TSnapshot;
    subscribe(listener: () => void): () => void;
}
interface FarmRendererRouterOptions {
    basePath?: string;
    routes?: readonly FarmRouterRouteInput[];
}
interface FarmRendererRouterSnapshot {
    pathname: string;
    searchParams: URLSearchParams;
    params: Record<string, string>;
    pageState: unknown;
    navigation: FarmNavigationState;
}
interface FarmRendererRouter extends FarmClientStore<FarmRendererRouterSnapshot> {
    push(href: string, options?: Omit<FarmNavigateOptions, "replace">): Promise<void>;
    replace(href: string, options?: Omit<FarmNavigateOptions, "replace">): Promise<void>;
    refresh(options?: Omit<FarmNavigateOptions, "replace" | "refresh">): Promise<void>;
    prefetch(href: string): Promise<void>;
    back(): void;
    forward(): void;
    pushState<TState>(state: TState, href?: string): void;
    replaceState<TState>(state: TState, href?: string): void;
}
declare function createRendererRouter(options?: FarmRendererRouterOptions): FarmRendererRouter;
type FarmActionStatus = "idle" | "pending" | "success" | "error";
interface FarmActionSnapshot<TResult, TError extends Error = Error> {
    pending: boolean;
    status: FarmActionStatus;
    data: TResult | null;
    error: TError | null;
}
interface FarmActionOptions<TInput, TResult, TError extends Error = Error> {
    initialResult?: TResult | null;
    resetOnSubmit?: boolean;
    optimistic?: (context: {
        input: TInput | FormData | undefined;
        formData?: FormData;
        current: TResult | null;
    }) => TResult | null | undefined;
    rollbackOnError?: boolean;
    onSuccess?: (result: TResult) => void;
    onError?: (error: TError) => void;
    onSettled?: (result: TResult | null, error: TError | null) => void;
}
type FarmActionSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
type FarmAction<TInput, TResult, TError extends Error = Error> = FarmClientStore<FarmActionSnapshot<TResult, TError>> & {
    submit: FarmActionSubmit<TInput, TResult>;
    reset(): void;
};
type FarmRouteActionTarget<TServerFn extends ServerFn<any, any, any>> = {
    readonly action: TServerFn;
};
declare function createRendererAction<TInput, TResult, TError extends Error = Error>(target: ServerFn<TInput, TResult, TError> | FarmRouteActionTarget<ServerFn<TInput, TResult, TError>>, options?: FarmActionOptions<TInput, TResult, TError>): FarmAction<TInput, TResult, TError>;
interface FarmRendererQueryOptions extends ServerQueryFetchOptions {
    enabled?: boolean;
    refetchOnWindowFocus?: boolean;
    refetchOnReconnect?: boolean;
}
interface FarmRendererQuerySnapshot<TData> {
    data: TData | undefined;
    error: Error | null;
    status: FarmClientCacheStatus;
    pending: boolean;
    fetching: boolean;
    stale: boolean;
}
interface FarmRendererQuery<TData> extends FarmClientStore<FarmRendererQuerySnapshot<TData>> {
    refetch(): Promise<TData>;
    dispose(): void;
}
declare function createRendererQuery<TInput, TData>(query: ServerQuery<TInput, TData>, input: TInput, options?: FarmRendererQueryOptions): FarmRendererQuery<TData>;
interface FarmRendererTheme extends FarmClientStore<FarmThemeSnapshot> {
    setTheme(theme: FarmThemePreference): void;
    toggleTheme(): FarmThemeSnapshot["resolvedTheme"];
}
declare function createRendererTheme(): FarmRendererTheme;
interface FarmRendererI18n extends FarmClientStore<FarmI18nClientSnapshot | undefined> {
    readonly t: FarmTranslator;
    setLocale(locale: FarmI18nLocale): void;
}
declare function createRendererI18n(): FarmRendererI18n;

export { type FarmAction, type FarmActionOptions, type FarmActionSnapshot, type FarmActionStatus, type FarmActionSubmit, type FarmClientStore, FarmI18nClientSnapshot, FarmI18nLocale, type FarmRendererI18n, type FarmRendererQuery, type FarmRendererQueryOptions, type FarmRendererQuerySnapshot, type FarmRendererRouter, type FarmRendererRouterOptions, type FarmRendererRouterSnapshot, type FarmRendererTheme, type FarmRouteActionTarget, FarmTranslator, createRendererAction, createRendererI18n, createRendererQuery, createRendererRouter, createRendererTheme };