@tanstack/query-core/build/modern/_tsup-dts-rollup.d.ts

The framework agnostic core that powers TanStack Query

export declare type Action<TData, TError, TVariables, TOnMutateResult> = ContinueAction_2 | ErrorAction_2<TError> | FailedAction_2<TError> | PendingAction<TVariables, TOnMutateResult> | PauseAction_2 | SuccessAction_2<TData>;

export declare type Action_alias_1<TData, TError> = ContinueAction | ErrorAction<TError> | FailedAction<TError> | FetchAction | InvalidateAction | PauseAction | SetStateAction<TData, TError> | SuccessAction<TData>;

export declare function addConsumeAwareSignal<T>(object: T, getSignal: () => AbortSignal, onCancelled: VoidFunction): T & {
    signal: AbortSignal;
};

export declare function addToEnd<T>(items: Array<T>, item: T, max?: number): Array<T>;

export declare function addToStart<T>(items: Array<T>, item: T, max?: number): Array<T>;

declare type AnyDataTag = {
    [dataTagSymbol]: any;
    [dataTagErrorSymbol]: any;
};
export { AnyDataTag }
export { AnyDataTag as AnyDataTag_alias_1 }

declare type BaseStreamedQueryParams<TQueryFnData, TQueryKey extends QueryKey> = {
    streamFn: (context: QueryFunctionContext<TQueryKey>) => AsyncIterable<TQueryFnData> | Promise<AsyncIterable<TQueryFnData>>;
    refetchMode?: 'append' | 'reset' | 'replace';
};

declare type BatchCallsCallback<T extends Array<unknown>> = (...args: T) => void;

declare type BatchNotifyFunction = (callback: () => void) => void;

declare class CancelledError extends Error {
    revert?: boolean;
    silent?: boolean;
    constructor(options?: CancelOptions);
}
export { CancelledError }
export { CancelledError as CancelledError_alias_1 }

declare interface CancelOptions {
    revert?: boolean;
    silent?: boolean;
}
export { CancelOptions }
export { CancelOptions as CancelOptions_alias_1 }

export declare function canFetch(networkMode: NetworkMode | undefined): boolean;

declare type CombineFn<TCombinedResult> = (result: Array<QueryObserverResult>) => TCombinedResult;

declare interface ContinueAction {
    type: 'continue';
}

declare interface ContinueAction_2 {
    type: 'continue';
}

export declare function createNotifyManager(): {
    readonly batch: <T>(callback: () => T) => T;
    /**
     * All calls to the wrapped function will be batched.
     */
    readonly batchCalls: <T extends Array<unknown>>(callback: BatchCallsCallback<T>) => BatchCallsCallback<T>;
    readonly schedule: (callback: NotifyCallback) => void;
    /**
     * Use this method to set a custom notify function.
     * This can be used to for example wrap notifications with `React.act` while running tests.
     */
    readonly setNotifyFunction: (fn: NotifyFunction) => void;
    /**
     * Use this method to set a custom function to batch notifications together into a single tick.
     * By default React Query will use the batch function provided by ReactDOM or React Native.
     */
    readonly setBatchNotifyFunction: (fn: BatchNotifyFunction) => void;
    readonly setScheduler: (fn: ScheduleFunction) => void;
};

export declare function createRetryer<TData = unknown, TError = DefaultError>(config: RetryerConfig<TData, TError>): Retryer<TData>;

declare type DataTag<TType, TValue, TError = UnsetMarker> = TType extends AnyDataTag ? TType : TType & {
    [dataTagSymbol]: TValue;
    [dataTagErrorSymbol]: TError;
};
export { DataTag }
export { DataTag as DataTag_alias_1 }

declare const dataTagErrorSymbol: unique symbol;

declare type dataTagErrorSymbol = typeof dataTagErrorSymbol;
export { dataTagErrorSymbol }
export { dataTagErrorSymbol as dataTagErrorSymbol_alias_1 }

declare const dataTagSymbol: unique symbol;

declare type dataTagSymbol = typeof dataTagSymbol;
export { dataTagSymbol }
export { dataTagSymbol as dataTagSymbol_alias_1 }

declare type DefaultedInfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = WithRequired<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'throwOnError' | 'refetchOnReconnect' | 'queryHash'>;
export { DefaultedInfiniteQueryObserverOptions }
export { DefaultedInfiniteQueryObserverOptions as DefaultedInfiniteQueryObserverOptions_alias_1 }

declare type DefaultedQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'throwOnError' | 'refetchOnReconnect' | 'queryHash'>;
export { DefaultedQueryObserverOptions }
export { DefaultedQueryObserverOptions as DefaultedQueryObserverOptions_alias_1 }

declare type DefaultError = Register extends {
    defaultError: infer TError;
} ? TError : Error;
export { DefaultError }
export { DefaultError as DefaultError_alias_1 }

declare interface DefaultOptions<TError = DefaultError> {
    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'suspense' | 'queryKey'>;
    mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
    hydrate?: HydrateOptions['defaultOptions'];
    dehydrate?: DehydrateOptions;
}
export { DefaultOptions }
export { DefaultOptions as DefaultOptions_alias_1 }

declare const defaultScheduler: ScheduleFunction;
export { defaultScheduler }
export { defaultScheduler as defaultScheduler_alias_1 }

