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

package/build/types/packages/react-query/src/Hydrate.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { HydrateOptions } from '@tanstack/query-core';
+import { ContextOptions } from './types';
+export declare function useHydrate(state: unknown, options?: HydrateOptions & ContextOptions): void;
+export interface HydrateProps {
+    state?: unknown;
+    options?: HydrateOptions;
+    children?: React.ReactNode;
+}
+export declare const Hydrate: ({ children, options, state }: HydrateProps) => React.ReactElement<any, string | React.JSXElementConstructor<any>>;

package/build/types/packages/react-query/src/QueryClientProvider.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { QueryClient } from '@tanstack/query-core';
+import { ContextOptions } from './types';
+declare global {
+    interface Window {
+        ReactQueryClientContext?: React.Context<QueryClient | undefined>;
+    }
+}
+export declare const defaultContext: React.Context<QueryClient | undefined>;
+export declare const useQueryClient: ({ context }?: ContextOptions) => QueryClient;
+declare type QueryClientProviderPropsBase = {
+    client: QueryClient;
+    children?: React.ReactNode;
+};
+declare type QueryClientProviderPropsWithContext = ContextOptions & {
+    contextSharing?: never;
+} & QueryClientProviderPropsBase;
+declare type QueryClientProviderPropsWithContextSharing = {
+    context?: never;
+    contextSharing?: boolean;
+} & QueryClientProviderPropsBase;
+export declare type QueryClientProviderProps = QueryClientProviderPropsWithContext | QueryClientProviderPropsWithContextSharing;
+export declare const QueryClientProvider: ({ client, children, context, contextSharing, }: QueryClientProviderProps) => JSX.Element;
+export {};

package/build/types/packages/react-query/src/QueryErrorResetBoundary.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+interface QueryErrorResetBoundaryValue {
+    clearReset: () => void;
+    isReset: () => boolean;
+    reset: () => void;
+}
+export declare const useQueryErrorResetBoundary: () => QueryErrorResetBoundaryValue;
+export interface QueryErrorResetBoundaryProps {
+    children: ((value: QueryErrorResetBoundaryValue) => React.ReactNode) | React.ReactNode;
+}
+export declare const QueryErrorResetBoundary: ({ children, }: QueryErrorResetBoundaryProps) => JSX.Element;
+export {};

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

@@ -0,0 +1,17 @@
+import './setBatchUpdatesFn';
+export * from '@tanstack/query-core';
+export * from './types';
+export { useQueries } from './useQueries';
+export type { QueriesResults, QueriesOptions } from './useQueries';
+export { useQuery } from './useQuery';
+export { defaultContext, QueryClientProvider, useQueryClient, } from './QueryClientProvider';
+export type { QueryClientProviderProps } from './QueryClientProvider';
+export type { QueryErrorResetBoundaryProps } from './QueryErrorResetBoundary';
+export { useHydrate, Hydrate } from './Hydrate';
+export type { HydrateProps } from './Hydrate';
+export { QueryErrorResetBoundary, useQueryErrorResetBoundary, } from './QueryErrorResetBoundary';
+export { useIsFetching } from './useIsFetching';
+export { useIsMutating } from './useIsMutating';
+export { useMutation } from './useMutation';
+export { useInfiniteQuery } from './useInfiniteQuery';
+export { useIsRestoring, IsRestoringProvider } from './isRestoring';

package/build/types/packages/react-query/src/isRestoring.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export declare const useIsRestoring: () => boolean;
+export declare const IsRestoringProvider: React.Provider<boolean>;

package/build/types/packages/react-query/src/reactBatchedUpdates.d.ts

@@ -0,0 +1,2 @@
+import * as ReactDOM from 'react-dom';
+export declare const unstable_batchedUpdates: typeof ReactDOM.unstable_batchedUpdates;

