import { ObservableQuery } from './observableQuery';
import { PrimitiveQuery } from './primitiveQuery';
import { QueryCache } from './queryCache';
import { CancelOptions, NetworkMode, RetryDelayValue, RetryValue } from './retryer';
import { FetchMeta, QueryMeta, Updater } from './typeUtils';
export type QueryStatus = 'pending' | 'error' | 'success';
export type FetchStatus = 'fetching' | 'paused' | 'idle';
export type InitialDataFunction<T> = () => T | undefined;
export interface QueryBehavior<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData> {
    onFetch: (context: FetchContext<TFetcherData, TVars, TError, TQueryData>) => void;
}
export type QueryKeyHashFunction<TVars> = (queryKey: [string, TVars]) => string;
export interface QueryInfoOptions<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData> {
    query: PrimitiveQuery<TFetcherData, TVars, TError, TQueryData>;
    variables?: TVars;
    /**
     * If `false`, failed queries will not retry by default.
     * If `true`, failed queries will retry infinitely., failureCount: num
     * If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.
     * If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.
     */
    retry?: RetryValue<TError>;
    retryDelay?: RetryDelayValue<TError>;
    networkMode?: NetworkMode;
    gcTime?: number;
    queryHash?: string;
    queryKeyHashFn?: QueryKeyHashFunction<TVars>;
    initialData?: TQueryData | InitialDataFunction<TQueryData>;
    initialDataUpdatedAt?: number | (() => number | undefined);
    /**
     * Set this to `false` to disable structural sharing between query results.
     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.
     * Defaults to `true`.
     */
    structuralSharing?: boolean | ((oldData: TQueryData | undefined, newData: TQueryData) => TQueryData);
    _defaulted?: boolean;
    /**
     * Additional payload to be stored on each query.
     * Use this property to pass information that can be used in other places.
     */
    meta?: QueryMeta;
    /**
     * Maximum number of pages to store in the data of an infinite query.
     */
    maxPages?: number;
    pages?: number;
}
export interface QueryInfoConfig<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData> {
    options: QueryInfoOptions<TFetcherData, TVars, TError, TQueryData>;
    cache: QueryCache;
    state?: QueryInfoState<TQueryData, TError>;
    queryHash: string;
    query: PrimitiveQuery<TFetcherData, TVars, TError, TQueryData>;
    variables: TVars;
}
export interface FetchContext<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData> {
    query: PrimitiveQuery<TFetcherData, TVars, TError, TQueryData>;
    variables: TVars;
    fetchOptions?: FetchOptions;
    options: QueryInfoOptions<TFetcherData, TVars, TError, TQueryData>;
    state: QueryInfoState<TQueryData, TError>;
    fetchFn: () => unknown | Promise<unknown>;
    signal: AbortSignal;
}
export interface SetDataOptions {
    updatedAt?: number;
}
export interface QueryInfoState<TQueryData, TError> {
    data: TQueryData | undefined;
    dataUpdatedAt: number;
    error: TError | null;
    errorUpdatedAt: number;
    fetchMeta: FetchMeta | null;
    isInvalidated: boolean;
    status: QueryStatus;
    fetchStatus: FetchStatus;
}
export interface FetchOptions {
    cancelRefetch?: boolean;
    meta?: FetchMeta;
}
interface FetchAction {
    type: 'fetch';
    meta?: FetchMeta;
}
interface SuccessAction<TQueryData> {
    data: TQueryData | undefined;
    type: 'success';
    dataUpdatedAt?: number;
    manual?: boolean;
}
interface ErrorAction {
    type: 'error';
    error: unknown;
}
interface InvalidateAction {
    type: 'invalidate';
}
interface PauseAction {
    type: 'pause';
}
interface ContinueAction {
    type: 'continue';
}
interface SetStateAction<TQueryData, TError> {
    type: 'setState';
    state: Partial<QueryInfoState<TQueryData, TError>>;
    setStateOptions?: SetStateOptions;
}
export interface SetStateOptions {
    meta?: any;
}
export type Action<TQueryData, TError> = ContinueAction | ErrorAction | FetchAction | InvalidateAction | PauseAction | SetStateAction<TQueryData, TError> | SuccessAction<TQueryData>;
export interface QueryInfo<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData> extends ReturnType<typeof createQueryInfo<TFetcherData, TVars, TError, TQueryData>> {
}
export declare function createQueryInfo<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData>(config: QueryInfoConfig<TFetcherData, TVars, TError, TQueryData>): {
    subscribe: (listener: ObservableQuery<TFetcherData, TVars, TError, TQueryData, any>) => () => void;
    scheduleGc: () => void;
    setState: (state: Partial<QueryInfoState<TQueryData, TError>>, setStateOptions?: SetStateOptions) => void;
    setIsFetchingOptimistic: (value: boolean) => void;
    fetch: (newOptions?: QueryInfoOptions<TFetcherData, TVars, TError, TQueryData>, fetchOptions?: FetchOptions) => Promise<TQueryData>;
    reset: () => void;
    cancel: (cancelOptions?: CancelOptions) => Promise<void>;
    destroy: () => void;
    invalidate: () => void;
    queryHash: string;
    variables: TVars;
    isStaleByTime: (staleTime?: number) => boolean;
    isStale: () => boolean;
    onOnline: () => void;
    onFocus: () => void;
    isActive: () => boolean;
    isDisabled: () => boolean;
    setData: (updater: Updater<TQueryData | undefined, TQueryData | undefined>, options?: SetDataOptions) => TQueryData | undefined;
    getObserversCount: () => number;
    readonly meta: QueryMeta | undefined;
    readonly options: QueryInfoOptions<TFetcherData, TVars, TError, TQueryData>;
    readonly state: QueryInfoState<TQueryData, TError>;
    readonly query: PrimitiveQuery<TFetcherData, TVars, TError, TQueryData>;
};
export {};