declare function defaultShouldDehydrateMutation(mutation: Mutation): boolean;
export { defaultShouldDehydrateMutation }
export { defaultShouldDehydrateMutation as defaultShouldDehydrateMutation_alias_1 }

declare function defaultShouldDehydrateQuery(query: Query): boolean;
export { defaultShouldDehydrateQuery }
export { defaultShouldDehydrateQuery as defaultShouldDehydrateQuery_alias_1 }

export declare const defaultTimeoutProvider: TimeoutProvider;

declare type DefinedInfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
export { DefinedInfiniteQueryObserverResult }
export { DefinedInfiniteQueryObserverResult as DefinedInfiniteQueryObserverResult_alias_1 }

declare type DefinedQueryObserverResult<TData = unknown, TError = DefaultError> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
export { DefinedQueryObserverResult }
export { DefinedQueryObserverResult as DefinedQueryObserverResult_alias_1 }

declare function dehydrate(client: QueryClient, options?: DehydrateOptions): DehydratedState;
export { dehydrate }
export { dehydrate as dehydrate_alias_1 }

declare interface DehydratedMutation {
    mutationKey?: MutationKey;
    state: MutationState;
    meta?: MutationMeta;
    scope?: MutationScope;
}

declare interface DehydratedQuery {
    queryHash: string;
    queryKey: QueryKey;
    state: QueryState;
    promise?: Promise<unknown>;
    meta?: QueryMeta;
    dehydratedAt?: number;
}

declare interface DehydratedState {
    mutations: Array<DehydratedMutation>;
    queries: Array<DehydratedQuery>;
}
export { DehydratedState }
export { DehydratedState as DehydratedState_alias_1 }

declare interface DehydrateOptions {
    serializeData?: TransformerFn;
    shouldDehydrateMutation?: (mutation: Mutation) => boolean;
    shouldDehydrateQuery?: (query: Query) => boolean;
    shouldRedactErrors?: (error: unknown) => boolean;
}
export { DehydrateOptions }
export { DehydrateOptions as DehydrateOptions_alias_1 }

declare type DistributiveOmit<TObject, TKey extends keyof TObject> = TObject extends any ? Omit<TObject, TKey> : never;
export { DistributiveOmit }
export { DistributiveOmit as DistributiveOmit_alias_1 }

declare type DropLast<T extends ReadonlyArray<unknown>> = T extends readonly [
...infer R,
unknown
] ? readonly [...R] : never;

declare type Enabled<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = boolean | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean);
export { Enabled }
export { Enabled as Enabled_alias_1 }

declare type EnsureInfiniteQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> & {
    revalidateIfStale?: boolean;
};
export { EnsureInfiniteQueryDataOptions }
export { EnsureInfiniteQueryDataOptions as EnsureInfiniteQueryDataOptions_alias_1 }

declare interface EnsureQueryDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam> {
    revalidateIfStale?: boolean;
}
export { EnsureQueryDataOptions }
export { EnsureQueryDataOptions as EnsureQueryDataOptions_alias_1 }

export declare function ensureQueryFn<TQueryFnData = unknown, TQueryKey extends QueryKey = QueryKey>(options: {
    queryFn?: QueryFunction<TQueryFnData, TQueryKey> | SkipToken;
    queryHash?: string;
}, fetchOptions?: FetchOptions<TQueryFnData>): QueryFunction<TQueryFnData, TQueryKey>;

/**
 * Manages environment detection used by TanStack Query internals.
 */
declare const environmentManager: {
    /**
     * Returns whether the current runtime should be treated as a server environment.
     */
    isServer(): boolean;
    /**
     * Overrides the server check globally.
     */
    setIsServer(isServerValue: IsServerValue): void;
};
export { environmentManager }
export { environmentManager as environmentManager_alias_1 }

declare interface ErrorAction<TError> {
    type: 'error';
    error: TError;
}

declare interface ErrorAction_2<TError> {
    type: 'error';
    error: TError;
}

declare interface FailedAction<TError> {
    type: 'failed';
    failureCount: number;
    error: TError;
}

declare interface FailedAction_2<TError> {
    type: 'failed';
    failureCount: number;
    error: TError | null;
}

declare interface FetchAction {
    type: 'fetch';
    meta?: FetchMeta;
}

export declare interface FetchContext<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
    fetchFn: () => unknown | Promise<unknown>;
    fetchOptions?: FetchOptions;
    signal: AbortSignal;
    options: QueryOptions<TQueryFnData, TError, TData, any>;
    client: QueryClient;
    queryKey: TQueryKey;
    state: QueryState<TData, TError>;
}

export declare type FetchDirection = 'forward' | 'backward';

declare type FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Omit<FetchQueryOptions<TQueryFnData, TError, InfiniteData<TData, TPageParam>, TQueryKey, TPageParam>, 'initialPageParam'> & InitialPageParam<TPageParam> & FetchInfiniteQueryPages<TQueryFnData, TPageParam>;
export { FetchInfiniteQueryOptions }
export { FetchInfiniteQueryOptions as FetchInfiniteQueryOptions_alias_1 }

declare type FetchInfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> = {
    pages?: never;
} | {
    pages: number;
    getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
};

export declare interface FetchMeta {
    fetchMore?: {
        direction: FetchDirection;
    };
}

