@tanstack/query-broadcast-client-experimental 4.0.0 → 4.0.5

package/build/types/query-core/src/mutationObserver.d.ts

@@ -0,0 +1,23 @@
+import { Action } from './mutation';
+import type { QueryClient } from './queryClient';
+import { Subscribable } from './subscribable';
+import type { MutateOptions, MutationObserverResult, MutationObserverOptions } from './types';
+declare type MutationObserverListener<TData, TError, TVariables, TContext> = (result: MutationObserverResult<TData, TError, TVariables, TContext>) => void;
+export declare class MutationObserver<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends Subscribable<MutationObserverListener<TData, TError, TVariables, TContext>> {
+    options: MutationObserverOptions<TData, TError, TVariables, TContext>;
+    private client;
+    private currentResult;
+    private currentMutation?;
+    private mutateOptions?;
+    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<TData, TError, TVariables, TContext>): void;
+    getCurrentResult(): MutationObserverResult<TData, TError, TVariables, TContext>;
+    reset(): void;
+    mutate(variables?: TVariables, options?: MutateOptions<TData, TError, TVariables, TContext>): Promise<TData>;
+    private updateResult;
+    private notify;
+}
+export {};

package/build/types/query-core/src/notifyManager.d.ts

@@ -0,0 +1,18 @@
+declare type NotifyCallback = () => void;
+declare type NotifyFunction = (callback: () => void) => void;
+declare type BatchNotifyFunction = (callback: () => void) => void;
+export declare function createNotifyManager(): {
+    readonly batch: <T>(callback: () => T) => T;
+    readonly batchCalls: <T_1 extends Function>(callback: T_1) => T_1;
+    readonly schedule: (callback: NotifyCallback) => void;
+    readonly setNotifyFunction: (fn: NotifyFunction) => void;
+    readonly setBatchNotifyFunction: (fn: BatchNotifyFunction) => void;
+};
+export declare const notifyManager: {
+    readonly batch: <T>(callback: () => T) => T;
+    readonly batchCalls: <T_1 extends Function>(callback: T_1) => T_1;
+    readonly schedule: (callback: NotifyCallback) => void;
+    readonly setNotifyFunction: (fn: NotifyFunction) => void;
+    readonly setBatchNotifyFunction: (fn: BatchNotifyFunction) => void;
+};
+export {};

package/build/types/query-core/src/onlineManager.d.ts

@@ -0,0 +1,16 @@
+import { Subscribable } from './subscribable';
+declare type SetupFn = (setOnline: (online?: boolean) => void) => (() => void) | undefined;
+export declare class OnlineManager extends Subscribable {
+    private online?;
+    private cleanup?;
+    private setup;
+    constructor();
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+    setEventListener(setup: SetupFn): void;
+    setOnline(online?: boolean): void;
+    onOnline(): void;
+    isOnline(): boolean;
+}
+export declare const onlineManager: OnlineManager;
+export {};

package/build/types/query-core/src/queriesObserver.d.ts

@@ -0,0 +1,23 @@
+import type { QueryObserverOptions, QueryObserverResult } from './types';
+import type { QueryClient } from './queryClient';
+import { NotifyOptions } from './queryObserver';
+import { Subscribable } from './subscribable';
+declare type QueriesObserverListener = (result: QueryObserverResult[]) => void;
+export declare class QueriesObserver extends Subscribable<QueriesObserverListener> {
+    private client;
+    private result;
+    private queries;
+    private observers;
+    private observersMap;
+    constructor(client: QueryClient, queries?: QueryObserverOptions[]);
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+    destroy(): void;
+    setQueries(queries: QueryObserverOptions[], notifyOptions?: NotifyOptions): void;
+    getCurrentResult(): QueryObserverResult[];
+    getOptimisticResult(queries: QueryObserverOptions[]): QueryObserverResult[];
+    private findMatchingObservers;
+    private onUpdate;
+    private notify;
+}
+export {};

package/build/types/query-core/src/query.d.ts

