@tanstack/query-core 5.0.0-alpha.86 → 5.0.0-alpha.87

package/build/legacy/queryClient-4ba6364e.d.ts

@@ -0,0 +1,916 @@
+import { Removable } from './removable.cjs';
+import { Subscribable } from './subscribable.cjs';
+
+type MutationObserverListener<TData, TError, TVariables, TContext> = (result: MutationObserverResult<TData, TError, TVariables, TContext>) => void;
+declare class MutationObserver<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends Subscribable<MutationObserverListener<TData, TError, TVariables, TContext>> {
+    #private;
+    options: MutationObserverOptions<TData, TError, TVariables, TContext>;
+    constructor(client: QueryClient, options: MutationObserverOptions<TData, TError, TVariables, TContext>);
+    protected bindMethods(): void;
+    setOptions(options?: MutationObserverOptions<TData, TError, TVariables, TContext>): void;
+    protected onUnsubscribe(): void;
+    onMutationUpdate(action: Action$1<TData, TError, TVariables, TContext>): void;
+    getCurrentResult(): MutationObserverResult<TData, TError, TVariables, TContext>;
+    reset(): void;
+    mutate(variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>): Promise<TData>;
+}
+
+interface QueryFilters {
+    /**
+     * Filter to active queries, inactive queries or all queries
+     */
+    type?: QueryTypeFilter;
+    /**
+     * Match query key exactly
+     */
+    exact?: boolean;
+    /**
+     * Include queries matching this predicate function
+     */
+    predicate?: (query: Query) => boolean;
+    /**
+     * Include queries matching this query key
+     */
+    queryKey?: QueryKey;
+    /**
+     * Include or exclude stale queries
+     */
+    stale?: boolean;
+    /**
+     * Include queries matching their fetchStatus
+     */
+    fetchStatus?: FetchStatus;
+}
+interface MutationFilters {
+    /**
+     * Match mutation key exactly
+     */
+    exact?: boolean;
+    /**
+     * Include mutations matching this predicate function
+     */
+    predicate?: (mutation: Mutation<any, any, any>) => boolean;
+    /**
+     * Include mutations matching this mutation key
+     */
+    mutationKey?: MutationKey;
+    /**
+     * Filter by mutation status
+     */
+    status?: MutationStatus;
+}
+type DataUpdateFunction<TInput, TOutput> = (input: TInput) => TOutput;
+type Updater<TInput, TOutput> = TOutput | DataUpdateFunction<TInput, TOutput>;
+type QueryTypeFilter = 'all' | 'active' | 'inactive';
+declare const isServer: boolean;
+declare function noop(): undefined;
+declare function functionalUpdate<TInput, TOutput>(updater: Updater<TInput, TOutput>, input: TInput): TOutput;
+declare function isValidTimeout(value: unknown): value is number;
+declare function timeUntilStale(updatedAt: number, staleTime?: number): number;
+declare function matchQuery(filters: QueryFilters, query: Query<any, any, any, any>): boolean;
+declare function matchMutation(filters: MutationFilters, mutation: Mutation<any, any>): boolean;
+declare function hashQueryKeyByOptions<TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: QueryOptions<any, any, any, TQueryKey>): string;
+/**
+ * Default query & mutation keys hash function.
+ * Hashes the value into a stable hash.
+ */
+declare function hashKey(queryKey: QueryKey | MutationKey): string;
+/**
+ * Checks if key `b` partially matches with key `a`.
+ */
+declare function partialMatchKey(a: QueryKey, b: QueryKey): boolean;
+/**
+ * This function returns `a` if `b` is deeply equal.
+ * If not, it will replace any deeply equal children of `b` with those of `a`.
+ * This can be used for structural sharing between JSON values for example.
+ */
+declare function replaceEqualDeep<T>(a: unknown, b: T): T;
+/**
+ * Shallow compare objects. Only works with objects that always have the same properties.
+ */
+declare function shallowEqualObjects<T>(a: T, b: T): boolean;
+declare function isPlainArray(value: unknown): boolean;
+declare function isPlainObject(o: any): o is Object;
+declare function sleep(timeout: number): Promise<void>;
+/**
+ * Schedules a microtask.
+ * This can be useful to schedule state updates after rendering.
+ */
+declare function scheduleMicrotask(callback: () => void): void;
+declare function replaceData<TData, TOptions extends QueryOptions<any, any, any, any>>(prevData: TData | undefined, data: TData, options: TOptions): TData;
+declare function keepPreviousData<T>(previousData: T | undefined): T | undefined;
+declare function addToEnd<T>(items: T[], item: T, max?: number): T[];
+declare function addToStart<T>(items: T[], item: T, max?: number): T[];
+
+interface MutationCacheConfig {
+    onError?: (error: DefaultError, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => Promise<unknown> | unknown;
+    onSuccess?: (data: unknown, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => Promise<unknown> | unknown;
+    onMutate?: (variables: unknown, mutation: Mutation<unknown, unknown, unknown>) => Promise<unknown> | unknown;
+    onSettled?: (data: unknown | undefined, error: DefaultError | null, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => Promise<unknown> | unknown;
+}
+interface NotifyEventMutationAdded extends NotifyEvent {
+    type: 'added';
+    mutation: Mutation<any, any, any, any>;
+}
+interface NotifyEventMutationRemoved extends NotifyEvent {
+    type: 'removed';
+    mutation: Mutation<any, any, any, any>;
+}
+interface NotifyEventMutationObserverAdded extends NotifyEvent {
+    type: 'observerAdded';
+    mutation: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationObserverRemoved extends NotifyEvent {
+    type: 'observerRemoved';
+    mutation: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {
+    type: 'observerOptionsUpdated';
+    mutation?: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any, any>;
+}
+interface NotifyEventMutationUpdated extends NotifyEvent {
+    type: 'updated';
+    mutation: Mutation<any, any, any, any>;
+    action: Action$1<any, any, any, any>;
+}
+type MutationCacheNotifyEvent = NotifyEventMutationAdded | NotifyEventMutationRemoved | NotifyEventMutationObserverAdded | NotifyEventMutationObserverRemoved | NotifyEventMutationObserverOptionsUpdated | NotifyEventMutationUpdated;
+type MutationCacheListener = (event: MutationCacheNotifyEvent) => void;
+declare class MutationCache extends Subscribable<MutationCacheListener> {
+    #private;
+    config: MutationCacheConfig;
+    constructor(config?: MutationCacheConfig);
+    build<TData, TError, TVariables, TContext>(client: QueryClient, options: MutationOptions<TData, TError, TVariables, TContext>, state?: MutationState<TData, TError, TVariables, TContext>): Mutation<TData, TError, TVariables, TContext>;
+    add(mutation: Mutation<any, any, any, any>): void;
+    remove(mutation: Mutation<any, any, any, any>): void;
+    clear(): void;
+    getAll(): Mutation[];
+    find<TData = unknown, TError = DefaultError, TVariables = any, TContext = unknown>(filters: MutationFilters): Mutation<TData, TError, TVariables, TContext> | undefined;
+    findAll(filters?: MutationFilters): Mutation[];
+    notify(event: MutationCacheNotifyEvent): void;
+    resumePausedMutations(): Promise<unknown>;
+}
+
+interface MutationConfig<TData, TError, TVariables, TContext> {
+    mutationId: number;
+    mutationCache: MutationCache;
+    options: MutationOptions<TData, TError, TVariables, TContext>;
+    defaultOptions?: MutationOptions<TData, TError, TVariables, TContext>;
+    state?: MutationState<TData, TError, TVariables, TContext>;
+}
+interface MutationState<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    context: TContext | undefined;
+    data: TData | undefined;
+    error: TError | null;
+    failureCount: number;
+    failureReason: TError | null;
+    isPaused: boolean;
+    status: MutationStatus;
+    variables: TVariables | undefined;
+    submittedAt: number;
+}
+interface FailedAction$1<TError> {
+    type: 'failed';
+    failureCount: number;
+    error: TError | null;
+}
+interface PendingAction<TVariables, TContext> {
+    type: 'pending';
+    variables?: TVariables;
+    context?: TContext;
+}
+interface SuccessAction$1<TData> {
+    type: 'success';
+    data: TData;
+}
+interface ErrorAction$1<TError> {
+    type: 'error';
+    error: TError;
+}
+interface PauseAction$1 {
+    type: 'pause';
+}
+interface ContinueAction$1 {
+    type: 'continue';
+}
+type Action$1<TData, TError, TVariables, TContext> = ContinueAction$1 | ErrorAction$1<TError> | FailedAction$1<TError> | PendingAction<TVariables, TContext> | PauseAction$1 | SuccessAction$1<TData>;
+declare class Mutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends Removable {
+    #private;
+    state: MutationState<TData, TError, TVariables, TContext>;
+    options: MutationOptions<TData, TError, TVariables, TContext>;
+    readonly mutationId: number;
+    constructor(config: MutationConfig<TData, TError, TVariables, TContext>);
+    setOptions(options?: MutationOptions<TData, TError, TVariables, TContext>): void;
+    get meta(): MutationMeta | undefined;
+    addObserver(observer: MutationObserver<any, any, any, any>): void;
+    removeObserver(observer: MutationObserver<any, any, any, any>): void;
+    protected optionalRemove(): void;
+    continue(): Promise<unknown>;
+    execute(variables: TVariables): Promise<TData>;
+}
+declare function getDefaultState<TData, TError, TVariables, TContext>(): MutationState<TData, TError, TVariables, TContext>;
+
+interface RetryerConfig<TData = unknown, TError = DefaultError> {
+    fn: () => TData | Promise<TData>;
+    abort?: () => void;
+    onError?: (error: TError) => void;
+    onSuccess?: (data: TData) => void;
+    onFail?: (failureCount: number, error: TError) => void;
+    onPause?: () => void;
+    onContinue?: () => void;
+    retry?: RetryValue<TError>;
+    retryDelay?: RetryDelayValue<TError>;
+    networkMode: NetworkMode | undefined;
+}
+interface Retryer<TData = unknown> {
+    promise: Promise<TData>;
+    cancel: (cancelOptions?: CancelOptions) => void;
+    continue: () => Promise<unknown>;
+    cancelRetry: () => void;
+    continueRetry: () => void;
+}
+type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>;
+type ShouldRetryFunction<TError = DefaultError> = (failureCount: number, error: TError) => boolean;
+type RetryDelayValue<TError> = number | RetryDelayFunction<TError>;
+type RetryDelayFunction<TError = DefaultError> = (failureCount: number, error: TError) => number;
+declare function canFetch(networkMode: NetworkMode | undefined): boolean;
+declare class CancelledError {
+    revert?: boolean;
+    silent?: boolean;
+    constructor(options?: CancelOptions);
+}
+declare function isCancelledError(value: any): value is CancelledError;
+declare function createRetryer<TData = unknown, TError = DefaultError>(config: RetryerConfig<TData, TError>): Retryer<TData>;
+
+interface Register {
+}
+type DefaultError = Register extends {
+    defaultError: infer TError;
+} ? TError : Error;
+type QueryKey = readonly unknown[];
+type QueryFunction<T = unknown, TQueryKey extends QueryKey = QueryKey, TPageParam = never> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T>;
+type QueryFunctionContext<TQueryKey extends QueryKey = QueryKey, TPageParam = never> = [TPageParam] extends [never] ? {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+    meta: QueryMeta | undefined;
+} : {
+    queryKey: TQueryKey;
+    signal: AbortSignal;
+    pageParam: TPageParam;
+    direction: FetchDirection;
+    meta: QueryMeta | undefined;
+};
+type InitialDataFunction<T> = () => T | undefined;
+type NonFunctionGuard<T> = T extends Function ? never : T;
+type PlaceholderDataFunction<TQueryFnData = unknown, TError = DefaultError, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = (previousData: TQueryData | undefined, previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined) => TQueryData | undefined;
+type QueriesPlaceholderDataFunction<TQueryData> = () => TQueryData | undefined;
+type QueryKeyHashFunction<TQueryKey extends QueryKey> = (queryKey: TQueryKey) => string;
+type GetPreviousPageParamFunction<TPageParam, TQueryFnData = unknown> = (firstPage: TQueryFnData, allPages: TQueryFnData[], firstPageParam: TPageParam, allPageParams: TPageParam[]) => TPageParam | undefined;
+type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (lastPage: TQueryFnData, allPages: TQueryFnData[], lastPageParam: TPageParam, allPageParams: TPageParam[]) => TPageParam | undefined;
+interface InfiniteData<TData> {
+    pages: TData[];
+    pageParams: unknown[];
+}
+type QueryMeta = Register extends {
+    queryMeta: infer TQueryMeta;
+} ? TQueryMeta extends Record<string, unknown> ? TQueryMeta : Record<string, unknown> : Record<string, unknown>;
+type NetworkMode = 'online' | 'always' | 'offlineFirst';
+interface QueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> {
+    /**
+     * 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;
+    queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam>;
+    queryHash?: string;
+    queryKey?: TQueryKey;
+    queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>;
+    initialData?: TData | InitialDataFunction<TData>;
+    initialDataUpdatedAt?: number | (() => number | undefined);
+    behavior?: QueryBehavior<TQueryFnData, TError, TData, TQueryKey>;
+    /**
+     * 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: TData | undefined, newData: TData) => TData);
+    _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;
+}
+interface DefaultPageParam<TPageParam = unknown> {
+    defaultPageParam: TPageParam;
+}
+interface InfiniteQueryPageParamsOptions<TQueryFnData = unknown, TPageParam = unknown> extends DefaultPageParam<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>;
+}
+type ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey extends QueryKey> = boolean | ((error: TError, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean);
+interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam> {
+    /**
+     * 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 data 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, query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => 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' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => 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' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => 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' | ((query: Query<TQueryFnData, TError, TQueryData, TQueryKey>) => boolean | 'always');
+    /**
+     * If set to `false`, the query will not be retried on mount if it contains an error.
+     * Defaults to `true`.
+     */
+    retryOnMount?: boolean;
+    /**
+     * If set, the component will only re-render if any of the listed properties change.
+     * When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.
+     * When set to `'all'`, the component will re-render whenever a query is updated.
+     * By default, access to properties will be tracked, and the component will only re-render when one of the tracked properties change.
+     */
+    notifyOnChangeProps?: Array<keyof InfiniteQueryObserverResult> | 'all';
+    /**
+     * 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<TQueryFnData, TError, TQueryData, TQueryKey>;
+    /**
+     * 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<NonFunctionGuard<TQueryData>>;
+    _optimisticResults?: 'optimistic' | 'isRestoring';
+}
+type WithRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+type DefaultedQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = WithRequired<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'throwOnError' | 'refetchOnReconnect'>;
+interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends QueryObserverOptions<TQueryFnData, TError, TData, InfiniteData<TQueryData>, TQueryKey, TPageParam>, InfiniteQueryPageParamsOptions<TQueryFnData, TPageParam> {
+}
+type DefaultedInfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = WithRequired<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'throwOnError' | 'refetchOnReconnect'>;
+interface FetchQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends WithRequired<QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, 'queryKey'> {
+    /**
+     * The time in milliseconds after data is considered stale.
+     * If the data is fresh it will be returned from the cache.
+     */
+    staleTime?: number;
+}
+type FetchInfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> = {
+    pages?: never;
+    getNextPageParam?: never;
+} | {
+    pages: number;
+    getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>;
+};
+type FetchInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = FetchQueryOptions<TQueryFnData, TError, InfiniteData<TData>, TQueryKey, TPageParam> & DefaultPageParam<TPageParam> & FetchInfiniteQueryPages<TQueryFnData, TPageParam>;
+interface ResultOptions {
+    throwOnError?: boolean;
+}
+interface RefetchOptions extends ResultOptions {
+    cancelRefetch?: boolean;
+}
+interface InvalidateQueryFilters extends QueryFilters {
+    refetchType?: QueryTypeFilter | 'none';
+}
+interface RefetchQueryFilters extends QueryFilters {
+}
+interface InvalidateOptions extends RefetchOptions {
+}
+interface ResetOptions extends RefetchOptions {
+}
+interface FetchNextPageOptions extends ResultOptions {
+    cancelRefetch?: boolean;
+}
+interface FetchPreviousPageOptions extends ResultOptions {
+    cancelRefetch?: boolean;
+}
+type QueryStatus = 'pending' | 'error' | 'success';
+type FetchStatus = 'fetching' | 'paused' | 'idle';
+interface QueryObserverBaseResult<TData = unknown, TError = DefaultError> {
+    data: TData | undefined;
+    dataUpdatedAt: number;
+    error: TError | null;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: TError | null;
+    errorUpdateCount: number;
+    isError: boolean;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isPending: boolean;
+    isLoadingError: boolean;
+    /**
+     * @deprecated isInitialLoading is being deprecated in favor of isLoading
+     * and will be removed in the next major version.
+     */
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isPlaceholderData: boolean;
+    isRefetchError: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isSuccess: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<TData, TError>>;
+    status: QueryStatus;
+    fetchStatus: FetchStatus;
+}
+interface QueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: 'pending';
+}
+interface QueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: TError;
+    isError: true;
+    isPending: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: 'error';
+}
+interface QueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: TData;
+    error: TError;
+    isError: true;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: 'error';
+}
+interface QueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    data: TData;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: 'success';
+}
+type DefinedQueryObserverResult<TData = unknown, TError = DefaultError> = QueryObserverRefetchErrorResult<TData, TError> | QueryObserverSuccessResult<TData, TError>;
+type QueryObserverResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError> | QueryObserverLoadingErrorResult<TData, TError> | QueryObserverLoadingResult<TData, TError>;
+interface InfiniteQueryObserverBaseResult<TData = unknown, TError = DefaultError> extends QueryObserverBaseResult<TData, TError> {
+    fetchNextPage: (options?: FetchNextPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+    fetchPreviousPage: (options?: FetchPreviousPageOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    isFetchingNextPage: boolean;
+    isFetchingPreviousPage: boolean;
+}
+interface InfiniteQueryObserverLoadingResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    status: 'pending';
+}
+interface InfiniteQueryObserverLoadingErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: undefined;
+    error: TError;
+    isError: true;
+    isPending: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    status: 'error';
+}
+interface InfiniteQueryObserverRefetchErrorResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: TData;
+    error: TError;
+    isError: true;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    status: 'error';
+}
+interface InfiniteQueryObserverSuccessResult<TData = unknown, TError = DefaultError> extends InfiniteQueryObserverBaseResult<TData, TError> {
+    data: TData;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    status: 'success';
+}
+type InfiniteQueryObserverResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverLoadingErrorResult<TData, TError> | InfiniteQueryObserverLoadingResult<TData, TError> | InfiniteQueryObserverRefetchErrorResult<TData, TError> | InfiniteQueryObserverSuccessResult<TData, TError>;
+type MutationKey = readonly unknown[];
+type MutationStatus = 'idle' | 'pending' | 'success' | 'error';
+type MutationMeta = Register extends {
+    mutationMeta: infer TMutationMeta;
+} ? TMutationMeta : Record<string, unknown>;
+type MutationFunction<TData = unknown, TVariables = unknown> = (variables: TVariables) => Promise<TData>;
+interface MutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    mutationFn?: MutationFunction<TData, TVariables>;
+    mutationKey?: MutationKey;
+    onMutate?: (variables: TVariables) => Promise<TContext | undefined> | TContext | undefined;
+    onSuccess?: (data: TData, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;
+    onError?: (error: TError, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;
+    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context: TContext | undefined) => Promise<unknown> | unknown;
+    retry?: RetryValue<TError>;
+    retryDelay?: RetryDelayValue<TError>;
+    networkMode?: NetworkMode;
+    gcTime?: number;
+    _defaulted?: boolean;
+    meta?: MutationMeta;
+}
+interface MutationObserverOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationOptions<TData, TError, TVariables, TContext> {
+    throwOnError?: boolean | ((error: TError) => boolean);
+}
+interface MutateOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> {
+    onSuccess?: (data: TData, variables: TVariables, context: TContext) => void;
+    onError?: (error: TError, variables: TVariables, context: TContext | undefined) => void;
+    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context: TContext | undefined) => void;
+}
+type MutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (variables: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>) => Promise<TData>;
+interface MutationObserverBaseResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationState<TData, TError, TVariables, TContext> {
+    isError: boolean;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    mutate: MutateFunction<TData, TError, TVariables, TContext>;
+    reset: () => void;
+}
+interface MutationObserverIdleResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: 'idle';
+}
+interface MutationObserverLoadingResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: undefined;
+    variables: TVariables;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: 'pending';
+}
+interface MutationObserverErrorResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: undefined;
+    error: TError;
+    variables: TVariables;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: 'error';
+}
+interface MutationObserverSuccessResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends MutationObserverBaseResult<TData, TError, TVariables, TContext> {
+    data: TData;
+    error: null;
+    variables: TVariables;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: 'success';
+}
+type MutationObserverResult<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutationObserverIdleResult<TData, TError, TVariables, TContext> | MutationObserverLoadingResult<TData, TError, TVariables, TContext> | MutationObserverErrorResult<TData, TError, TVariables, TContext> | MutationObserverSuccessResult<TData, TError, TVariables, TContext>;
+interface QueryClientConfig {
+    queryCache?: QueryCache;
+    mutationCache?: MutationCache;
+    defaultOptions?: DefaultOptions;
+}
+interface DefaultOptions<TError = DefaultError> {
+    queries?: QueryObserverOptions<unknown, TError>;
+    mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>;
+}
+interface CancelOptions {
+    revert?: boolean;
+    silent?: boolean;
+}
+interface SetDataOptions {
+    updatedAt?: number;
+}
+type NotifyEventType = 'added' | 'removed' | 'updated' | 'observerAdded' | 'observerRemoved' | 'observerResultsUpdated' | 'observerOptionsUpdated';
+interface NotifyEvent {
+    type: NotifyEventType;
+}
+
+type QueryObserverListener<TData, TError> = (result: QueryObserverResult<TData, TError>) => void;
+interface NotifyOptions {
+    listeners?: boolean;
+}
+interface ObserverFetchOptions extends FetchOptions {
+    throwOnError?: boolean;
+}
+declare class QueryObserver<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Subscribable<QueryObserverListener<TData, TError>> {
+    #private;
+    options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    constructor(client: QueryClient, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
+    protected bindMethods(): void;
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+    shouldFetchOnReconnect(): boolean;
+    shouldFetchOnWindowFocus(): boolean;
+    destroy(): void;
+    setOptions(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, notifyOptions?: NotifyOptions): void;
+    getOptimisticResult(options: DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+    getCurrentResult(): QueryObserverResult<TData, TError>;
+    trackResult(result: QueryObserverResult<TData, TError>): QueryObserverResult<TData, TError>;
+    getCurrentQuery(): Query<TQueryFnData, TError, TQueryData, TQueryKey>;
+    refetch({ ...options }?: RefetchOptions): Promise<QueryObserverResult<TData, TError>>;
+    fetchOptimistic(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Promise<QueryObserverResult<TData, TError>>;
+    protected fetch(fetchOptions: ObserverFetchOptions): Promise<QueryObserverResult<TData, TError>>;
+    protected createResult(query: Query<TQueryFnData, TError, TQueryData, TQueryKey>, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+    updateResult(notifyOptions?: NotifyOptions): void;
+    onQueryUpdate(): void;
+}
+
+interface QueryConfig<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+    cache: QueryCache;
+    queryKey: TQueryKey;
+    queryHash: string;
+    options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    defaultOptions?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    state?: QueryState<TData, TError>;
+}
+interface QueryState<TData = unknown, TError = DefaultError> {
+    data: TData | undefined;
+    dataUpdateCount: number;
+    dataUpdatedAt: number;
+    error: TError | null;
+    errorUpdateCount: number;
+    errorUpdatedAt: number;
+    fetchFailureCount: number;
+    fetchFailureReason: TError | null;
+    fetchMeta: FetchMeta | null;
+    isInvalidated: boolean;
+    status: QueryStatus;
+    fetchStatus: FetchStatus;
+}
+interface FetchContext<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+    fetchFn: () => unknown | Promise<unknown>;
+    fetchOptions?: FetchOptions;
+    signal: AbortSignal;
+    options: QueryOptions<TQueryFnData, TError, TData, any>;
+    queryKey: TQueryKey;
+    state: QueryState<TData, TError>;
+}
+interface QueryBehavior<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    onFetch: (context: FetchContext<TQueryFnData, TError, TData, TQueryKey>) => void;
+}
+type FetchDirection = 'forward' | 'backward';
+interface FetchMeta {
+    fetchMore?: {
+        direction: FetchDirection;
+    };
+}
+interface FetchOptions {
+    cancelRefetch?: boolean;
+    meta?: FetchMeta;
+}
+interface FailedAction<TError> {
+    type: 'failed';
+    failureCount: number;
+    error: TError;
+}
+interface FetchAction {
+    type: 'fetch';
+    meta?: FetchMeta;
+}
+interface SuccessAction<TData> {
+    data: TData | undefined;
+    type: 'success';
+    dataUpdatedAt?: number;
+    manual?: boolean;
+}
+interface ErrorAction<TError> {
+    type: 'error';
+    error: TError;
+}
+interface InvalidateAction {
+    type: 'invalidate';
+}
+interface PauseAction {
+    type: 'pause';
+}
+interface ContinueAction {
+    type: 'continue';
+}
+interface SetStateAction<TData, TError> {
+    type: 'setState';
+    state: Partial<QueryState<TData, TError>>;
+    setStateOptions?: SetStateOptions;
+}
+type Action<TData, TError> = ContinueAction | ErrorAction<TError> | FailedAction<TError> | FetchAction | InvalidateAction | PauseAction | SetStateAction<TData, TError> | SuccessAction<TData>;
+interface SetStateOptions {
+    meta?: any;
+}
+declare class Query<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Removable {
+    #private;
+    queryKey: TQueryKey;
+    queryHash: string;
+    options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    state: QueryState<TData, TError>;
+    isFetchingOptimistic?: boolean;
+    constructor(config: QueryConfig<TQueryFnData, TError, TData, TQueryKey>);
+    get meta(): QueryMeta | undefined;
+    protected optionalRemove(): void;
+    setData(newData: TData, options?: SetDataOptions & {
+        manual: boolean;
+    }): TData;
+    setState(state: Partial<QueryState<TData, TError>>, setStateOptions?: SetStateOptions): void;
+    cancel(options?: CancelOptions): Promise<void>;
+    destroy(): void;
+    reset(): void;
+    isActive(): boolean;
+    isDisabled(): boolean;
+    isStale(): boolean;
+    isStaleByTime(staleTime?: number): boolean;
+    onFocus(): void;
+    onOnline(): void;
+    addObserver(observer: QueryObserver<any, any, any, any, any>): void;
+    removeObserver(observer: QueryObserver<any, any, any, any, any>): void;
+    getObserversCount(): number;
+    invalidate(): void;
+    fetch(options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, fetchOptions?: FetchOptions): Promise<TData>;
+}
+
+interface QueryCacheConfig {
+    onError?: (error: DefaultError, query: Query<unknown, unknown, unknown>) => void;
+    onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void;
+    onSettled?: (data: unknown | undefined, error: DefaultError | null, query: Query<unknown, unknown, unknown>) => void;
+}
+interface NotifyEventQueryAdded extends NotifyEvent {
+    type: 'added';
+    query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryRemoved extends NotifyEvent {
+    type: 'removed';
+    query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryUpdated extends NotifyEvent {
+    type: 'updated';
+    query: Query<any, any, any, any>;
+    action: Action<any, any>;
+}
+interface NotifyEventQueryObserverAdded extends NotifyEvent {
+    type: 'observerAdded';
+    query: Query<any, any, any, any>;
+    observer: QueryObserver<any, any, any, any, any>;
+}
+interface NotifyEventQueryObserverRemoved extends NotifyEvent {
+    type: 'observerRemoved';
+    query: Query<any, any, any, any>;
+    observer: QueryObserver<any, any, any, any, any>;
+}
+interface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {
+    type: 'observerResultsUpdated';
+    query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {
+    type: 'observerOptionsUpdated';
+    query: Query<any, any, any, any>;
+    observer: QueryObserver<any, any, any, any, any>;
+}
+type QueryCacheNotifyEvent = NotifyEventQueryAdded | NotifyEventQueryRemoved | NotifyEventQueryUpdated | NotifyEventQueryObserverAdded | NotifyEventQueryObserverRemoved | NotifyEventQueryObserverResultsUpdated | NotifyEventQueryObserverOptionsUpdated;
+type QueryCacheListener = (event: QueryCacheNotifyEvent) => void;
+interface QueryStore {
+    has: (queryKey: string) => boolean;
+    set: (queryKey: string, query: Query) => void;
+    get: (queryKey: string) => Query | undefined;
+    delete: (queryKey: string) => void;
+    values: () => IterableIterator<Query>;
+}
+declare class QueryCache extends Subscribable<QueryCacheListener> {
+    #private;
+    config: QueryCacheConfig;
+    constructor(config?: QueryCacheConfig);
+    build<TQueryFnData, TError, TData, TQueryKey extends QueryKey>(client: QueryClient, options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>, state?: QueryState<TData, TError>): Query<TQueryFnData, TError, TData, TQueryKey>;
+    add(query: Query<any, any, any, any>): void;
+    remove(query: Query<any, any, any, any>): void;
+    clear(): void;
+    get<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryHash: string): Query<TQueryFnData, TError, TData, TQueryKey> | undefined;
+    getAll(): Query[];
+    find<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData>(filters: WithRequired<QueryFilters, 'queryKey'>): Query<TQueryFnData, TError, TData> | undefined;
+    findAll(filters?: QueryFilters): Query[];
+    notify(event: QueryCacheNotifyEvent): void;
+    onFocus(): void;
+    onOnline(): void;
+}
+
+declare class QueryClient {
+    #private;
+    constructor(config?: QueryClientConfig);
+    mount(): void;
+    unmount(): void;
+    isFetching(filters?: QueryFilters): number;
+    isMutating(filters?: MutationFilters): number;
+    getQueryData<TQueryFnData = unknown>(queryKey: QueryKey): TQueryFnData | undefined;
+    ensureQueryData<TQueryFnData, TError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    getQueriesData<TQueryFnData = unknown>(filters: QueryFilters): [QueryKey, TQueryFnData | undefined][];
+    setQueryData<TQueryFnData>(queryKey: QueryKey, updater: Updater<TQueryFnData | undefined, TQueryFnData | undefined>, options?: SetDataOptions): TQueryFnData | undefined;
+    setQueriesData<TQueryFnData>(filters: QueryFilters, updater: Updater<TQueryFnData | undefined, TQueryFnData | undefined>, options?: SetDataOptions): [QueryKey, TQueryFnData | undefined][];
+    getQueryState<TQueryFnData = unknown, TError = DefaultError>(queryKey: QueryKey): QueryState<TQueryFnData, TError> | undefined;
+    removeQueries(filters?: QueryFilters): void;
+    resetQueries(filters?: QueryFilters, options?: ResetOptions): Promise<void>;
+    cancelQueries(filters?: QueryFilters, cancelOptions?: CancelOptions): Promise<void>;
+    invalidateQueries(filters?: InvalidateQueryFilters, options?: InvalidateOptions): Promise<void>;
+    refetchQueries(filters?: RefetchQueryFilters, options?: RefetchOptions): Promise<void>;
+    fetchQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<TData>;
+    prefetchQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    fetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<InfiniteData<TData>>;
+    prefetchInfiniteQuery<TQueryFnData, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>): Promise<void>;
+    resumePausedMutations(): Promise<unknown>;
+    getQueryCache(): QueryCache;
+    getMutationCache(): MutationCache;
+    getDefaultOptions(): DefaultOptions;
+    setDefaultOptions(options: DefaultOptions): void;
+    setQueryDefaults(queryKey: QueryKey, options: Partial<Omit<QueryObserverOptions<unknown, any, any, any>, 'queryKey'>>): void;
+    getQueryDefaults(queryKey: QueryKey): QueryObserverOptions<any, any, any, any, any>;
+    setMutationDefaults(mutationKey: MutationKey, options: Omit<MutationObserverOptions<any, any, any, any>, 'mutationKey'>): void;
+    getMutationDefaults(mutationKey: MutationKey): MutationObserverOptions<any, any, any, any>;
+    defaultQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never>(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam> | DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): DefaultedQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    defaultMutationOptions<T extends MutationOptions<any, any, any, any>>(options?: T): T;
+    clear(): void;
+}
+
+export { QueryStatus as $, InfiniteQueryPageParamsOptions as A, QueryObserverOptions as B, CancelledError as C, DefaultError as D, DefaultedQueryObserverOptions as E, InfiniteQueryObserverOptions as F, GetPreviousPageParamFunction as G, DefaultedInfiniteQueryObserverOptions as H, InitialDataFunction as I, FetchQueryOptions as J, FetchInfiniteQueryOptions as K, ResultOptions as L, MutationCache as M, NetworkMode as N, RefetchOptions as O, PlaceholderDataFunction as P, QueryCache as Q, Register as R, InvalidateQueryFilters as S, ThrowOnError as T, Updater as U, RefetchQueryFilters as V, WithRequired as W, InvalidateOptions as X, ResetOptions as Y, FetchNextPageOptions as Z, FetchPreviousPageOptions as _, QueryCacheNotifyEvent as a, FetchMeta as a$, FetchStatus as a0, QueryObserverBaseResult as a1, QueryObserverLoadingResult as a2, QueryObserverLoadingErrorResult as a3, QueryObserverRefetchErrorResult as a4, QueryObserverSuccessResult as a5, DefinedQueryObserverResult as a6, QueryObserverResult as a7, InfiniteQueryObserverBaseResult as a8, InfiniteQueryObserverLoadingResult as a9, NotifyOptions as aA, DataUpdateFunction as aB, QueryTypeFilter as aC, noop as aD, functionalUpdate as aE, isValidTimeout as aF, timeUntilStale as aG, matchMutation as aH, hashQueryKeyByOptions as aI, partialMatchKey as aJ, shallowEqualObjects as aK, isPlainArray as aL, isPlainObject as aM, sleep as aN, scheduleMicrotask as aO, replaceData as aP, addToEnd as aQ, addToStart as aR, Action$1 as aS, getDefaultState as aT, Retryer as aU, RetryValue as aV, RetryDelayValue as aW, canFetch as aX, createRetryer as aY, FetchContext as aZ, FetchDirection as a_, InfiniteQueryObserverLoadingErrorResult as aa, InfiniteQueryObserverRefetchErrorResult as ab, InfiniteQueryObserverSuccessResult as ac, InfiniteQueryObserverResult as ad, MutationKey as ae, MutationStatus as af, MutationMeta as ag, MutationFunction as ah, MutationOptions as ai, MutationObserverOptions as aj, MutateOptions as ak, MutateFunction as al, MutationObserverBaseResult as am, MutationObserverIdleResult as an, MutationObserverLoadingResult as ao, MutationObserverErrorResult as ap, MutationObserverSuccessResult as aq, MutationObserverResult as ar, QueryClientConfig as as, DefaultOptions as at, CancelOptions as au, SetDataOptions as av, NotifyEventType as aw, NotifyEvent as ax, QueryBehavior as ay, ObserverFetchOptions as az, QueryClient as b, FetchOptions as b0, Action as b1, SetStateOptions as b2, QueryStore as b3, QueryObserver as c, MutationObserver as d, MutationFilters as e, QueryFilters as f, isCancelledError as g, hashKey as h, isServer as i, Query as j, keepPreviousData as k, QueryState as l, matchQuery as m, Mutation as n, MutationState as o, QueryKey as p, QueryFunction as q, replaceEqualDeep as r, QueryFunctionContext as s, QueriesPlaceholderDataFunction as t, QueryKeyHashFunction as u, GetNextPageParamFunction as v, InfiniteData as w, QueryMeta as x, QueryOptions as y, DefaultPageParam as z };