declare interface FetchNextPageOptions extends ResultOptions {
    /**
     * If set to `true`, calling `fetchNextPage` repeatedly will invoke `queryFn` every time,
     * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
     *
     * If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.
     *
     * Defaults to `true`.
     */
    cancelRefetch?: boolean;
}
export { FetchNextPageOptions }
export { FetchNextPageOptions as FetchNextPageOptions_alias_1 }

export declare interface FetchOptions<TData = unknown> {
    cancelRefetch?: boolean;
    meta?: FetchMeta;
    initialPromise?: Promise<TData>;
}

declare interface FetchPreviousPageOptions extends ResultOptions {
    /**
     * If set to `true`, calling `fetchPreviousPage` repeatedly will invoke `queryFn` every time,
     * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.
     *
     * If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.
     *
     * Defaults to `true`.
     */
    cancelRefetch?: boolean;
}
export { FetchPreviousPageOptions }
export { FetchPreviousPageOptions as FetchPreviousPageOptions_alias_1 }

declare interface FetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey'> {
    initialPageParam?: never;
    /**
     * The time in milliseconds after data is considered stale.
     * If the data is fresh it will be returned from the cache.
     */
    staleTime?: StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>;
}
export { FetchQueryOptions }
export { FetchQueryOptions as FetchQueryOptions_alias_1 }

export declare function fetchState<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(data: TData | undefined, options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>): {
    readonly error?: null | undefined;
    readonly status?: "pending" | undefined;
    readonly fetchFailureCount: 0;
    readonly fetchFailureReason: null;
    readonly fetchStatus: "fetching" | "paused";
};

declare type FetchStatus = 'fetching' | 'paused' | 'idle';
export { FetchStatus }
export { FetchStatus as FetchStatus_alias_1 }

export declare class FocusManager extends Subscribable<Listener> {
    #private;
    constructor();
    protected onSubscribe(): void;
    protected onUnsubscribe(): void;
    setEventListener(setup: SetupFn): void;
    setFocused(focused?: boolean): void;
    onFocus(): void;
    isFocused(): boolean;
}

declare const focusManager: FocusManager;
export { focusManager }
export { focusManager as focusManager_alias_1 }

/**
 * Thenable types which matches React's types for promises
 *
 * React seemingly uses `.status`, `.value` and `.reason` properties on a promises to optimistically unwrap data from promises
 *
 * @see https://github.com/facebook/react/blob/main/packages/shared/ReactTypes.js#L112-L138
 * @see https://github.com/facebook/react/blob/4f604941569d2e8947ce1460a0b2997e835f37b9/packages/react-debug-tools/src/ReactDebugHooks.js#L224-L227
 */
declare interface Fulfilled<T> {
    status: 'fulfilled';
    value: T;
}

export declare type FulfilledThenable<T> = Promise<T> & Fulfilled<T>;

export declare function functionalUpdate<TInput, TOutput>(updater: Updater<TInput, TOutput>, input: TInput): TOutput;

export declare function getDefaultState<TData, TError, TVariables, TOnMutateResult>(): MutationState<TData, TError, TVariables, TOnMutateResult>;

declare type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (lastPage: TQueryFnData, allPages: Array<TQueryFnData>, lastPageParam: TPageParam, allPageParams: Array<TPageParam>) => TPageParam | undefined | null;
export { GetNextPageParamFunction }
export { GetNextPageParamFunction as GetNextPageParamFunction_alias_1 }

declare type GetPreviousPageParamFunction<TPageParam, TQueryFnData = unknown> = (firstPage: TQueryFnData, allPages: Array<TQueryFnData>, firstPageParam: TPageParam, allPageParams: Array<TPageParam>) => TPageParam | undefined | null;
export { GetPreviousPageParamFunction }
export { GetPreviousPageParamFunction as GetPreviousPageParamFunction_alias_1 }

/**
 * Default query & mutation keys hash function.
 * Hashes the value into a stable hash.
 */
declare function hashKey(queryKey: QueryKey | MutationKey): string;
export { hashKey }
export { hashKey as hashKey_alias_1 }

export declare function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Pick<QueryOptions<any, any, any, any>, 'queryKeyHashFn'>): string;

/**
 * Checks if there is a next page.
 */
export declare function hasNextPage(options: InfiniteQueryPageParamsOptions<any, any>, data?: InfiniteData<unknown>): boolean;

/**
 * Checks if there is a previous page.
 */
export declare function hasPreviousPage(options: InfiniteQueryPageParamsOptions<any, any>, data?: InfiniteData<unknown>): boolean;

declare function hydrate(client: QueryClient, dehydratedState: unknown, options?: HydrateOptions): void;
export { hydrate }
export { hydrate as hydrate_alias_1 }

declare interface HydrateOptions {
    defaultOptions?: {
        deserializeData?: TransformerFn;
        queries?: QueryOptions;
        mutations?: MutationOptions<unknown, DefaultError, unknown, unknown>;
    };
}
export { HydrateOptions }
export { HydrateOptions as HydrateOptions_alias_1 }

declare type InferDataFromTag<TQueryFnData, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, infer TaggedValue, unknown> ? TaggedValue : TQueryFnData;
export { InferDataFromTag }
export { InferDataFromTag as InferDataFromTag_alias_1 }

