import { b as NexusDefinition, C as CacheHandler } from '../definition-DCghXrsH.js';
import * as react_jsx_runtime from 'react/jsx-runtime';

type QueryRefetchMode = 'foreground' | 'background';
interface UseNexusQueryOptions<TData = unknown, TSelectedData = TData> {
    route?: string;
    enabled?: boolean;
    select?: (data: TData) => TSelectedData;
    revalidateOnWindowFocus?: boolean;
    revalidateOnMount?: boolean;
    keepStaleData?: boolean;
}
interface UseNexusQueryResult<TSelectedData = unknown> {
    data: TSelectedData | undefined;
    headers: Headers | undefined;
    error: Error | null;
    isPending: boolean;
    isPendingBackground: boolean;
    isSuccess: boolean;
    isError: boolean;
    revalidate: () => Promise<void>;
}
type UseNexusInfiniteQueryOptions<TPage, TParam, TSelected = TPage> = UseNexusQueryOptions<TPage, TSelected> & {
    initialPageParam: TParam;
    getNextPageParam: (lastPage: TPage, pages: TPage[]) => TParam | null;
    prefetchNextOnNearViewport?: {
        rootMargin?: string;
        threshold?: number;
        strategy?: 'revalidate' | 'refetch';
        mode?: QueryRefetchMode;
    };
    keepPages?: number;
};
type UseNexusInfiniteQueryResult<TSelected = unknown, TParam = unknown> = Omit<UseNexusQueryResult<{
    pages: TSelected[];
    pageParams: TParam[];
}>, 'revalidate'> & {
    hasNextPage: boolean;
    revalidateNext: () => Promise<void>;
    prefetchRef?: (el: Element | null) => void;
};
interface UseNexusMutationOptions<TContext = unknown, TError = Error, TData = unknown, TVariables = unknown> {
    route?: string;
    onStart?: (variables: TVariables) => TContext | Promise<TContext>;
    onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined) => void | Promise<void>;
    onError?: (error: TError, variables: TVariables, context: TContext | undefined) => void | Promise<void>;
    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context: TContext | undefined) => void | Promise<void>;
}
interface UseNexusMutationResult<TData = unknown, TError = Error, TVariables = unknown> {
    data: TData | undefined;
    headers: Headers | undefined;
    error: TError | null;
    isPending: boolean;
    isSuccess: boolean;
    isError: boolean;
    mutate: (variables: TVariables) => void;
    mutateAsync: (variables: TVariables) => Promise<TData>;
    reset: () => void;
}
interface UseNexusActionOptions<TResult = unknown, TArgs extends unknown[] = [FormData]> {
    onStart?: (...args: TArgs) => void | Promise<void>;
    onSuccess?: (result: TResult, ...args: TArgs) => void | Promise<void>;
    onError?: (error: Error, ...args: TArgs) => void | Promise<void>;
    onSettled?: (result: TResult | undefined, error: Error | null, ...args: TArgs) => void | Promise<void>;
}
interface UseNexusActionResult<TResult = unknown, TError = Error, TArgs extends unknown[] = unknown[]> {
    execute: (...args: TArgs) => void;
    executeAsync: (...args: TArgs) => Promise<TResult>;
    isPending: boolean;
    isSuccess: boolean;
    isError: boolean;
    result: TResult | undefined;
    error: TError | null;
    reset: () => void;
}
interface UseNexusFormActionOptions<TResult = unknown> {
    onStart?: () => void | Promise<void>;
    onSuccess?: (result: TResult) => void | Promise<void>;
    onError?: (error: Error) => void | Promise<void>;
    onSettled?: (result: TResult | undefined, error: Error | null) => void | Promise<void>;
}
interface UseNexusFormActionResult<TResult = unknown, TError = Error> {
    formAction: (formData: FormData) => void;
    isPending: boolean;
    isSuccess: boolean;
    isError: boolean;
    result: TResult | undefined;
    error: TError | null;
    reset: () => void;
}

declare const useNexusQuery: <TData = unknown, TSelectedData = TData>(definition: NexusDefinition<TData>, options?: UseNexusQueryOptions<TData, TSelectedData>) => UseNexusQueryResult<TSelectedData>;

declare const useNexusInfiniteQuery: <TPage = unknown, TParam = unknown, TSelected = TPage>(getDefinition: (param: TParam) => NexusDefinition<TPage>, options: UseNexusInfiniteQueryOptions<TPage, TParam, TSelected>) => UseNexusInfiniteQueryResult<TSelected, TParam>;

declare const useNexusMutation: <TContext = unknown, TError = Error, TData = unknown, TParam = unknown>(mutationDefinition: (param: TParam) => NexusDefinition<TData>, options?: UseNexusMutationOptions<TContext, TError, TData, TParam>) => UseNexusMutationResult<TData, TError, TParam>;

declare const useNexusAction: <TResult = unknown, TError extends Error = Error, TArgs extends unknown[] = unknown[]>(serverAction: (...args: TArgs) => Promise<TResult>, options?: UseNexusActionOptions<TResult, TArgs>) => UseNexusActionResult<TResult, TError, TArgs>;

declare function useNexusFormAction<TResult = unknown, TError extends Error = Error>(serverAction: (formData: FormData) => Promise<TResult>, options?: UseNexusFormActionOptions<TResult>): UseNexusFormActionResult<TResult, TError>;

declare const nexusCache: <TData = unknown>(definition: NexusDefinition<TData>) => CacheHandler<TData>;

declare const revalidateClientTags: (tags: string[]) => void;

declare const NexusRuntime: ({ maxSize }: {
    maxSize?: number;
}) => react_jsx_runtime.JSX.Element;

export { NexusRuntime, nexusCache, revalidateClientTags, useNexusAction, useNexusFormAction, useNexusInfiniteQuery, useNexusMutation, useNexusQuery };