package/build/types/packages/react-query/src/setBatchUpdatesFn.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/packages/react-query/src/types.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { InfiniteQueryObserverOptions, InfiniteQueryObserverResult, MutationObserverResult, QueryObserverOptions, QueryObserverResult, QueryKey, MutationObserverOptions, MutateFunction } from '@tanstack/query-core';
+import type { QueryClient } from '@tanstack/query-core';
+export interface ContextOptions {
+    /**
+     * Use this to pass your React Query context. Otherwise, `defaultContext` will be used.
+     */
+    context?: React.Context<QueryClient | undefined>;
+}
+export interface UseBaseQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends ContextOptions, QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
+}
+export interface UseQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
+}
+export interface UseInfiniteQueryOptions<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends ContextOptions, InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {
+}
+export declare type UseBaseQueryResult<TData = unknown, TError = unknown> = QueryObserverResult<TData, TError>;
+export declare type UseQueryResult<TData = unknown, TError = unknown> = UseBaseQueryResult<TData, TError>;
+export declare type DefinedUseQueryResult<TData = unknown, TError = unknown> = Omit<UseQueryResult<TData, TError>, 'data'> & {
+    data: TData;
+};
+export declare type UseInfiniteQueryResult<TData = unknown, TError = unknown> = InfiniteQueryObserverResult<TData, TError>;
+export interface UseMutationOptions<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> extends ContextOptions, Omit<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted' | 'variables'> {
+}
+export declare type UseMutateFunction<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
+export declare type UseMutateAsyncFunction<TData = unknown, TError = unknown, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
+export declare type UseBaseMutationResult<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
+    mutate: UseMutateFunction<TData, TError, TVariables, TContext>;
+}> & {
+    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+};
+export declare type UseMutationResult<TData = unknown, TError = unknown, TVariables = unknown, TContext = unknown> = UseBaseMutationResult<TData, TError, TVariables, TContext>;
+declare type Override<A, B> = {
+    [K in keyof A]: K extends keyof B ? B[K] : A[K];
+};
+export {};

package/build/types/packages/react-query/src/useBaseQuery.d.ts

@@ -0,0 +1,3 @@
+import { QueryKey, QueryObserver } from '@tanstack/query-core';
+import { UseBaseQueryOptions } from './types';
+export declare function useBaseQuery<TQueryFnData, TError, TData, TQueryData, TQueryKey extends QueryKey>(options: UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, Observer: typeof QueryObserver): import("@tanstack/query-core").QueryObserverResult<TData, TError>;

package/build/types/packages/react-query/src/useInfiniteQuery.d.ts

@@ -0,0 +1,5 @@
+import { QueryFunction, QueryKey } from '@tanstack/query-core';
+import { UseInfiniteQueryOptions, UseInfiniteQueryResult } from './types';
+export declare function useInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>): UseInfiniteQueryResult<TData, TError>;
+export declare function useInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey'>): UseInfiniteQueryResult<TData, TError>;
+export declare function useInfiniteQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey>, 'queryKey' | 'queryFn'>): UseInfiniteQueryResult<TData, TError>;

package/build/types/packages/react-query/src/useIsFetching.d.ts

@@ -0,0 +1,7 @@
+import { QueryKey, QueryFilters } from '@tanstack/query-core';
+import { ContextOptions } from './types';
+interface Options extends ContextOptions {
+}
+export declare function useIsFetching(filters?: QueryFilters, options?: Options): number;
+export declare function useIsFetching(queryKey?: QueryKey, filters?: QueryFilters, options?: Options): number;
+export {};

package/build/types/packages/react-query/src/useIsMutating.d.ts

@@ -0,0 +1,7 @@
+import { MutationKey, MutationFilters } from '@tanstack/query-core';
+import { ContextOptions } from './types';
+interface Options extends ContextOptions {
+}
+export declare function useIsMutating(filters?: MutationFilters, options?: Options): number;
+export declare function useIsMutating(mutationKey?: MutationKey, filters?: Omit<MutationFilters, 'mutationKey'>, options?: Options): number;
+export {};

package/build/types/packages/react-query/src/useMutation.d.ts

@@ -0,0 +1,6 @@
+import { MutationFunction, MutationKey } from '@tanstack/query-core';
+import { UseMutationOptions, UseMutationResult } from './types';
+export declare function useMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TError, TVariables, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
+export declare function useMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(mutationFn: MutationFunction<TData, TVariables>, options?: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, 'mutationFn'>): UseMutationResult<TData, TError, TVariables, TContext>;
+export declare function useMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(mutationKey: MutationKey, options?: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, 'mutationKey'>): UseMutationResult<TData, TError, TVariables, TContext>;
+export declare function useMutation<TData = unknown, TError = unknown, TVariables = void, TContext = unknown>(mutationKey: MutationKey, mutationFn?: MutationFunction<TData, TVariables>, options?: Omit<UseMutationOptions<TData, TError, TVariables, TContext>, 'mutationKey' | 'mutationFn'>): UseMutationResult<TData, TError, TVariables, TContext>;