declare type InferErrorFromTag<TError, TTaggedQueryKey extends QueryKey> = TTaggedQueryKey extends DataTag<unknown, unknown, infer TaggedError> ? TaggedError extends UnsetMarker ? TError : TaggedError : TError;
export { InferErrorFromTag }
export { InferErrorFromTag as InferErrorFromTag_alias_1 }

declare interface InfiniteData<TData, TPageParam = unknown> {
    pages: Array<TData>;
    pageParams: Array<TPageParam>;
}
export { InfiniteData }
export { InfiniteData as InfiniteData_alias_1 }

export declare function infiniteQueryBehavior<TQueryFnData, TError, TData, TPageParam>(pages?: number): QueryBehavior<TQueryFnData, TError, InfiniteData<TData, TPageParam>>;

declare class InfiniteQueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey> {
    subscribe: Subscribable<InfiniteQueryObserverListener<TData, TError>>['subscribe'];
    getCurrentResult: ReplaceReturnType<QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>['getCurrentResult'], InfiniteQueryObserverResult<TData, TError>>;
    protected fetch: ReplaceReturnType<QueryObserver<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>['fetch'], Promise<InfiniteQueryObserverResult<TData, TError>>>;
    constructor(client: QueryClient, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>);
    protected bindMethods(): void;
    setOptions(options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): void;
    getOptimisticResult(options: DefaultedInfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): InfiniteQueryObserverResult<TData, TError>;
    fetchNextPage(options?: FetchNextPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
    fetchPreviousPage(options?: FetchPreviousPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
    protected createResult(query: Query<TQueryFnData, TError, InfiniteData<TQueryFnData, TPageParam>, TQueryKey>, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): InfiniteQueryObserverResult<TData, TError>;
}
export { InfiniteQueryObserver }
export { InfiniteQueryObserver as InfiniteQueryObserver_alias_1 }

declare interface InfiniteQueryObserverBaseResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
    /**
     * This function allows you to fetch the next "page" of results.
     */
    fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
    /**
     * This function allows you to fetch the previous "page" of results.
     */
    fetchPreviousPage: (options?: FetchPreviousPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
    /**
     * Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).
     */
    hasNextPage: boolean;
    /**
     * Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).
     */
    hasPreviousPage: boolean;
    /**
     * Will be `true` if the query failed while fetching the next page.
     */
    isFetchNextPageError: boolean;
    /**
     * Will be `true` while fetching the next page with `fetchNextPage`.
     */
    isFetchingNextPage: boolean;
    /**
     * Will be `true` if the query failed while fetching the previous page.
     */
    isFetchPreviousPageError: boolean;
    /**
     * Will be `true` while fetching the previous page with `fetchPreviousPage`.
     */
    isFetchingPreviousPage: boolean;
}
export { InfiniteQueryObserverBaseResult }
export { InfiniteQueryObserverBaseResult as InfiniteQueryObserverBaseResult_alias_1 }

declare type InfiniteQueryObserverListener<TData, TError> = (result: InfiniteQueryObserverResult<TData, TError>) => void;

declare interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
    data: undefined;
    error: TError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: 'error';
}
export { InfiniteQueryObserverLoadingErrorResult }
export { InfiniteQueryObserverLoadingErrorResult as InfiniteQueryObserverLoadingErrorResult_alias_1 }

declare interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: 'pending';
}
export { InfiniteQueryObserverLoadingResult }
export { InfiniteQueryObserverLoadingResult as InfiniteQueryObserverLoadingResult_alias_1 }

declare interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserverOptions<TQueryFnData, TError, TData, InfiniteData<TQueryFnData, TPageParam>, TQueryKey, TPageParam>, InfiniteQueryPageParamsOptions<TQueryFnData, TPageParam> {
}
export { InfiniteQueryObserverOptions }
export { InfiniteQueryObserverOptions as InfiniteQueryObserverOptions_alias_1 }

declare interface InfiniteQueryObserverPendingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
    data: undefined;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: false;
    isPlaceholderData: false;
    status: 'pending';
}
export { InfiniteQueryObserverPendingResult }
export { InfiniteQueryObserverPendingResult as InfiniteQueryObserverPendingResult_alias_1 }

declare interface InfiniteQueryObserverPlaceholderResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
    data: TData;
    isError: false;
    error: null;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    status: 'success';
}
export { InfiniteQueryObserverPlaceholderResult }
export { InfiniteQueryObserverPlaceholderResult as InfiniteQueryObserverPlaceholderResult_alias_1 }

declare interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
    data: TData;
    error: TError;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    status: 'error';
}
export { InfiniteQueryObserverRefetchErrorResult }
export { InfiniteQueryObserverRefetchErrorResult as InfiniteQueryObserverRefetchErrorResult_alias_1 }

declare type InfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError> | InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverPendingResult<TData, TError> | InfiniteQueryObserverPlaceholderResult<TData, TError>;
export { InfiniteQueryObserverResult }
export { InfiniteQueryObserverResult as InfiniteQueryObserverResult_alias_1 }

declare interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
    data: TData;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isFetchNextPageError: false;
    isFetchPreviousPageError: false;
    isSuccess: true;
    isPlaceholderData: false;
    status: 'success';
}
export { InfiniteQueryObserverSuccessResult }
export { InfiniteQueryObserverSuccessResult as InfiniteQueryObserverSuccessResult_alias_1 }

