@tanstack/query-sync-storage-persister 4.0.0 → 4.0.5

package/build/stats-html.html

@@ -2669,7 +2669,7 @@ var drawChart = (function (exports) {
   </script>
   <script>
     /*<!--*/
-    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.production.js","children":[{"name":"packages/query-sync-storage-persister/src/index.ts","uid":"9f45-143"}]}],"isRoot":true},"nodeParts":{"9f45-143":{"renderedLength":1715,"gzipLength":628,"brotliLength":0,"mainUid":"9f45-142"}},"nodeMetas":{"9f45-142":{"id":"/packages/query-sync-storage-persister/src/index.ts","moduleParts":{"index.production.js":"9f45-143"},"imported":[],"importedBy":[],"isEntry":true}},"env":{"rollup":"2.76.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
+    const data = {"version":2,"tree":{"name":"root","children":[{"name":"index.production.js","children":[{"name":"packages/query-sync-storage-persister/src/index.ts","uid":"f3f3-143"}]}],"isRoot":true},"nodeParts":{"f3f3-143":{"renderedLength":1715,"gzipLength":628,"brotliLength":0,"mainUid":"f3f3-142"}},"nodeMetas":{"f3f3-142":{"id":"/packages/query-sync-storage-persister/src/index.ts","moduleParts":{"index.production.js":"f3f3-143"},"imported":[],"importedBy":[],"isEntry":true}},"env":{"rollup":"2.76.0"},"options":{"gzip":true,"brotli":false,"sourcemap":false}};
 
     const run = () => {
       const width = window.innerWidth;

package/build/stats.json

@@ -0,0 +1,45 @@
+{
+  "version": 2,
+  "tree": {
+    "name": "root",
+    "children": [
+      {
+        "name": "index.production.js",
+        "children": [
+          {
+            "name": "packages/query-sync-storage-persister/src/index.ts",
+            "uid": "f3f3-145"
+          }
+        ]
+      }
+    ],
+    "isRoot": true
+  },
+  "nodeParts": {
+    "f3f3-145": {
+      "renderedLength": 1715,
+      "gzipLength": 628,
+      "brotliLength": 0,
+      "mainUid": "f3f3-144"
+    }
+  },
+  "nodeMetas": {
+    "f3f3-144": {
+      "id": "/packages/query-sync-storage-persister/src/index.ts",
+      "moduleParts": {
+        "index.production.js": "f3f3-145"
+      },
+      "imported": [],
+      "importedBy": [],
+      "isEntry": true
+    }
+  },
+  "env": {
+    "rollup": "2.76.0"
+  },
+  "options": {
+    "gzip": true,
+    "brotli": false,
+    "sourcemap": false
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Subscribable } from './subscribable';
+declare type SetupFn = (setFocused: (focused?: boolean) => void) => (() => void) | undefined;
+export declare class FocusManager extends Subscribable {
+    private focused?;
+    private cleanup?;
+    private setup;
+    constructor();
+    protected onSubscribe(): void;
+    protected onUnsubscribe(): void;
+    setEventListener(setup: SetupFn): void;
+    setFocused(focused?: boolean): void;
+    onFocus(): void;
+    isFocused(): boolean;
+}
+export declare const focusManager: FocusManager;
+export {};

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

@@ -0,0 +1,34 @@
+import type { QueryClient } from './queryClient';
+import type { Query, QueryState } from './query';
+import type { MutationKey, MutationOptions, QueryKey, QueryOptions } from './types';
+import type { Mutation, MutationState } from './mutation';
+export interface DehydrateOptions {
+    dehydrateMutations?: boolean;
+    dehydrateQueries?: boolean;
+    shouldDehydrateMutation?: ShouldDehydrateMutationFunction;
+    shouldDehydrateQuery?: ShouldDehydrateQueryFunction;
+}
+export interface HydrateOptions {
+    defaultOptions?: {
+        queries?: QueryOptions;
+        mutations?: MutationOptions;
+    };
+}
+interface DehydratedMutation {
+    mutationKey?: MutationKey;
+    state: MutationState;
+}
+interface DehydratedQuery {
+    queryHash: string;
+    queryKey: QueryKey;
+    state: QueryState;
+}
+export interface DehydratedState {
+    mutations: DehydratedMutation[];
+    queries: DehydratedQuery[];
+}
+export declare type ShouldDehydrateQueryFunction = (query: Query) => boolean;
+export declare type ShouldDehydrateMutationFunction = (mutation: Mutation) => boolean;
+export declare function dehydrate(client: QueryClient, options?: DehydrateOptions): DehydratedState;
+export declare function hydrate(client: QueryClient, dehydratedState: unknown, options?: HydrateOptions): void;
+export {};

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

@@ -0,0 +1,20 @@
+export { CancelledError } from './retryer';
+export { QueryCache } from './queryCache';
+export { QueryClient } from './queryClient';
+export { QueryObserver } from './queryObserver';
+export { QueriesObserver } from './queriesObserver';
+export { InfiniteQueryObserver } from './infiniteQueryObserver';
+export { MutationCache } from './mutationCache';
+export { MutationObserver } from './mutationObserver';
+export { notifyManager } from './notifyManager';
+export { focusManager } from './focusManager';
+export { onlineManager } from './onlineManager';
+export { hashQueryKey, isError, parseQueryArgs, parseFilterArgs, parseMutationFilterArgs, parseMutationArgs, } from './utils';
+export type { MutationFilters, QueryFilters } from './utils';
+export { isCancelledError } from './retryer';
+export { dehydrate, hydrate } from './hydration';
+export * from './types';
+export type { Query } from './query';
+export type { Mutation } from './mutation';
+export type { Logger } from './logger';
+export type { DehydrateOptions, DehydratedState, HydrateOptions, ShouldDehydrateMutationFunction, ShouldDehydrateQueryFunction, } from './hydration';

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

@@ -0,0 +1,15 @@
+import type { QueryBehavior } from './query';
+import type { InfiniteData, QueryOptions } from './types';
+export declare function infiniteQueryBehavior<TQueryFnData, TError, TData>(): QueryBehavior<TQueryFnData, TError, InfiniteData<TData>>;
+export declare function getNextPageParam(options: QueryOptions<any, any>, pages: unknown[]): unknown | undefined;
+export declare function getPreviousPageParam(options: QueryOptions<any, any>, pages: unknown[]): unknown | undefined;
+/**
+ * Checks if there is a next page.
+ * Returns `undefined` if it cannot be determined.
+ */
+export declare function hasNextPage(options: QueryOptions<any, any, any, any>, pages?: unknown): boolean | undefined;
+/**
+ * Checks if there is a previous page.
+ * Returns `undefined` if it cannot be determined.
+ */
+export declare function hasPreviousPage(options: QueryOptions<any, any, any, any>, pages?: unknown): boolean | undefined;

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

@@ -0,0 +1,18 @@
+import type { DefaultedInfiniteQueryObserverOptions, FetchNextPageOptions, FetchPreviousPageOptions, InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, QueryKey } from './types';
+import type { QueryClient } from './queryClient';
+import { NotifyOptions, ObserverFetchOptions, QueryObserver } from './queryObserver';
+import { Query } from './query';
+declare type InfiniteQueryObserverListener<TData, TError> = (result: InfiniteQueryObserverResult<TData, TError>) => void;
+export declare class InfiniteQueryObserver<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends QueryObserver<TQueryFnData, TError, InfiniteData<TData>, InfiniteData<TQueryData>, TQueryKey> {
+    subscribe: (listener?: InfiniteQueryObserverListener<TData, TError>) => () => void;
+    getCurrentResult: () => InfiniteQueryObserverResult<TData, TError>;
+    protected fetch: (fetchOptions: ObserverFetchOptions) => Promise<InfiniteQueryObserverResult<TData, TError>>;
+    constructor(client: QueryClient, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>);
+    protected bindMethods(): void;
+    setOptions(options?: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, notifyOptions?: NotifyOptions): void;
+    getOptimisticResult(options: DefaultedInfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): InfiniteQueryObserverResult<TData, TError>;
+    fetchNextPage({ pageParam, ...options }?: FetchNextPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
+    fetchPreviousPage({ pageParam, ...options }?: FetchPreviousPageOptions): Promise<InfiniteQueryObserverResult<TData, TError>>;
+    protected createResult(query: Query<TQueryFnData, TError, InfiniteData<TQueryData>, TQueryKey>, options: InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>): InfiniteQueryObserverResult<TData, TError>;
+}
+export {};

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

@@ -0,0 +1,8 @@
+export interface Logger {
+    log: LogFunction;
+    warn: LogFunction;
+    error: LogFunction;
+}
+declare type LogFunction = (...args: any[]) => void;
+export declare const defaultLogger: Logger;
+export {};

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

@@ -0,0 +1,70 @@
+import type { MutationOptions, MutationStatus, MutationMeta } from './types';
+import type { MutationCache } from './mutationCache';
+import type { MutationObserver } from './mutationObserver';
+import { Logger } from './logger';
+import { Removable } from './removable';
+interface MutationConfig<TData, TError, TVariables, TContext> {
+    mutationId: number;
+    mutationCache: MutationCache;
+    options: MutationOptions<TData, TError, TVariables, TContext>;
+    logger?: Logger;
+    defaultOptions?: MutationOptions<TData, TError, TVariables, TContext>;
+    state?: MutationState<TData, TError, TVariables, TContext>;
+    meta?: MutationMeta;
+}
+export interface MutationState<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> {
+    context: TContext | undefined;
+    data: TData | undefined;
+    error: TError | null;
+    failureCount: number;
+    isPaused: boolean;
+    status: MutationStatus;
+    variables: TVariables | undefined;
+}
+interface FailedAction {
+    type: 'failed';
+}
+interface LoadingAction<TVariables, TContext> {
+    type: 'loading';
+    variables?: TVariables;
+    context?: TContext;
+}
+interface SuccessAction<TData> {
+    type: 'success';
+    data: TData;
+}
+interface ErrorAction<TError> {
+    type: 'error';
+    error: TError;
+}
+interface PauseAction {
+    type: 'pause';
+}
+interface ContinueAction {
+    type: 'continue';
+}
+interface SetStateAction<TData, TError, TVariables, TContext> {
+    type: 'setState';
+    state: MutationState<TData, TError, TVariables, TContext>;
+}
+export declare type Action<TData, TError, TVariables, TContext> = ContinueAction | ErrorAction<TError> | FailedAction | LoadingAction<TVariables, TContext> | PauseAction | SetStateAction<TData, TError, TVariables, TContext> | SuccessAction<TData>;
+export declare class Mutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends Removable {
+    state: MutationState<TData, TError, TVariables, TContext>;
+    options: MutationOptions<TData, TError, TVariables, TContext>;
+    mutationId: number;
+    meta: MutationMeta | undefined;
+    private observers;
+    private mutationCache;
+    private logger;
+    private retryer?;
+    constructor(config: MutationConfig<TData, TError, TVariables, TContext>);
+    setState(state: MutationState<TData, TError, TVariables, TContext>): void;
+    addObserver(observer: MutationObserver<any, any, any, any>): void;
+    removeObserver(observer: MutationObserver<any, any, any, any>): void;
+    protected optionalRemove(): void;
+    continue(): Promise<TData>;
+    execute(): Promise<TData>;
+    private dispatch;
+}
+export declare function getDefaultState<TData, TError, TVariables, TContext>(): MutationState<TData, TError, TVariables, TContext>;
+export {};

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

@@ -0,0 +1,52 @@
+import { MutationObserver } from './mutationObserver';
+import type { MutationOptions } from './types';
+import type { QueryClient } from './queryClient';
+import { Action, Mutation, MutationState } from './mutation';
+import { MutationFilters } from './utils';
+import { Subscribable } from './subscribable';
+interface MutationCacheConfig {
+    onError?: (error: unknown, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => void;
+    onSuccess?: (data: unknown, variables: unknown, context: unknown, mutation: Mutation<unknown, unknown, unknown>) => void;
+    onMutate?: (variables: unknown, mutation: Mutation<unknown, unknown, unknown, unknown>) => void;
+}
+interface NotifyEventMutationAdded {
+    type: 'added';
+    mutation: Mutation<any, any, any, any>;
+}
+interface NotifyEventMutationRemoved {
+    type: 'removed';
+    mutation: Mutation<any, any, any, any>;
+}
+interface NotifyEventMutationObserverAdded {
+    type: 'observerAdded';
+    mutation: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationObserverRemoved {
+    type: 'observerRemoved';
+    mutation: Mutation<any, any, any, any>;
+    observer: MutationObserver<any, any, any>;
+}
+interface NotifyEventMutationUpdated {
+    type: 'updated';
+    mutation: Mutation<any, any, any, any>;
+    action: Action<any, any, any, any>;
+}
+declare type MutationCacheNotifyEvent = NotifyEventMutationAdded | NotifyEventMutationRemoved | NotifyEventMutationObserverAdded | NotifyEventMutationObserverRemoved | NotifyEventMutationUpdated;
+declare type MutationCacheListener = (event: MutationCacheNotifyEvent) => void;
+export declare class MutationCache extends Subscribable<MutationCacheListener> {
+    config: MutationCacheConfig;
+    private mutations;
+    private mutationId;
+    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 = unknown, TVariables = any, TContext = unknown>(filters: MutationFilters): Mutation<TData, TError, TVariables, TContext> | undefined;
+    findAll(filters: MutationFilters): Mutation[];
+    notify(event: MutationCacheNotifyEvent): void;
+    resumePausedMutations(): Promise<void>;
+}
+export {};

package/build/types/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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;
+}