package/build/types/packages/react-query/src/useQueries.d.ts

@@ -0,0 +1,49 @@
+import { QueryKey, QueryFunction } from '@tanstack/query-core';
+import { UseQueryOptions, UseQueryResult } from './types';
+declare type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'context'>;
+declare type MAXIMUM_DEPTH = 20;
+declare type GetOptions<T> = T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+    select: (data: any) => infer TData;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown, TData, TQueryKey> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey>;
+} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown, TQueryFnData, TQueryKey> : UseQueryOptionsForUseQueries;
+declare type GetResults<T> = T extends {
+    queryFnData: any;
+    error?: infer TError;
+    data: infer TData;
+} ? UseQueryResult<TData, TError> : T extends {
+    queryFnData: infer TQueryFnData;
+    error?: infer TError;
+} ? UseQueryResult<TQueryFnData, TError> : T extends {
+    data: infer TData;
+    error?: infer TError;
+} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
+    queryFn?: QueryFunction<unknown, any>;
+    select: (data: any) => infer TData;
+} ? UseQueryResult<TData> : T extends {
+    queryFn?: QueryFunction<infer TQueryFnData, any>;
+} ? UseQueryResult<TQueryFnData> : UseQueryResult;
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+export declare type QueriesOptions<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? UseQueryOptionsForUseQueries[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[...Tail], [...Result, GetOptions<Head>], [...Depth, 1]> : unknown[] extends T ? T : T extends UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>[] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>[] : UseQueryOptionsForUseQueries[];
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+export declare type QueriesResults<T extends any[], Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? UseQueryResult[] : T extends [] ? [] : T extends [infer Head] ? [...Result, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[...Tail], [...Result, GetResults<Head>], [...Depth, 1]> : T extends UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, any>[] ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, TError>[] : UseQueryResult[];
+export declare function useQueries<T extends any[]>({ queries, context, }: {
+    queries: readonly [...QueriesOptions<T>];
+    context?: UseQueryOptions['context'];
+}): QueriesResults<T>;
+export {};

package/build/types/packages/react-query/src/useQuery.d.ts

@@ -0,0 +1,20 @@
+import { QueryFunction, QueryKey } from '@tanstack/query-core';
+import { DefinedUseQueryResult, UseQueryOptions, UseQueryResult } from './types';
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
+    initialData?: () => undefined;
+}): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'initialData'> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}): DefinedUseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'> & {
+    initialData?: () => undefined;
+}): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'initialData'> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}): DefinedUseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'initialData'> & {
+    initialData?: () => undefined;
+}): UseQueryResult<TData, TError>;
+export declare function useQuery<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(queryKey: TQueryKey, queryFn: QueryFunction<TQueryFnData, TQueryKey>, options?: Omit<UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'queryKey' | 'queryFn' | 'initialData'> & {
+    initialData: TQueryFnData | (() => TQueryFnData);
+}): DefinedUseQueryResult<TData, TError>;

package/build/types/packages/react-query/src/utils.d.ts

@@ -0,0 +1 @@
+export declare function shouldThrowError<T extends (...args: any[]) => boolean>(_useErrorBoundary: boolean | T | undefined, params: Parameters<T>): boolean;

package/build/types/packages/react-query-persist-client/src/PersistQueryClientProvider.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { PersistQueryClientOptions } from './persist';
+import { QueryClientProviderProps } from '@tanstack/react-query';
+export declare type PersistQueryClientProviderProps = QueryClientProviderProps & {
+    persistOptions: Omit<PersistQueryClientOptions, 'queryClient'>;
+    onSuccess?: () => void;
+};
+export declare const PersistQueryClientProvider: ({ client, children, persistOptions, onSuccess, ...props }: PersistQueryClientProviderProps) => JSX.Element;

package/build/types/packages/react-query-persist-client/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './persist';
+export * from './PersistQueryClientProvider';
+export * from './retryStrategies';

package/build/types/packages/react-query-persist-client/src/persist.d.ts