declare interface InfiniteQueryPageParamsOptions<TQueryFnData = unknown, TPageParam = unknown> extends InitialPageParam<TPageParam> {
    /**
     * This function can be set to automatically get the previous cursor for infinite queries.
     * The result will also be used to determine the value of `hasPreviousPage`.
     */
    getPreviousPageParam?: GetPreviousPageParamFunction<TPageParam, TQueryFnData>;
    /**
     * This function can be set to automatically get the next cursor for infinite queries.
     * The result will also be used to determine the value of `hasNextPage`.
     */
    getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
}
export { InfiniteQueryPageParamsOptions }
export { InfiniteQueryPageParamsOptions as InfiniteQueryPageParamsOptions_alias_1 }

declare type InitialDataFunction<T> = () => T | undefined;
export { InitialDataFunction }
export { InitialDataFunction as InitialDataFunction_alias_1 }

declare interface InitialPageParam<TPageParam = unknown> {
    initialPageParam: TPageParam;
}
export { InitialPageParam }
export { InitialPageParam as InitialPageParam_alias_1 }

declare interface InvalidateAction {
    type: 'invalidate';
}

declare interface InvalidateOptions extends RefetchOptions {
}
export { InvalidateOptions }
export { InvalidateOptions as InvalidateOptions_alias_1 }

declare interface InvalidateQueryFilters<TQueryKey extends QueryKey = QueryKey> extends QueryFilters<TQueryKey> {
    refetchType?: QueryTypeFilter | 'none';
}
export { InvalidateQueryFilters }
export { InvalidateQueryFilters as InvalidateQueryFilters_alias_1 }

/**
 * @deprecated Use instanceof `CancelledError` instead.
 */
declare function isCancelledError(value: any): value is CancelledError;
export { isCancelledError }
export { isCancelledError as isCancelledError_alias_1 }

export declare function isPlainArray(value: unknown): value is Array<unknown>;

export declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;

/** @deprecated
 * use `environmentManager.isServer()` instead.
 */
declare const isServer: boolean;
export { isServer }
export { isServer as isServer_alias_1 }

export declare type IsServerValue = () => boolean;

export declare function isValidTimeout(value: unknown): value is number;

declare function keepPreviousData<T>(previousData: T | undefined): T | undefined;
export { keepPreviousData }
export { keepPreviousData as keepPreviousData_alias_1 }

declare type Listener = (focused: boolean) => void;

declare type Listener_2 = (online: boolean) => void;

/**
 * Wrapping `setTimeout` is awkward from a typing perspective because platform
 * typings may extend the return type of `setTimeout`. For example, NodeJS
 * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be
 * able to return such a type.
 */
declare type ManagedTimerId = number | {
    [Symbol.toPrimitive]: () => number;
};
export { ManagedTimerId }
export { ManagedTimerId as ManagedTimerId_alias_1 }

declare function matchMutation(filters: MutationFilters, mutation: Mutation<any, any>): boolean;
export { matchMutation }
export { matchMutation as matchMutation_alias_1 }

declare function matchQuery(filters: QueryFilters, query: Query<any, any, any, any>): boolean;
export { matchQuery }
export { matchQuery as matchQuery_alias_1 }

declare type MutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>) => Promise<TData>;
export { MutateFunction }
export { MutateFunction as MutateFunction_alias_1 }

declare interface MutateOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
    onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
    onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => void;
}
export { MutateOptions }
export { MutateOptions as MutateOptions_alias_1 }

declare class Mutation<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> extends Removable {
    #private;
    state: MutationState<TData, TError, TVariables, TOnMutateResult>;
    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
    readonly mutationId: number;
    constructor(config: MutationConfig<TData, TError, TVariables, TOnMutateResult>);
    setOptions(options: MutationOptions<TData, TError, TVariables, TOnMutateResult>): void;
    get meta(): MutationMeta | undefined;
    addObserver(observer: MutationObserver_2<any, any, any, any>): void;
    removeObserver(observer: MutationObserver_2<any, any, any, any>): void;
    protected optionalRemove(): void;
    continue(): Promise<unknown>;
    execute(variables: TVariables): Promise<TData>;
}
export { Mutation }
export { Mutation as Mutation_alias_1 }

declare class MutationCache extends Subscribable<MutationCacheListener> {
    #private;
    config: MutationCacheConfig;
    constructor(config?: MutationCacheConfig);
    build<TData, TError, TVariables, TOnMutateResult>(client: QueryClient, options: MutationOptions<TData, TError, TVariables, TOnMutateResult>, state?: MutationState<TData, TError, TVariables, TOnMutateResult>): Mutation<TData, TError, TVariables, TOnMutateResult>;
    add(mutation: Mutation<any, any, any, any>): void;
    remove(mutation: Mutation<any, any, any, any>): void;
    canRun(mutation: Mutation<any, any, any, any>): boolean;
    runNext(mutation: Mutation<any, any, any, any>): Promise<unknown>;
    clear(): void;
    getAll(): Array<Mutation>;
    find<TData = unknown, TError = DefaultError, TVariables = any, TOnMutateResult = unknown>(filters: MutationFilters): Mutation<TData, TError, TVariables, TOnMutateResult> | undefined;
    findAll(filters?: MutationFilters): Array<Mutation>;
    notify(event: MutationCacheNotifyEvent): void;
    resumePausedMutations(): Promise<unknown>;
}
export { MutationCache }
export { MutationCache as MutationCache_alias_1 }