@@ -0,0 +1,119 @@
+import type { QueryKey, QueryOptions, QueryStatus, QueryMeta, CancelOptions, SetDataOptions, FetchStatus } from './types';
+import type { QueryCache } from './queryCache';
+import type { QueryObserver } from './queryObserver';
+import { Logger } from './logger';
+import { Removable } from './removable';
+interface QueryConfig<TQueryFnData, TError, TData, TQueryKey extends QueryKey = QueryKey> {
+    cache: QueryCache;
+    queryKey: TQueryKey;
+    queryHash: string;
+    logger?: Logger;
+    options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    defaultOptions?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    state?: QueryState<TData, TError>;
+    meta: QueryMeta | undefined;
+}
+export interface QueryState<TData = unknown, TError = unknown> {
+    data: TData | undefined;
+    dataUpdateCount: number;
+    dataUpdatedAt: number;
+    error: TError | null;
+    errorUpdateCount: number;
+    errorUpdatedAt: number;
+    fetchFailureCount: number;
+    fetchMeta: any;
+    isInvalidated: boolean;
+    status: QueryStatus;
+    fetchStatus: FetchStatus;
+}
+export 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>;
+    meta: QueryMeta | undefined;
+}
+export interface QueryBehavior<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> {
+    onFetch: (context: FetchContext<TQueryFnData, TError, TData, TQueryKey>) => void;
+}
+export interface FetchOptions {
+    cancelRefetch?: boolean;
+    meta?: any;
+}
+interface FailedAction {
+    type: 'failed';
+}
+interface FetchAction {
+    type: 'fetch';
+    meta?: any;
+}
+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: QueryState<TData, TError>;
+    setStateOptions?: SetStateOptions;
+}
+export declare type Action<TData, TError> = ContinueAction | ErrorAction<TError> | FailedAction | FetchAction | InvalidateAction | PauseAction | SetStateAction<TData, TError> | SuccessAction<TData>;
+export interface SetStateOptions {
+    meta?: any;
+}
+export declare class Query<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Removable {
+    queryKey: TQueryKey;
+    queryHash: string;
+    options: QueryOptions<TQueryFnData, TError, TData, TQueryKey>;
+    initialState: QueryState<TData, TError>;
+    revertState?: QueryState<TData, TError>;
+    state: QueryState<TData, TError>;
+    meta: QueryMeta | undefined;
+    isFetchingOptimistic?: boolean;
+    private cache;
+    private logger;
+    private promise?;
+    private retryer?;
+    private observers;
+    private defaultOptions?;
+    private abortSignalConsumed;
+    constructor(config: QueryConfig<TQueryFnData, TError, TData, TQueryKey>);
+    private setOptions;
+    protected optionalRemove(): void;
+    setData(newData: TData, options?: SetDataOptions & {
+        manual: boolean;
+    }): TData;
+    setState(state: 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>;
+    private dispatch;
+}
+export {};

package/build/types/query-core/src/queryCache.d.ts

@@ -0,0 +1,59 @@
+import { QueryFilters } from './utils';
+import { Action, Query, QueryState } from './query';
+import type { QueryKey, QueryOptions } from './types';
+import type { QueryClient } from './queryClient';
+import { Subscribable } from './subscribable';
+import { QueryObserver } from './queryObserver';
+interface QueryCacheConfig {
+    onError?: (error: unknown, query: Query<unknown, unknown, unknown>) => void;
+    onSuccess?: (data: unknown, query: Query<unknown, unknown, unknown>) => void;
+}
+interface NotifyEventQueryAdded {
+    type: 'added';
+    query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryRemoved {
+    type: 'removed';
+    query: Query<any, any, any, any>;
+}
+interface NotifyEventQueryUpdated {
+    type: 'updated';
+    query: Query<any, any, any, any>;
+    action: Action<any, any>;
+}
+interface NotifyEventQueryObserverAdded {
+    type: 'observerAdded';
+    query: Query<any, any, any, any>;
+    observer: QueryObserver<any, any, any, any, any>;
+}
+interface NotifyEventQueryObserverRemoved {
+    type: 'observerRemoved';
+    query: Query<any, any, any, any>;
+    observer: QueryObserver<any, any, any, any, any>;
+}
+interface NotifyEventQueryObserverResultsUpdated {
+    type: 'observerResultsUpdated';
+    query: Query<any, any, any, any>;
+}
+declare type QueryCacheNotifyEvent = NotifyEventQueryAdded | NotifyEventQueryRemoved | NotifyEventQueryUpdated | NotifyEventQueryObserverAdded | NotifyEventQueryObserverRemoved | NotifyEventQueryObserverResultsUpdated;
+declare type QueryCacheListener = (event: QueryCacheNotifyEvent) => void;
+export declare class QueryCache extends Subscribable<QueryCacheListener> {
+    config: QueryCacheConfig;
+    private queries;
+    private queriesMap;
+    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 = unknown, TData = TQueryFnData, TQueyKey extends QueryKey = QueryKey>(queryHash: string): Query<TQueryFnData, TError, TData, TQueyKey> | undefined;
+    getAll(): Query[];
+    find<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData>(arg1: QueryKey, arg2?: QueryFilters): Query<TQueryFnData, TError, TData> | undefined;
+    findAll(queryKey?: QueryKey, filters?: QueryFilters): Query[];
+    findAll(filters?: QueryFilters): Query[];
+    findAll(arg1?: QueryKey | QueryFilters, arg2?: QueryFilters): Query[];
+    notify(event: QueryCacheNotifyEvent): void;
+    onFocus(): void;
+    onOnline(): void;
+}
+export {};

package/build/types/query-core/src/queryClient.d.ts

@@ -0,0 +1,65 @@
+import { QueryFilters, Updater, MutationFilters } from './utils';
+import type { QueryClientConfig, DefaultOptions, FetchInfiniteQueryOptions, FetchQueryOptions, InfiniteData, InvalidateOptions, InvalidateQueryFilters, MutationKey, MutationObserverOptions, MutationOptions, QueryFunction, QueryKey, QueryObserverOptions, RefetchOptions, RefetchQueryFilters, ResetOptions, ResetQueryFilters, SetDataOptions } from './types';
+import type { QueryState } from './query';
+import { QueryCache } from './queryCache';
+import { MutationCache } from './mutationCache';
+import { CancelOptions, DefaultedQueryObserverOptions } from './types';
+import { Logger } from './logger';
+export declare class QueryClient {
+    private queryCache;
+    private mutationCache;
+    private logger;
+    private defaultOptions;
+    private queryDefaults;
+    private mutationDefaults;
+    private unsubscribeFocus?;
+    private unsubscribeOnline?;
+    constructor(config?: QueryClientConfig);
+    mount(): void;
+    unmount(): void;
+    isFetching(filters?: QueryFilters): number;
+    isFetching(queryKey?: QueryKey, filters?: QueryFilters): number;
+    isMutating(filters?: MutationFilters): number;
+    getQueryData<TData = unknown>(queryKey: QueryKey, filters?: QueryFilters): TData | undefined;
+    getQueriesData<TData = unknown>(queryKey: QueryKey): [QueryKey, TData][];
+    getQueriesData<TData = unknown>(filters: QueryFilters): [QueryKey, TData][];
+    setQueryData<TData>(queryKey: QueryKey, updater: Updater<TData | undefined, TData | undefined>, options?: SetDataOptions): TData | undefined;
+    setQueriesData<TData>(queryKey: QueryKey, updater: Updater<TData | undefined, TData | undefined>, options?: SetDataOptions): [QueryKey, TData | undefined][];
+    setQueriesData<TData>(filters: QueryFilters, updater: Updater<TData | undefined, TData | undefined>, options?: SetDataOptions): [QueryKey, TData | undefined][];
+    getQueryState<TData = unknown, TError = undefined>(queryKey: QueryKey, filters?: QueryFilters): QueryState<TData, TError> | undefined;
+    removeQueries(filters?: QueryFilters): void;
+    removeQueries(queryKey?: QueryKey, filters?: QueryFilters): void;
+    resetQueries<TPageData = unknown>(filters?: ResetQueryFilters<TPageData>, options?: ResetOptions): Promise<void>;
+    resetQueries<TPageData = unknown>(queryKey?: QueryKey, filters?: ResetQueryFilters<TPageData>, options?: ResetOptions): Promise<void>;
+    cancelQueries(filters?: QueryFilters, options?: CancelOptions): Promise<void>;
+    cancelQueries(queryKey?: QueryKey, filters?: QueryFilters, options?: CancelOptions): Promise<void>;
+    invalidateQueries<TPageData = unknown>(filters?: InvalidateQueryFilters<TPageData>, options?: InvalidateOptions): Promise<void>;
+    invalidateQueries<TPageData = unknown>(queryKey?: QueryKey, filters?: InvalidateQueryFilters<TPageData>, options?: InvalidateOptions): Promise<void>;
+    refetchQueries<TPageData = unknown>(filters?: RefetchQueryFilters<TPageData>, options?: RefetchOptions): Promise<void>;
+    refetchQueries<TPageData = unknown>(queryKey?: QueryKey, filters?: RefetchQueryFilters<TPageData>, options?: RefetchOptions): Promise<void>;
+    fetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    fetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    fetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<TData>;
+    prefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    prefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    prefetchQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    fetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<InfiniteData<TData>>;
+    fetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<InfiniteData<TData>>;
+    fetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<InfiniteData<TData>>;
+    prefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    prefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    prefetchInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>): Promise<void>;
+    resumePausedMutations(): Promise<void>;
+    getQueryCache(): QueryCache;
+    getMutationCache(): MutationCache;
+    getLogger(): Logger;
+    getDefaultOptions(): DefaultOptions;
+    setDefaultOptions(options: DefaultOptions): void;
+    setQueryDefaults(queryKey: QueryKey, options: QueryObserverOptions<unknown, any, any, any>): void;
+    getQueryDefaults(queryKey?: QueryKey): QueryObserverOptions<any, any, any, any, any> | undefined;
+    setMutationDefaults(mutationKey: MutationKey, options: MutationObserverOptions<any, any, any, any>): void;
+    getMutationDefaults(mutationKey?: MutationKey): MutationObserverOptions<any, any, any, any> | undefined;
+    defaultQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options?: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> | 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;
+}

package/build/types/query-core/src/queryObserver.d.ts

@@ -0,0 +1,61 @@
+import { DefaultedQueryObserverOptions, RefetchPageFilters } from './types';
+import type { QueryKey, QueryObserverOptions, QueryObserverResult, RefetchOptions } from './types';
+import type { Query, Action, FetchOptions } from './query';
+import type { QueryClient } from './queryClient';
+import { Subscribable } from './subscribable';
+declare type QueryObserverListener<TData, TError> = (result: QueryObserverResult<TData, TError>) => void;
+export interface NotifyOptions {
+    cache?: boolean;
+    listeners?: boolean;
+    onError?: boolean;
+    onSuccess?: boolean;
+}
+export interface ObserverFetchOptions extends FetchOptions {
+    throwOnError?: boolean;
+}
+export declare class QueryObserver<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends Subscribable<QueryObserverListener<TData, TError>> {
+    options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
+    private client;
+    private currentQuery;
+    private currentQueryInitialState;
+    private currentResult;
+    private currentResultState?;
+    private currentResultOptions?;
+    private previousQueryResult?;
+    private selectError;
+    private selectFn?;
+    private selectResult?;
+    private staleTimeoutId?;
+    private refetchIntervalId?;
+    private currentRefetchInterval?;
+    private trackedProps;
+    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>;
+    remove(): void;
+    refetch<TPageData>({ refetchPage, ...options }?: RefetchOptions & RefetchPageFilters<TPageData>): Promise<QueryObserverResult<TData, TError>>;
+    fetchOptimistic(options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): Promise<QueryObserverResult<TData, TError>>;
+    protected fetch(fetchOptions: ObserverFetchOptions): Promise<QueryObserverResult<TData, TError>>;
+    private executeFetch;
+    private updateStaleTimeout;
+    private computeRefetchInterval;
+    private updateRefetchInterval;
+    private updateTimers;
+    private clearStaleTimeout;
+    private clearRefetchInterval;
+    protected createResult(query: Query<TQueryFnData, TError, TQueryData, TQueryKey>, options: QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): QueryObserverResult<TData, TError>;
+    updateResult(notifyOptions?: NotifyOptions): void;
+    private updateQuery;
+    onQueryUpdate(action: Action<TData, TError>): void;
+    private notify;
+}
+export {};

package/build/types/query-core/src/removable.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class Removable {
+    cacheTime: number;
+    private gcTimeout?;
+    destroy(): void;
+    protected scheduleGc(): void;
+    protected updateCacheTime(newCacheTime: number | undefined): void;
+    protected clearGcTimeout(): void;
+    protected abstract optionalRemove(): void;
+}

package/build/types/query-core/src/retryer.d.ts

@@ -0,0 +1,33 @@
+import { CancelOptions, NetworkMode } from './types';
+interface RetryerConfig<TData = unknown, TError = unknown> {
+    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;
+}
+export interface Retryer<TData = unknown> {
+    promise: Promise<TData>;
+    cancel: (cancelOptions?: CancelOptions) => void;
+    continue: () => void;
+    cancelRetry: () => void;
+    continueRetry: () => void;
+}
+export declare type RetryValue<TError> = boolean | number | ShouldRetryFunction<TError>;
+declare type ShouldRetryFunction<TError> = (failureCount: number, error: TError) => boolean;
+export declare type RetryDelayValue<TError> = number | RetryDelayFunction<TError>;
+declare type RetryDelayFunction<TError = unknown> = (failureCount: number, error: TError) => number;
+export declare function canFetch(networkMode: NetworkMode | undefined): boolean;
+export declare class CancelledError {
+    revert?: boolean;
+    silent?: boolean;
+    constructor(options?: CancelOptions);
+}
+export declare function isCancelledError(value: any): value is CancelledError;
+export declare function createRetryer<TData = unknown, TError = unknown>(config: RetryerConfig<TData, TError>): Retryer<TData>;
+export {};

package/build/types/query-core/src/subscribable.d.ts

@@ -0,0 +1,10 @@
+declare type Listener = () => void;
+export declare class Subscribable<TListener extends Function = Listener> {
+    protected listeners: TListener[];
+    constructor();
+    subscribe(listener: TListener): () => void;
+    hasListeners(): boolean;
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+}
+export {};