@@ -0,0 +1,58 @@
+import { QueryClient, DehydratedState, DehydrateOptions, HydrateOptions } from '@tanstack/query-core';
+export declare type Promisable<T> = T | PromiseLike<T>;
+export interface Persister {
+    persistClient(persistClient: PersistedClient): Promisable<void>;
+    restoreClient(): Promisable<PersistedClient | undefined>;
+    removeClient(): Promisable<void>;
+}
+export interface PersistedClient {
+    timestamp: number;
+    buster: string;
+    clientState: DehydratedState;
+}
+export interface PersistQueryClienRootOptions {
+    /** The QueryClient to persist */
+    queryClient: QueryClient;
+    /** The Persister interface for storing and restoring the cache
+     * to/from a persisted location */
+    persister: Persister;
+    /** A unique string that can be used to forcefully
+     * invalidate existing caches if they do not share the same buster string */
+    buster?: string;
+}
+export interface PersistedQueryClientRestoreOptions extends PersistQueryClienRootOptions {
+    /** The max-allowed age of the cache in milliseconds.
+     * If a persisted cache is found that is older than this
+     * time, it will be discarded */
+    maxAge?: number;
+    /** The options passed to the hydrate function */
+    hydrateOptions?: HydrateOptions;
+}
+export interface PersistedQueryClientSaveOptions extends PersistQueryClienRootOptions {
+    /** The options passed to the dehydrate function */
+    dehydrateOptions?: DehydrateOptions;
+}
+export interface PersistQueryClientOptions extends PersistedQueryClientRestoreOptions, PersistedQueryClientSaveOptions, PersistQueryClienRootOptions {
+}
+/**
+ * Restores persisted data to the QueryCache
+ *  - data obtained from persister.restoreClient
+ *  - data is hydrated using hydrateOptions
+ * If data is expired, busted, empty, or throws, it runs persister.removeClient
+ */
+export declare function persistQueryClientRestore({ queryClient, persister, maxAge, buster, hydrateOptions, }: PersistedQueryClientRestoreOptions): Promise<void>;
+/**
+ * Persists data from the QueryCache
+ *  - data dehydrated using dehydrateOptions
+ *  - data is persisted using persister.persistClient
+ */
+export declare function persistQueryClientSave({ queryClient, persister, buster, dehydrateOptions, }: PersistedQueryClientSaveOptions): Promise<void>;
+/**
+ * Subscribe to QueryCache and MutationCache updates (for persisting)
+ * @returns an unsubscribe function (to discontinue monitoring)
+ */
+export declare function persistQueryClientSubscribe(props: PersistedQueryClientSaveOptions): () => void;
+/**
+ * Restores persisted data to QueryCache and persists further changes.
+ */
+export declare function persistQueryClient(props: PersistQueryClientOptions): [() => void, Promise<void>];

package/build/types/packages/react-query-persist-client/src/retryStrategies.d.ts

@@ -0,0 +1,7 @@
+import { PersistedClient } from './persist';
+export declare type PersistRetryer = (props: {
+    persistedClient: PersistedClient;
+    error: Error;
+    errorCount: number;
+}) => PersistedClient | undefined;
+export declare const removeOldestQuery: PersistRetryer;

package/build/types/tests/utils.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="jest" />
+/// <reference types="node" />
+import { MutationOptions, QueryClient, QueryClientConfig } from '@tanstack/query-core';
+export declare function createQueryClient(config?: QueryClientConfig): QueryClient;
+export declare function mockVisibilityState(value: DocumentVisibilityState): jest.SpyInstance<DocumentVisibilityState, []>;
+export declare function mockNavigatorOnLine(value: boolean): jest.SpyInstance<boolean, []>;
+export declare const mockLogger: {
+    log: jest.Mock<any, any>;
+    warn: jest.Mock<any, any>;
+    error: jest.Mock<any, any>;
+};
+export declare function queryKey(): Array<string>;
+export declare function sleep(timeout: number): Promise<void>;
+export declare function setActTimeout(fn: () => void, ms?: number): NodeJS.Timeout;
+/**
+ * Assert the parameter is of a specific type.
+ */
+export declare const expectType: <T>(_: T) => void;
+/**
+ * Assert the parameter is not typed as `any`
+ */
+export declare const expectTypeNotAny: <T>(_: 0 extends 1 & T ? never : T) => void;
+export declare const executeMutation: (queryClient: QueryClient, options: MutationOptions<any, any, any, any>) => Promise<unknown>;
+export declare function setIsServer(isServer: boolean): () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/query-sync-storage-persister",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "TODO",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -15,7 +15,7 @@
   "browser": "build/umd/index.production.js",
   "types": "build/types/packages/query-sync-storage-persister/src/index.d.ts",
   "files": [
-    "build",
+    "build/*",
     "src"
   ],
   "scripts": {