declare interface MutationCacheConfig {
    onError?: (error: DefaultError, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
    onSuccess?: (data: unknown, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
    onMutate?: (variables: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
    onSettled?: (data: unknown | undefined, error: DefaultError | null, variables: unknown, onMutateResult: unknown, mutation: Mutation<unknown, unknown, unknown>, context: MutationFunctionContext) => Promise<unknown> | unknown;
}

declare type MutationCacheListener = (event: MutationCacheNotifyEvent) => void;

declare type MutationCacheNotifyEvent = NotifyEventMutationAdded | NotifyEventMutationRemoved | NotifyEventMutationObserverAdded | NotifyEventMutationObserverRemoved | NotifyEventMutationObserverOptionsUpdated | NotifyEventMutationUpdated;
export { MutationCacheNotifyEvent }
export { MutationCacheNotifyEvent as MutationCacheNotifyEvent_alias_1 }

declare interface MutationConfig<TData, TError, TVariables, TOnMutateResult> {
    client: QueryClient;
    mutationId: number;
    mutationCache: MutationCache;
    options: MutationOptions<TData, TError, TVariables, TOnMutateResult>;
    state?: MutationState<TData, TError, TVariables, TOnMutateResult>;
}

declare interface MutationFilters<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
    /**
     * Match mutation key exactly
     */
    exact?: boolean;
    /**
     * Include mutations matching this predicate function
     */
    predicate?: (mutation: Mutation<TData, TError, TVariables, TOnMutateResult>) => boolean;
    /**
     * Include mutations matching this mutation key
     */
    mutationKey?: TuplePrefixes<MutationKey>;
    /**
     * Filter by mutation status
     */
    status?: MutationStatus;
}
export { MutationFilters }
export { MutationFilters as MutationFilters_alias_1 }

declare type MutationFunction<TData = unknown, TVariables = unknown> = (variables: TVariables, context: MutationFunctionContext) => Promise<TData>;
export { MutationFunction }
export { MutationFunction as MutationFunction_alias_1 }

declare type MutationFunctionContext = {
    client: QueryClient;
    meta: MutationMeta | undefined;
    mutationKey?: MutationKey;
};
export { MutationFunctionContext }
export { MutationFunctionContext as MutationFunctionContext_alias_1 }

declare type MutationKey = Register extends {
    mutationKey: infer TMutationKey;
} ? TMutationKey extends ReadonlyArray<unknown> ? TMutationKey : TMutationKey extends Array<unknown> ? TMutationKey : ReadonlyArray<unknown> : ReadonlyArray<unknown>;
export { MutationKey }
export { MutationKey as MutationKey_alias_1 }

declare type MutationMeta = Register extends {
    mutationMeta: infer TMutationMeta;
} ? TMutationMeta extends Record<string, unknown> ? TMutationMeta : Record<string, unknown> : Record<string, unknown>;
export { MutationMeta }
export { MutationMeta as MutationMeta_alias_1 }

declare class MutationObserver_2<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends Subscribable<MutationObserverListener<TData, TError, TVariables, TOnMutateResult>> {
    #private;
    options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>;
    constructor(client: QueryClient, options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>);
    protected bindMethods(): void;
    setOptions(options: MutationObserverOptions<TData, TError, TVariables, TOnMutateResult>): void;
    protected onUnsubscribe(): void;
    onMutationUpdate(action: Action<TData, TError, TVariables, TOnMutateResult>): void;
    getCurrentResult(): MutationObserverResult<TData, TError, TVariables, TOnMutateResult>;
    reset(): void;
    mutate(variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>): Promise<TData>;
}
export { MutationObserver_2 as MutationObserver }
export { MutationObserver_2 as MutationObserver_alias_1 }

declare interface MutationObserverBaseResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationState<TData, TError, TVariables, TOnMutateResult> {
    /**
     * The last successfully resolved data for the mutation.
     */
    data: TData | undefined;
    /**
     * The variables object passed to the `mutationFn`.
     */
    variables: TVariables | undefined;
    /**
     * The error object for the mutation, if an error was encountered.
     * - Defaults to `null`.
     */
    error: TError | null;
    /**
     * A boolean variable derived from `status`.
     * - `true` if the last mutation attempt resulted in an error.
     */
    isError: boolean;
    /**
     * A boolean variable derived from `status`.
     * - `true` if the mutation is in its initial state prior to executing.
     */
    isIdle: boolean;
    /**
     * A boolean variable derived from `status`.
     * - `true` if the mutation is currently executing.
     */
    isPending: boolean;
    /**
     * A boolean variable derived from `status`.
     * - `true` if the last mutation attempt was successful.
     */
    isSuccess: boolean;
    /**
     * The status of the mutation.
     * - Will be:
     *   - `idle` initial status prior to the mutation function executing.
     *   - `pending` if the mutation is currently executing.
     *   - `error` if the last mutation attempt resulted in an error.
     *   - `success` if the last mutation attempt was successful.
     */
    status: MutationStatus;
    /**
     * The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.
     * @param variables - The variables object to pass to the `mutationFn`.
     * @param options.onSuccess - This function will fire when the mutation is successful and will be passed the mutation's result.
     * @param options.onError - This function will fire if the mutation encounters an error and will be passed the error.
     * @param options.onSettled - This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.
     * @remarks
     * - If you make multiple requests, `onSuccess` will fire only after the latest call you've made.
     * - All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.
     */
    mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>;
    /**
     * A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).
     */
    reset: () => void;
}
export { MutationObserverBaseResult }
export { MutationObserverBaseResult as MutationObserverBaseResult_alias_1 }

declare interface MutationObserverErrorResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
    data: undefined;
    error: TError;
    variables: TVariables;
    isError: true;
    isIdle: false;
    isPending: false;
    isSuccess: false;
    status: 'error';
}
export { MutationObserverErrorResult }
export { MutationObserverErrorResult as MutationObserverErrorResult_alias_1 }

declare interface MutationObserverIdleResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
    data: undefined;
    variables: undefined;
    error: null;
    isError: false;
    isIdle: true;
    isPending: false;
    isSuccess: false;
    status: 'idle';
}
export { MutationObserverIdleResult }
export { MutationObserverIdleResult as MutationObserverIdleResult_alias_1 }

