import { QueryClient, RefetchOptions } from './queryClient';
import { FetchOptions, QueryInfo, QueryInfoOptions } from './queryInfo';
export type ThrowOnError<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData> = boolean | ((error: unknown, query: QueryInfo<TFetcherData, TVars, TError, TQueryData>) => boolean);
type NonFunctionGuard<T> = T extends (...args: any[]) => any ? never : T;
export type PlaceholderDataFunction<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData> = (previousData: TQueryData | undefined, previousQueryInfo: QueryInfo<TFetcherData, TVars, TError, TQueryData> | undefined) => TQueryData | undefined;
export interface ObservableQueryOptions<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData, TData = TQueryData> extends Omit<QueryInfoOptions<TFetcherData, TVars, TError, TQueryData>, 'pages'> {
    /**
     * Set this to `false` to disable automatic refetching when the query mounts or changes query keys.
     * To refetch the query, use the `refetch` method returned from the `useQuery` instance.
     * Defaults to `true`.
     */
    enabled?: boolean;
    /**
     * The time in milliseconds after datcreateResulta is considered stale.
     * If set to `Infinity`, the data will never be considered stale.
     */
    staleTime?: number;
    /**
     * If set to a number, the query will continuously refetch at this frequency in milliseconds.
     * If set to a function, the function will be executed with the latest data and query to compute a frequency
     * Defaults to `false`.
     */
    refetchInterval?: number | false | ((data: TData | undefined, queryInfo: QueryInfo<TFetcherData, TVars, TError, TQueryData>) => number | false | undefined);
    /**
     * If set to `true`, the query will continue to refetch while their tab/window is in the background.
     * Defaults to `false`.
     */
    refetchIntervalInBackground?: boolean;
    /**
     * If set to `true`, the query will refetch on window focus if the data is stale.
     * If set to `false`, the query will not refetch on window focus.
     * If set to `'always'`, the query will always refetch on window focus.
     * If set to a function, the function will be executed with the latest data and query to compute the value.
     * Defaults to `true`.
     */
    refetchOnWindowFocus?: boolean | 'always' | ((queryInfo: QueryInfo<TFetcherData, TVars, TError, TQueryData>) => boolean | 'always');
    /**
     * If set to `true`, the query will refetch on reconnect if the data is stale.
     * If set to `false`, the query will not refetch on reconnect.
     * If set to `'always'`, the query will always refetch on reconnect.
     * If set to a function, the function will be executed with the latest data and query to compute the value.
     * Defaults to the value of `networkOnline` (`true`)
     */
    refetchOnReconnect?: boolean | 'always' | ((queryInfo: QueryInfo<TFetcherData, TVars, TError, TQueryData>) => boolean | 'always');
    /**
     * If set to `true`, the query will refetch on mount if the data is stale.
     * If set to `false`, will disable additional instances of a query to trigger background refetches.
     * If set to `'always'`, the query will always refetch on mount.
     * If set to a function, the function will be executed with the latest data and query to compute the value
     * Defaults to `true`.
     */
    refetchOnMount?: boolean | 'always' | ((queryInfo: QueryInfo<TFetcherData, TVars, TError, TQueryData>) => boolean | 'always');
    /**
     * If set to `false`, the query will not be retried on mount if it contains an error.
     * Defaults to `true`.
     */
    retryOnMount?: boolean;
    /**
     * Whether errors should be thrown instead of setting the `error` property.
     * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.
     * If set to `false` and `suspense` is `false`, errors are returned as state.
     * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).
     * Defaults to `false`.
     */
    throwOnError?: ThrowOnError<TFetcherData, TVars, TError, TQueryData>;
    /**
     * This option can be used to transform or select a part of the data returned by the query function.
     */
    select?: (data: TQueryData) => TData;
    /**
     * If set to `true`, the query will suspend when `status === 'pending'`
     * and throw errors when `status === 'error'`.
     * Defaults to `false`.
     */
    suspense?: boolean;
    /**
     * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.
     */
    placeholderData?: NonFunctionGuard<TQueryData> | PlaceholderDataFunction<TFetcherData, TVars, TError, TQueryData>;
    behavior?: (obsQuery: any) => any;
    _optimisticResults?: boolean;
}
export interface ObservableQueryBaseResult<TData = unknown, TError = Error> {
    data: TData | undefined;
    error: TError | null;
    isFetching: boolean;
    isLoading: boolean;
    isPlaceholderData: boolean;
    isStale: boolean;
    refetch: (options?: RefetchOptions) => Promise<ObservableQueryResult<TData, TError>>;
}
export interface ObservableQueryLoadingResult<TData = unknown, TError = Error> extends ObservableQueryBaseResult<TData, TError> {
    data: undefined;
    error: null;
}
export interface ObservableQueryLoadingErrorResult<TData = unknown, TError = Error> extends ObservableQueryBaseResult<TData, TError> {
    data: undefined;
    error: TError;
}
export interface ObservableQuerySuccessResult<TData = unknown, TError = Error> extends ObservableQueryBaseResult<TData, TError> {
    data: TData;
    error: null;
}
export type ObservableQueryResult<TData = unknown, TError = Error> = ObservableQueryLoadingResult<TData, TError> | ObservableQueryLoadingErrorResult<TData, TError> | ObservableQuerySuccessResult<TData, TError>;
export interface ObserverFetchOptions extends FetchOptions {
    throwOnError?: boolean;
}
export interface NotifyOptions {
    listeners?: boolean;
}
export interface ObservableQuery<TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData, TData = TFetcherData> extends ReturnType<typeof createObservableQuery<TFetcherData, TVars, TError, TQueryData, TData>> {
}
type ObservableQueryListener<TData = unknown, TError = Error> = (result: ObservableQueryResult<TData, TError>) => void;
export declare const createObservableQuery: <TFetcherData = unknown, TVars = unknown, TError = Error, TQueryData = TFetcherData, TData = TQueryData>(client: QueryClient, initialOptions: ObservableQueryOptions<TFetcherData, TVars, TError, TQueryData, TData>) => {
    subscribe: (listener: ObservableQueryListener<TData, TError>) => () => void;
    onQueryUpdate: () => void;
    setOptions: (newOptions?: Partial<ObservableQueryOptions<TFetcherData, TVars, TError, TQueryData, TData>> | undefined, notifyOptions?: NotifyOptions) => void;
    destroy: () => void;
    refetch: (options?: RefetchOptions) => Promise<ObservableQueryResult<TData, TError>>;
    fetch: (fetchOptions?: ObserverFetchOptions) => Promise<ObservableQueryResult<TData, TError>>;
    updateResult: (notifyOptions?: NotifyOptions) => void;
    getCurrentResult: () => ObservableQueryResult<TData, TError>;
    shouldFetchOnReconnect: () => boolean;
    shouldFetchOnWindowFocus: () => boolean;
    getCurrentQueryInfo: () => QueryInfo<TFetcherData, TVars, TError, TQueryData>;
    getOptimisticResult: (options: ObservableQueryOptions<TFetcherData, TVars, TError, TQueryData, TData>) => ObservableQueryResult<TData, TError>;
    trackResult: (result: ObservableQueryResult<TData, TError>) => ObservableQueryResult<TData, TError>;
    fetchOptimistic(options: ObservableQueryOptions<TFetcherData, TVars, TError, TQueryData, TData>): Promise<ObservableQueryResult<TData, TError>>;
    createResult: (queryInfo: QueryInfo<TFetcherData, TVars, TError, TQueryData>, options: ObservableQueryOptions<TFetcherData, TVars, TError, TQueryData, TData>) => ObservableQueryResult<TData, TError>;
    readonly options: ObservableQueryOptions<TFetcherData, TVars, TError, TQueryData, TData>;
};
export {};