declare type MutationObserverListener<TData, TError, TVariables, TOnMutateResult> = (result: MutationObserverResult<TData, TError, TVariables, TOnMutateResult>) => void;

declare interface MutationObserverLoadingResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
    data: undefined;
    variables: TVariables;
    error: null;
    isError: false;
    isIdle: false;
    isPending: true;
    isSuccess: false;
    status: 'pending';
}
export { MutationObserverLoadingResult }
export { MutationObserverLoadingResult as MutationObserverLoadingResult_alias_1 }

declare interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationOptions<TData, TError, TVariables, TOnMutateResult> {
    throwOnError?: boolean | ((error: TError) => boolean);
}
export { MutationObserverOptions }
export { MutationObserverOptions as MutationObserverOptions_alias_1 }

declare type MutationObserverResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> = MutationObserverIdleResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverLoadingResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverErrorResult<TData, TError, TVariables, TOnMutateResult> | MutationObserverSuccessResult<TData, TError, TVariables, TOnMutateResult>;
export { MutationObserverResult }
export { MutationObserverResult as MutationObserverResult_alias_1 }

declare interface MutationObserverSuccessResult<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TOnMutateResult> {
    data: TData;
    error: null;
    variables: TVariables;
    isError: false;
    isIdle: false;
    isPending: false;
    isSuccess: true;
    status: 'success';
}
export { MutationObserverSuccessResult }
export { MutationObserverSuccessResult as MutationObserverSuccessResult_alias_1 }

declare interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TOnMutateResult = unknown> {
    mutationFn?: MutationFunction<TData, TVariables>;
    mutationKey?: MutationKey;
    onMutate?: (variables: TVariables, context: MutationFunctionContext) => Promise<TOnMutateResult> | TOnMutateResult;
    onSuccess?: (data: TData, variables: TVariables, onMutateResult: TOnMutateResult, context: MutationFunctionContext) => Promise<unknown> | unknown;
    onError?: (error: TError, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, onMutateResult: TOnMutateResult | undefined, context: MutationFunctionContext) => Promise<unknown> | unknown;
    retry?: RetryValue<TError>;
    retryDelay?: RetryDelayValue<TError>;
    networkMode?: NetworkMode;
    gcTime?: number;
    _defaulted?: boolean;
    meta?: MutationMeta;
    scope?: MutationScope;
}
export { MutationOptions }
export { MutationOptions as MutationOptions_alias_1 }

declare type MutationScope = {
    id: string;
};
export { MutationScope }
export { MutationScope as MutationScope_alias_1 }

declare interface MutationState<TData = unknown, TError = DefaultError, TVariables = unknown, TOnMutateResult = unknown> {
    context: TOnMutateResult | undefined;
    data: TData | undefined;
    error: TError | null;
    failureCount: number;
    failureReason: TError | null;
    isPaused: boolean;
    status: MutationStatus;
    variables: TVariables | undefined;
    submittedAt: number;
}
export { MutationState }
export { MutationState as MutationState_alias_1 }

declare type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
export { MutationStatus }
export { MutationStatus as MutationStatus_alias_1 }

declare type NetworkMode = 'online' | 'always' | 'offlineFirst';
export { NetworkMode }
export { NetworkMode as NetworkMode_alias_1 }

declare type NoInfer_2<T> = [T][T extends any ? 0 : never];
export { NoInfer_2 as NoInfer }
export { NoInfer_2 as NoInfer_alias_1 }

declare type NonFunctionGuard<T> = T extends Function ? never : T;

declare type NonUndefinedGuard<T> = T extends undefined ? never : T;
export { NonUndefinedGuard }
export { NonUndefinedGuard as NonUndefinedGuard_alias_1 }

declare function noop(): void;

declare function noop(): undefined;
export { noop }
export { noop as noop_alias_1 }

declare type NotifyCallback = () => void;

declare interface NotifyEvent {
    type: NotifyEventType;
}
export { NotifyEvent }
export { NotifyEvent as NotifyEvent_alias_1 }

declare interface NotifyEventMutationAdded extends NotifyEvent {
    type: 'added';
    mutation: Mutation<any, any, any, any>;
}

declare interface NotifyEventMutationObserverAdded extends NotifyEvent {
    type: 'observerAdded';
    mutation: Mutation<any, any, any, any>;
    observer: MutationObserver_2<any, any, any>;
}

declare interface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {
    type: 'observerOptionsUpdated';
    mutation?: Mutation<any, any, any, any>;
    observer: MutationObserver_2<any, any, any, any>;
}

declare interface NotifyEventMutationObserverRemoved extends NotifyEvent {
    type: 'observerRemoved';
    mutation: Mutation<any, any, any, any>;
    observer: MutationObserver_2<any, any, any>;
}

declare interface NotifyEventMutationRemoved extends NotifyEvent {
    type: 'removed';
    mutation: Mutation<any, any, any, any>;
}

declare interface NotifyEventMutationUpdated extends NotifyEvent {
    type: 'updated';
    mutation: Mutation<any, any, any, any>;
    action: Action<any, any, any, any>;
}

declare interface NotifyEventQueryAdded extends NotifyEvent {
    type: 'added';
    query: Query<any, any, any, any>;
}

declare interface NotifyEventQueryObserverAdded extends NotifyEvent {
    type: 'observerAdded';
    query: Query<any, any, any, any>;
    observer: QueryObserver<any, any, any, any, any>;
}

declare interface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {
    type: 'observerOptionsUpdated';
    query: Query<any, any, any, any>;
    observer: QueryObserver<any, any, any, any, any>;
}

declare interface NotifyEventQueryObserverRemoved extends NotifyEvent {
    type: 'observerRemoved';
    query: Query<any, any, any, any>;
    observer: QueryObserver<any, any, any, any, any>;
}

declare interface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {
    type: 'observerResultsUpdated';
    query: Query<any, any, any, any>;
}

declare interface NotifyEventQueryRemoved extends NotifyEvent {
    type: 'removed';
    query: Query<any, any, any, any>;
}

declare interface NotifyEventQueryUpdated extends NotifyEvent {
    type: 'updated';
    query: Query<any, any, any, any>;
    action: Action_alias_1<any, any>;
}

declare type NotifyEventType = 'added' | 'removed' | 'updated' | 'observerAdded' | 'observerRemoved' | 'observerResultsUpdated' | 'observerOptionsUpdated';
export { NotifyEventType }
export { NotifyEventType as NotifyEventType_alias_1 }

declare type NotifyFunction = (callback: () => void) => void;

declare const notifyManager: {
    readonly batch: <T>(callback: () => T) => T;
    /**
     * All calls to the wrapped function will be batched.
     */
    readonly batchCalls: <T extends Array<unknown>>(callback: BatchCallsCallback<T>) => BatchCallsCallback<T>;
    readonly schedule: (callback: NotifyCallback) => void;
    /**
     * Use this method to set a custom notify function.
     * This can be used to for example wrap notifications with `React.act` while running tests.
     */
    readonly setNotifyFunction: (fn: NotifyFunction) => void;
    /**
     * Use this method to set a custom function to batch notifications together into a single tick.
     * By default React Query will use the batch function provided by ReactDOM or React Native.
     */
    readonly setBatchNotifyFunction: (fn: BatchNotifyFunction) => void;
    readonly setScheduler: (fn: ScheduleFunction) => void;
};
export { notifyManager }
export { notifyManager as notifyManager_alias_1 }

declare type NotifyOnChangeProps = Array<keyof InfiniteQueryObserverResult> | 'all' | undefined | (() => Array<keyof InfiniteQueryObserverResult> | 'all' | undefined);
export { NotifyOnChangeProps }
export { NotifyOnChangeProps as NotifyOnChangeProps_alias_1 }

declare interface ObserverFetchOptions extends FetchOptions {
    throwOnError?: boolean;
}

declare type OmitKeyof<TObject, TKey extends TStrictly extends 'safely' ? keyof TObject | (string & Record<never, never>) | (number & Record<never, never>) | (symbol & Record<never, never>) : keyof TObject, TStrictly extends 'strictly' | 'safely' = 'strictly'> = Omit<TObject, TKey>;
export { OmitKeyof }
export { OmitKeyof as OmitKeyof_alias_1 }

export declare class OnlineManager extends Subscribable<Listener_2> {
    #private;
    constructor();
    protected onSubscribe(): void;
    protected onUnsubscribe(): void;
    setEventListener(setup: SetupFn_2): void;
    setOnline(online: boolean): void;
    isOnline(): boolean;
}

declare const onlineManager: OnlineManager;
export { onlineManager }
export { onlineManager as onlineManager_alias_1 }

declare type Override<TTargetA, TTargetB> = {
    [AKey in keyof TTargetA]: AKey extends keyof TTargetB ? TTargetB[AKey] : TTargetA[AKey];
};
export { Override }
export { Override as Override_alias_1 }

/**
 * Checks if key `b` partially matches with key `a`.
 */
declare function partialMatchKey(a: QueryKey, b: QueryKey): boolean;
export { partialMatchKey }
export { partialMatchKey as partialMatchKey_alias_1 }

declare interface PauseAction {
    type: 'pause';
}

declare interface PauseAction_2 {
    type: 'pause';
}

declare interface Pending<T> {
    status: 'pending';
    /**
     * Resolve the promise with a value.