@qiaopeng/tanstack-query-plus 0.5.9 → 0.5.10

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/PersistQueryClientProvider.tsx"],"names":["useEffect","setupOnlineManager","useMemo","createPersister","TIME_CONSTANTS","jsx","QueryClientProvider","TanStackPersistProvider","useState","isOnline","subscribeToOnlineStatus","clearCache"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAmBO,SAAS,0BAAA,CAA2B;AAAA,EACzC,QAAA;AAAA,EACA,MAAA;AAAA,EACA,QAAA,GAAW,sBAAA;AAAA,EACX,iBAAA,GAAoB,IAAA;AAAA,EACpB,oBAAA,GAAuB,IAAA;AAAA,EACvB,cAAA,EAAgB,eAAA;AAAA,EAChB;AACF,CAAA,EAAoC;AAClC,EAAAA,eAAA,CAAU,MAAM;AACd,IAAA,IAAI,oBAAA,EAAsB;AACxB,MAAAC,oCAAA,EAAmB;AAAA,IACrB;AAAA,EACF,CAAA,EAAG,CAAC,oBAAoB,CAAC,CAAA;AAEzB,EAAA,MAAM,SAAA,GAAYC,cAAQ,MAAM;AAC9B,IAAA,IAAI,CAAC,mBAAmB,OAAO,IAAA;AAC/B,IAAA,OAAOC,iCAAA,CAAgB,QAAA,EAAU,MAAA,EAAW,eAAe,CAAA;AAAA,EAC7D,CAAA,EAAG,CAAC,QAAA,EAAU,iBAAA,EAAmB,eAAe,CAAC,CAAA;AAEjD,EAAA,MAAM,cAAA,GAAiBD,cAAQ,MAAM;AACnC,IAAA,IAAI,CAAC,WAAW,OAAO,IAAA;AACvB,IAAA,OAAO;AAAA,MACL,SAAA;AAAA,MACA,QAAQE,gCAAA,CAAe;AAAA,KACzB;AAAA,EACF,CAAA,EAAG,CAAC,SAAS,CAAC,CAAA;AAEd,EAAA,IAAI,iBAAA,EAAmB;AACrB,IAAA,IAAI,CAAC,cAAA,EAAgB;AACnB,MAAA,uBAAOC,cAAA,CAACC,8BAAA,EAAA,EAAoB,MAAA,EAAiB,QAAA,EAAS,CAAA;AAAA,IACxD;AACA,IAAA,uBACED,cAAA;AAAA,MAACE,kDAAA;AAAA,MAAA;AAAA,QACC,MAAA;AAAA,QACA,cAAA;AAAA,QACA,SAAA,EAAW,gBAAA;AAAA,QAEV;AAAA;AAAA,KACH;AAAA,EAEJ;AACA,EAAA,uBAAOF,cAAA,CAACC,8BAAA,EAAA,EAAoB,MAAA,EAAiB,QAAA,EAAS,CAAA;AACxD;AAEO,SAAS,oBAAA,GAAuB;AACrC,EAAA,MAAM,CAAC,MAAA,EAAQ,SAAS,CAAA,GAAIE,cAAA,CAASC,4BAAU,CAAA;AAC/C,EAAAT,eAAA,CAAU,MAAM;AACd,IAAA,OAAOU,0CAAwB,SAAS,CAAA;AAAA,EAC1C,CAAA,EAAG,EAAE,CAAA;AACL,EAAA,OAAO;AAAA,IACL,QAAA,EAAU,MAAA;AAAA,IACV,WAAW,CAAC;AAAA,GACd;AACF;AAEO,SAAS,qBAAA,GAAwB;AACtC,EAAA,MAAM,qBAAA,GAAwB,CAAC,QAAA,GAAW,sBAAA,KAA2B;AACnE,IAAAC,4BAAA,CAAW,QAAQ,CAAA;AAAA,EACrB,CAAA;AACA,EAAA,MAAM,kBAAkB,MAAM;AAC5B,IAAA,OAAOF,0BAAA,EAAS;AAAA,EAClB,CAAA;AACA,EAAA,OAAO;AAAA,IACL,UAAA,EAAY,qBAAA;AAAA,IACZ;AAAA,GACF;AACF","file":"index.cjs","sourcesContent":["import type { QueryClient } from \"@tanstack/react-query\";\nimport type { ReactNode } from \"react\";\nimport { QueryClientProvider } from \"@tanstack/react-query\";\nimport { PersistQueryClientProvider as TanStackPersistProvider } from \"@tanstack/react-query-persist-client\";\nimport { useEffect, useMemo, useState } from \"react\";\nimport { TIME_CONSTANTS } from \"./core/config.js\";\nimport { isOnline, setupOnlineManager, subscribeToOnlineStatus } from \"./features/offline.js\";\nimport { clearCache, createPersister } from \"./features/persistence.js\";\n\nexport interface PersistQueryClientProviderProps {\n  children: ReactNode;\n  client: QueryClient;\n  cacheKey?: string;\n  enablePersistence?: boolean;\n  enableOfflineSupport?: boolean;\n  onPersistError?: (error: Error) => void;\n  onPersistRestore?: () => void;\n}\n\nexport function PersistQueryClientProvider({\n  children,\n  client,\n  cacheKey = \"tanstack-query-cache\",\n  enablePersistence = true,\n  enableOfflineSupport = true,\n  onPersistError: _onPersistError,\n  onPersistRestore\n}: PersistQueryClientProviderProps) {\n  useEffect(() => {\n    if (enableOfflineSupport) {\n      setupOnlineManager();\n    }\n  }, [enableOfflineSupport]);\n\n  const persister = useMemo(() => {\n    if (!enablePersistence) return null;\n    return createPersister(cacheKey, undefined, _onPersistError);\n  }, [cacheKey, enablePersistence, _onPersistError]);\n\n  const persistOptions = useMemo(() => {\n    if (!persister) return null;\n    return {\n      persister,\n      maxAge: TIME_CONSTANTS.ONE_DAY\n    };\n  }, [persister]);\n\n  if (enablePersistence) {\n    if (!persistOptions) {\n      return <QueryClientProvider client={client}>{children}</QueryClientProvider>;\n    }\n    return (\n      <TanStackPersistProvider\n        client={client}\n        persistOptions={persistOptions}\n        onSuccess={onPersistRestore}\n      >\n        {children}\n      </TanStackPersistProvider>\n    );\n  }\n  return <QueryClientProvider client={client}>{children}</QueryClientProvider>;\n}\n\nexport function usePersistenceStatus() {\n  const [online, setOnline] = useState(isOnline());\n  useEffect(() => {\n    return subscribeToOnlineStatus(setOnline);\n  }, []);\n  return {\n    isOnline: online,\n    isOffline: !online\n  };\n}\n\nexport function usePersistenceManager() {\n  const clearPersistenceCache = (cacheKey = \"tanstack-query-cache\") => {\n    clearCache(cacheKey);\n  };\n  const getOnlineStatus = () => {\n    return isOnline();\n  };\n  return {\n    clearCache: clearPersistenceCache,\n    getOnlineStatus\n  };\n}\n\nexport default PersistQueryClientProvider;\n"]}

package/dist/index.d.cts

@@ -0,0 +1,36 @@
+export { CardSkeletonFallback, DefaultLoadingFallback, FullScreenLoading, ListSkeletonFallback, PageSkeletonFallback, QueryErrorBoundary, QueryErrorBoundaryProps, QuerySuspenseWrapper, SmallLoadingIndicator, SuspenseWrapper, TextSkeletonFallback } from './components/index.cjs';
+import { QueryClient } from '@tanstack/react-query';
+export { HydrationBoundary, MutationFilters, MutationKey, QueryClient, QueryClientProvider, UseMutationOptions, UseQueryOptions, dehydrate, focusManager, hydrate, keepPreviousData, skipToken, useIsMutating, useQueryClient } from '@tanstack/react-query';
+export { DEFAULT_GC_TIME, DEFAULT_MUTATION_CONFIG, DEFAULT_QUERY_CONFIG, DEFAULT_STALE_TIME, DEVELOPMENT_CONFIG, FocusManagerConfig, GLOBAL_QUERY_CONFIG, LONG_CACHE_CONFIG, ListQueryConfig, PRODUCTION_CONFIG, REALTIME_CONFIG, SMART_RETRY_MUTATION_CONFIG, SmartFocusManager, TIME_CONSTANTS, areKeysEqual, containsEntity, createAppQueryOptions, createAppQueryOptionsWithSelect, createComplexKey, createCustomConfig, createDomainKeyFactory, createErrorSafeConfig, createFilteredKey, createListQueryOptions, createMutationKeyFactory, createPaginatedKey, createSafeRetryStrategy, createSearchKey, createSortedKey, defaultMutationRetryStrategy, defaultQueryRetryStrategy, ensureBestPractices, exponentialBackoff, extractEntityId, getConfigByEnvironment, getSmartFocusManager, isDev, isProd, isTest, matchesKeyPattern, normalizeQueryKey, pauseFocusManager, queryKeys, resetSmartFocusManager, resumeFocusManager, setupFocusManager, validateConfig, validateGcTime, validateQueryKey } from './core/index.cjs';
+export { DevToolsConfig, createDevToolsConfig, defaultDevToolsConfig, isDevToolsEnabled } from './core/devtools.cjs';
+export { DataGuardMutationOptions, EnhancedQueryOptions, EnhancedQueryResult, HoverPrefetchOptions, InViewPrefetchOptions, MutationDefaultsConfig, MutationStateOptions, PrefetchOptions, UseFocusRefetchOptions, UsePauseFocusOptions, batchQueryUtils, calculateBatchStats, createBatchQueryConfig, createCursorPaginationOptions, createInfiniteQueryOptions, createOffsetPaginationOptions, createPageNumberPaginationOptions, createSuspenseInfiniteQuery, createSuspenseQuery, setupMutationDefaults, useAutoRefreshBatchQueries, useBatchPrefetch, useBatchQueryPerformance, useCombinedQueries, useConditionalBatchQueries, useConditionalFocusRefetch, useConditionalPrefetch, useDashboardQueries, useDataGuardMutation, useDataGuardQueryConfig, useDependentBatchQueries, useDynamicBatchQueries, useEnhancedInfiniteQuery, useEnhancedQueries, useEnhancedQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQueries, useEnhancedSuspenseQuery, useFocusCallback, useFocusRefetch, useFocusState, useHoverPrefetch, useIdlePrefetch, useIsFetching, useListMutation, useMutation, useMutationState, usePageVisibility, usePaginatedBatchQueries, usePauseFocus, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRetryBatchQueries, useRoutePrefetch, useSmartFocusManager, useSmartPrefetch } from './hooks/index.cjs';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+export { CursorPaginatedResponse, EnhancedSuspenseInfiniteQueryOptions, EnhancedSuspenseInfiniteQueryResult, EnhancedSuspenseQueryOptions, EnhancedSuspenseQueryResult, ErrorBoundaryProps, ErrorBoundaryState, ErrorFallbackProps, LoadingFallbackProps, MutationContext, MutationOptions, OffsetPaginatedResponse, PageNumberPaginatedResponse, PaginatedResponseWithMeta, PaginationMeta, PaginationParams, QueryMetadata, QueryStatus, SuspenseConfig, SuspenseInfiniteQueryFunction, SuspenseQueryFunction, SuspenseWrapperProps } from './types/index.cjs';
+export { BatchTask, FieldMappingConfig, InteractionRecord, ListOperationVariables, NavigatorWithConnection, NetworkSpeed, NormalizeConfig, PredictionResult, PrefetchConfig, PrefetchStats, PrefetchTask, QueryKeyFactory, QueryKeyFactoryConfig, SmartPrefetchManager, addHashToData, applyDataGuard, batchRemoveItems, batchUpdateItems, cancelQueriesBatch, clearRecentlyUpdated, compose, conditionalUpdateItems, createAddItemConfig, createFieldEnricher, createListOperationConfig, createOptimisticBase, createQueryKeyFactory, createRemoveItemConfig, createSimpleQueryKeyFactory, createTempId, createUpdateItemConfig, deepClone, deriveFamilyKey, extractParamsFromKey, formatBytes, getNetworkInfo, getNetworkSpeed, getPrefetchManager, getStorageUsage, hashObject, invalidateQueriesBatch, isFastNetwork, isListFamilyKey, isQueryKeyEqual, isSlowNetwork, isStorageAvailable, listUpdater, markRecentlyUpdated, normalizeQueryParams, reorderItems, resetPrefetchManager, selectById, selectByIds, selectCount, selectField, selectFields, selectFirst, selectItems, selectLast, selectMap, selectTotal, selectWhere, selectors, setQueryDataBatch, stableListPlaceholder, startsWithKeyPrefix, updateFamilyMetadata } from './utils/index.cjs';
+export { ReactQueryDevtools } from '@tanstack/react-query-devtools';
+export { PersistedClient, Persister } from '@tanstack/react-query-persist-client';
+export { a as CachePriority, C as ConnectionQuality, D as DeepReadonly, N as NetworkInformation, b as NetworkStatus, O as OperationResult, c as Optional, P as PersistenceStrategyType, R as Required, S as StorageType } from './base-CHnwqfyz.cjs';
+export { o as BatchErrorAggregate, n as BatchOperationReport, l as BatchQueryConfig, p as BatchQueryOperations, B as BatchQueryResult, k as BatchQueryStats, m as BatchRetryConfig, C as ConflictError, b as DataGuardInfo, c as DataGuardOptions, D as DataGuardStrategy, E as EnhancedBatchQueryResult, s as EntityWithId, L as ListOperationConfig, g as ListOperationType, i as ListUpdater, d as OptimisticContext, j as OptimisticGlobalConfig, e as OptimisticOperationType, f as OptimisticOperationTypeValue, O as OptimisticUpdateConfig, h as OptimisticUpdater, P as PaginatedData, R as RollbackFunction, r as Selector, S as StaleDataInfo, q as StorageInfo, V as VersionedEntity, a as VersionedPaginatedResponse } from './persistence-MRtkmhqq.cjs';
+export { d as MutationFunctionRegistry, M as MutationOperationType, e as OfflineManagerConfig, b as OfflineMutationOperation, h as OfflineMutationOptions, a as OfflineQueryInfo, g as OfflineQueryOptions, c as OfflineQueueConfig, O as OfflineRecoveryConfig, f as OfflineState } from './offline-xxeA_-6V.cjs';
+
+interface PersistQueryClientProviderProps {
+    children: ReactNode;
+    client: QueryClient;
+    cacheKey?: string;
+    enablePersistence?: boolean;
+    enableOfflineSupport?: boolean;
+    onPersistError?: (error: Error) => void;
+    onPersistRestore?: () => void;
+}
+declare function PersistQueryClientProvider({ children, client, cacheKey, enablePersistence, enableOfflineSupport, onPersistError: _onPersistError, onPersistRestore }: PersistQueryClientProviderProps): react_jsx_runtime.JSX.Element;
+declare function usePersistenceStatus(): {
+    isOnline: boolean;
+    isOffline: boolean;
+};
+declare function usePersistenceManager(): {
+    clearCache: (cacheKey?: string) => void;
+    getOnlineStatus: () => boolean;
+};
+
+export { PersistQueryClientProvider, type PersistQueryClientProviderProps, usePersistenceManager, usePersistenceStatus };

package/dist/index.d.ts

@@ -1,8 +1,36 @@
-export * from "./components/index.js";
-export * from "./core/index.js";
-export * from "./hooks/index.js";
-export { PersistQueryClientProvider, usePersistenceStatus, usePersistenceManager, type PersistQueryClientProviderProps } from "./PersistQueryClientProvider.js";
-export * from "./types/index.js";
-export * from "./utils/index.js";
-export { QueryClient, QueryClientProvider, skipToken, useQueryClient, useIsMutating, type UseMutationOptions, type UseQueryOptions } from "@tanstack/react-query";
-//# sourceMappingURL=index.d.ts.map
+export { CardSkeletonFallback, DefaultLoadingFallback, FullScreenLoading, ListSkeletonFallback, PageSkeletonFallback, QueryErrorBoundary, QueryErrorBoundaryProps, QuerySuspenseWrapper, SmallLoadingIndicator, SuspenseWrapper, TextSkeletonFallback } from './components/index.js';
+import { QueryClient } from '@tanstack/react-query';
+export { HydrationBoundary, MutationFilters, MutationKey, QueryClient, QueryClientProvider, UseMutationOptions, UseQueryOptions, dehydrate, focusManager, hydrate, keepPreviousData, skipToken, useIsMutating, useQueryClient } from '@tanstack/react-query';
+export { DEFAULT_GC_TIME, DEFAULT_MUTATION_CONFIG, DEFAULT_QUERY_CONFIG, DEFAULT_STALE_TIME, DEVELOPMENT_CONFIG, FocusManagerConfig, GLOBAL_QUERY_CONFIG, LONG_CACHE_CONFIG, ListQueryConfig, PRODUCTION_CONFIG, REALTIME_CONFIG, SMART_RETRY_MUTATION_CONFIG, SmartFocusManager, TIME_CONSTANTS, areKeysEqual, containsEntity, createAppQueryOptions, createAppQueryOptionsWithSelect, createComplexKey, createCustomConfig, createDomainKeyFactory, createErrorSafeConfig, createFilteredKey, createListQueryOptions, createMutationKeyFactory, createPaginatedKey, createSafeRetryStrategy, createSearchKey, createSortedKey, defaultMutationRetryStrategy, defaultQueryRetryStrategy, ensureBestPractices, exponentialBackoff, extractEntityId, getConfigByEnvironment, getSmartFocusManager, isDev, isProd, isTest, matchesKeyPattern, normalizeQueryKey, pauseFocusManager, queryKeys, resetSmartFocusManager, resumeFocusManager, setupFocusManager, validateConfig, validateGcTime, validateQueryKey } from './core/index.js';
+export { DevToolsConfig, createDevToolsConfig, defaultDevToolsConfig, isDevToolsEnabled } from './core/devtools.js';
+export { DataGuardMutationOptions, EnhancedQueryOptions, EnhancedQueryResult, HoverPrefetchOptions, InViewPrefetchOptions, MutationDefaultsConfig, MutationStateOptions, PrefetchOptions, UseFocusRefetchOptions, UsePauseFocusOptions, batchQueryUtils, calculateBatchStats, createBatchQueryConfig, createCursorPaginationOptions, createInfiniteQueryOptions, createOffsetPaginationOptions, createPageNumberPaginationOptions, createSuspenseInfiniteQuery, createSuspenseQuery, setupMutationDefaults, useAutoRefreshBatchQueries, useBatchPrefetch, useBatchQueryPerformance, useCombinedQueries, useConditionalBatchQueries, useConditionalFocusRefetch, useConditionalPrefetch, useDashboardQueries, useDataGuardMutation, useDataGuardQueryConfig, useDependentBatchQueries, useDynamicBatchQueries, useEnhancedInfiniteQuery, useEnhancedQueries, useEnhancedQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQueries, useEnhancedSuspenseQuery, useFocusCallback, useFocusRefetch, useFocusState, useHoverPrefetch, useIdlePrefetch, useIsFetching, useListMutation, useMutation, useMutationState, usePageVisibility, usePaginatedBatchQueries, usePauseFocus, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRetryBatchQueries, useRoutePrefetch, useSmartFocusManager, useSmartPrefetch } from './hooks/index.js';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+export { CursorPaginatedResponse, EnhancedSuspenseInfiniteQueryOptions, EnhancedSuspenseInfiniteQueryResult, EnhancedSuspenseQueryOptions, EnhancedSuspenseQueryResult, ErrorBoundaryProps, ErrorBoundaryState, ErrorFallbackProps, LoadingFallbackProps, MutationContext, MutationOptions, OffsetPaginatedResponse, PageNumberPaginatedResponse, PaginatedResponseWithMeta, PaginationMeta, PaginationParams, QueryMetadata, QueryStatus, SuspenseConfig, SuspenseInfiniteQueryFunction, SuspenseQueryFunction, SuspenseWrapperProps } from './types/index.js';
+export { BatchTask, FieldMappingConfig, InteractionRecord, ListOperationVariables, NavigatorWithConnection, NetworkSpeed, NormalizeConfig, PredictionResult, PrefetchConfig, PrefetchStats, PrefetchTask, QueryKeyFactory, QueryKeyFactoryConfig, SmartPrefetchManager, addHashToData, applyDataGuard, batchRemoveItems, batchUpdateItems, cancelQueriesBatch, clearRecentlyUpdated, compose, conditionalUpdateItems, createAddItemConfig, createFieldEnricher, createListOperationConfig, createOptimisticBase, createQueryKeyFactory, createRemoveItemConfig, createSimpleQueryKeyFactory, createTempId, createUpdateItemConfig, deepClone, deriveFamilyKey, extractParamsFromKey, formatBytes, getNetworkInfo, getNetworkSpeed, getPrefetchManager, getStorageUsage, hashObject, invalidateQueriesBatch, isFastNetwork, isListFamilyKey, isQueryKeyEqual, isSlowNetwork, isStorageAvailable, listUpdater, markRecentlyUpdated, normalizeQueryParams, reorderItems, resetPrefetchManager, selectById, selectByIds, selectCount, selectField, selectFields, selectFirst, selectItems, selectLast, selectMap, selectTotal, selectWhere, selectors, setQueryDataBatch, stableListPlaceholder, startsWithKeyPrefix, updateFamilyMetadata } from './utils/index.js';
+export { ReactQueryDevtools } from '@tanstack/react-query-devtools';
+export { PersistedClient, Persister } from '@tanstack/react-query-persist-client';
+export { a as CachePriority, C as ConnectionQuality, D as DeepReadonly, N as NetworkInformation, b as NetworkStatus, O as OperationResult, c as Optional, P as PersistenceStrategyType, R as Required, S as StorageType } from './base-CHnwqfyz.js';
+export { o as BatchErrorAggregate, n as BatchOperationReport, l as BatchQueryConfig, p as BatchQueryOperations, B as BatchQueryResult, k as BatchQueryStats, m as BatchRetryConfig, C as ConflictError, b as DataGuardInfo, c as DataGuardOptions, D as DataGuardStrategy, E as EnhancedBatchQueryResult, s as EntityWithId, L as ListOperationConfig, g as ListOperationType, i as ListUpdater, d as OptimisticContext, j as OptimisticGlobalConfig, e as OptimisticOperationType, f as OptimisticOperationTypeValue, O as OptimisticUpdateConfig, h as OptimisticUpdater, P as PaginatedData, R as RollbackFunction, r as Selector, S as StaleDataInfo, q as StorageInfo, V as VersionedEntity, a as VersionedPaginatedResponse } from './persistence-tIrEb0pR.js';
+export { d as MutationFunctionRegistry, M as MutationOperationType, e as OfflineManagerConfig, b as OfflineMutationOperation, h as OfflineMutationOptions, a as OfflineQueryInfo, g as OfflineQueryOptions, c as OfflineQueueConfig, O as OfflineRecoveryConfig, f as OfflineState } from './offline-DVPtgoAS.js';
+
+interface PersistQueryClientProviderProps {
+    children: ReactNode;
+    client: QueryClient;
+    cacheKey?: string;
+    enablePersistence?: boolean;
+    enableOfflineSupport?: boolean;
+    onPersistError?: (error: Error) => void;
+    onPersistRestore?: () => void;
+}
+declare function PersistQueryClientProvider({ children, client, cacheKey, enablePersistence, enableOfflineSupport, onPersistError: _onPersistError, onPersistRestore }: PersistQueryClientProviderProps): react_jsx_runtime.JSX.Element;
+declare function usePersistenceStatus(): {
+    isOnline: boolean;
+    isOffline: boolean;
+};
+declare function usePersistenceManager(): {
+    clearCache: (cacheKey?: string) => void;
+    getOnlineStatus: () => boolean;
+};
+
+export { PersistQueryClientProvider, type PersistQueryClientProviderProps, usePersistenceManager, usePersistenceStatus };

package/dist/index.js

@@ -1,7 +1,89 @@
-export * from "./components/index.js";
-export * from "./core/index.js";
-export * from "./hooks/index.js";
-export { PersistQueryClientProvider, usePersistenceStatus, usePersistenceManager } from "./PersistQueryClientProvider.js";
-export * from "./types/index.js";
-export * from "./utils/index.js";
-export { QueryClient, QueryClientProvider, skipToken, useQueryClient, useIsMutating } from "@tanstack/react-query";
+export { MutationOperationType } from './chunk-BYAOQALW.js';
+export { SmartPrefetchManager, batchRemoveItems, batchUpdateItems, cancelQueriesBatch, compose, conditionalUpdateItems, createAddItemConfig, createFieldEnricher, createListOperationConfig, createOptimisticBase, createRemoveItemConfig, createTempId, createUpdateItemConfig, getPrefetchManager, invalidateQueriesBatch, keepPreviousData, listUpdater, reorderItems, resetPrefetchManager, selectById, selectByIds, selectCount, selectField, selectFields, selectFirst, selectItems, selectLast, selectMap, selectTotal, selectWhere, selectors, setQueryDataBatch, stableListPlaceholder } from './chunk-GMO3PRZZ.js';
+export { ListOperationType, OptimisticOperationType } from './chunk-ZNXSWUIS.js';
+export { CardSkeletonFallback, DefaultLoadingFallback, FullScreenLoading, HydrationBoundary, ListSkeletonFallback, PageSkeletonFallback, QueryErrorBoundary, QuerySuspenseWrapper, SmallLoadingIndicator, SuspenseWrapper, TextSkeletonFallback, dehydrate, hydrate } from './chunk-AXMWOGNX.js';
+export { areKeysEqual, containsEntity, createAppQueryOptions, createAppQueryOptionsWithSelect, createComplexKey, createDomainKeyFactory, createFilteredKey, createListQueryOptions, createMutationKeyFactory, createPaginatedKey, createSearchKey, createSortedKey, extractEntityId, matchesKeyPattern, normalizeQueryKey, queryKeys, validateQueryKey } from './chunk-ADS2QTMP.js';
+export { ReactQueryDevtools, createDevToolsConfig, defaultDevToolsConfig, isDevToolsEnabled } from './chunk-ZUEMBY4W.js';
+import { setupOnlineManager, createPersister, isOnline, subscribeToOnlineStatus, clearCache } from './chunk-YEV73J4J.js';
+export { deepClone, formatBytes, getStorageUsage, isStorageAvailable } from './chunk-STOMAA2X.js';
+export { CachePriority, ConnectionQuality, PersistenceStrategyType, StorageType } from './chunk-LHEHSLD5.js';
+export { batchQueryUtils, calculateBatchStats, createBatchQueryConfig, createCursorPaginationOptions, createInfiniteQueryOptions, createOffsetPaginationOptions, createPageNumberPaginationOptions, createSuspenseInfiniteQuery, createSuspenseQuery, setupMutationDefaults, useAutoRefreshBatchQueries, useBatchPrefetch, useBatchQueryPerformance, useCombinedQueries, useConditionalBatchQueries, useConditionalFocusRefetch, useConditionalPrefetch, useDashboardQueries, useDataGuardMutation, useDataGuardQueryConfig, useDependentBatchQueries, useDynamicBatchQueries, useEnhancedInfiniteQuery, useEnhancedQueries, useEnhancedQuery, useEnhancedSuspenseInfiniteQuery, useEnhancedSuspenseQueries, useEnhancedSuspenseQuery, useFocusCallback, useFocusRefetch, useFocusState, useHoverPrefetch, useIdlePrefetch, useIsFetching, useListMutation, useMutation, useMutationState, usePageVisibility, usePaginatedBatchQueries, usePauseFocus, usePeriodicPrefetch, usePredictivePrefetch, usePriorityPrefetch, useRetryBatchQueries, useRoutePrefetch, useSmartFocusManager, useSmartPrefetch } from './chunk-JHDKUQSB.js';
+export { ConflictError } from './chunk-HRO2DWKZ.js';
+export { addHashToData, applyDataGuard, clearRecentlyUpdated, createQueryKeyFactory, createSimpleQueryKeyFactory, deriveFamilyKey, extractParamsFromKey, getNetworkInfo, getNetworkSpeed, hashObject, isFastNetwork, isListFamilyKey, isQueryKeyEqual, isSlowNetwork, markRecentlyUpdated, normalizeQueryParams, startsWithKeyPrefix, updateFamilyMetadata } from './chunk-X3ZTSLBQ.js';
+export { SmartFocusManager, focusManager, getSmartFocusManager, pauseFocusManager, resetSmartFocusManager, resumeFocusManager, setupFocusManager } from './chunk-KC62H4VJ.js';
+import { TIME_CONSTANTS } from './chunk-EXITP7QO.js';
+export { DEFAULT_GC_TIME, DEFAULT_MUTATION_CONFIG, DEFAULT_QUERY_CONFIG, DEFAULT_STALE_TIME, DEVELOPMENT_CONFIG, GLOBAL_QUERY_CONFIG, LONG_CACHE_CONFIG, PRODUCTION_CONFIG, REALTIME_CONFIG, SMART_RETRY_MUTATION_CONFIG, TIME_CONSTANTS, createCustomConfig, createErrorSafeConfig, createSafeRetryStrategy, defaultMutationRetryStrategy, defaultQueryRetryStrategy, ensureBestPractices, exponentialBackoff, getConfigByEnvironment, validateConfig, validateGcTime } from './chunk-EXITP7QO.js';
+export { isDev, isProd, isTest } from './chunk-JN2Y6RSY.js';
+import { QueryClientProvider } from '@tanstack/react-query';
+export { QueryClient, QueryClientProvider, skipToken, useIsMutating, useQueryClient } from '@tanstack/react-query';
+import { PersistQueryClientProvider as PersistQueryClientProvider$1 } from '@tanstack/react-query-persist-client';
+import { useEffect, useMemo, useState } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+function PersistQueryClientProvider({
+  children,
+  client,
+  cacheKey = "tanstack-query-cache",
+  enablePersistence = true,
+  enableOfflineSupport = true,
+  onPersistError: _onPersistError,
+  onPersistRestore
+}) {
+  useEffect(() => {
+    if (enableOfflineSupport) {
+      setupOnlineManager();
+    }
+  }, [enableOfflineSupport]);
+  const persister = useMemo(() => {
+    if (!enablePersistence) return null;
+    return createPersister(cacheKey, void 0, _onPersistError);
+  }, [cacheKey, enablePersistence, _onPersistError]);
+  const persistOptions = useMemo(() => {
+    if (!persister) return null;
+    return {
+      persister,
+      maxAge: TIME_CONSTANTS.ONE_DAY
+    };
+  }, [persister]);
+  if (enablePersistence) {
+    if (!persistOptions) {
+      return /* @__PURE__ */ jsx(QueryClientProvider, { client, children });
+    }
+    return /* @__PURE__ */ jsx(
+      PersistQueryClientProvider$1,
+      {
+        client,
+        persistOptions,
+        onSuccess: onPersistRestore,
+        children
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client, children });
+}
+function usePersistenceStatus() {
+  const [online, setOnline] = useState(isOnline());
+  useEffect(() => {
+    return subscribeToOnlineStatus(setOnline);
+  }, []);
+  return {
+    isOnline: online,
+    isOffline: !online
+  };
+}
+function usePersistenceManager() {
+  const clearPersistenceCache = (cacheKey = "tanstack-query-cache") => {
+    clearCache(cacheKey);
+  };
+  const getOnlineStatus = () => {
+    return isOnline();
+  };
+  return {
+    clearCache: clearPersistenceCache,
+    getOnlineStatus
+  };
+}
+
+export { PersistQueryClientProvider, usePersistenceManager, usePersistenceStatus };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/PersistQueryClientProvider.tsx"],"names":["TanStackPersistProvider"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAmBO,SAAS,0BAAA,CAA2B;AAAA,EACzC,QAAA;AAAA,EACA,MAAA;AAAA,EACA,QAAA,GAAW,sBAAA;AAAA,EACX,iBAAA,GAAoB,IAAA;AAAA,EACpB,oBAAA,GAAuB,IAAA;AAAA,EACvB,cAAA,EAAgB,eAAA;AAAA,EAChB;AACF,CAAA,EAAoC;AAClC,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,IAAI,oBAAA,EAAsB;AACxB,MAAA,kBAAA,EAAmB;AAAA,IACrB;AAAA,EACF,CAAA,EAAG,CAAC,oBAAoB,CAAC,CAAA;AAEzB,EAAA,MAAM,SAAA,GAAY,QAAQ,MAAM;AAC9B,IAAA,IAAI,CAAC,mBAAmB,OAAO,IAAA;AAC/B,IAAA,OAAO,eAAA,CAAgB,QAAA,EAAU,MAAA,EAAW,eAAe,CAAA;AAAA,EAC7D,CAAA,EAAG,CAAC,QAAA,EAAU,iBAAA,EAAmB,eAAe,CAAC,CAAA;AAEjD,EAAA,MAAM,cAAA,GAAiB,QAAQ,MAAM;AACnC,IAAA,IAAI,CAAC,WAAW,OAAO,IAAA;AACvB,IAAA,OAAO;AAAA,MACL,SAAA;AAAA,MACA,QAAQ,cAAA,CAAe;AAAA,KACzB;AAAA,EACF,CAAA,EAAG,CAAC,SAAS,CAAC,CAAA;AAEd,EAAA,IAAI,iBAAA,EAAmB;AACrB,IAAA,IAAI,CAAC,cAAA,EAAgB;AACnB,MAAA,uBAAO,GAAA,CAAC,mBAAA,EAAA,EAAoB,MAAA,EAAiB,QAAA,EAAS,CAAA;AAAA,IACxD;AACA,IAAA,uBACE,GAAA;AAAA,MAACA,4BAAA;AAAA,MAAA;AAAA,QACC,MAAA;AAAA,QACA,cAAA;AAAA,QACA,SAAA,EAAW,gBAAA;AAAA,QAEV;AAAA;AAAA,KACH;AAAA,EAEJ;AACA,EAAA,uBAAO,GAAA,CAAC,mBAAA,EAAA,EAAoB,MAAA,EAAiB,QAAA,EAAS,CAAA;AACxD;AAEO,SAAS,oBAAA,GAAuB;AACrC,EAAA,MAAM,CAAC,MAAA,EAAQ,SAAS,CAAA,GAAI,QAAA,CAAS,UAAU,CAAA;AAC/C,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,OAAO,wBAAwB,SAAS,CAAA;AAAA,EAC1C,CAAA,EAAG,EAAE,CAAA;AACL,EAAA,OAAO;AAAA,IACL,QAAA,EAAU,MAAA;AAAA,IACV,WAAW,CAAC;AAAA,GACd;AACF;AAEO,SAAS,qBAAA,GAAwB;AACtC,EAAA,MAAM,qBAAA,GAAwB,CAAC,QAAA,GAAW,sBAAA,KAA2B;AACnE,IAAA,UAAA,CAAW,QAAQ,CAAA;AAAA,EACrB,CAAA;AACA,EAAA,MAAM,kBAAkB,MAAM;AAC5B,IAAA,OAAO,QAAA,EAAS;AAAA,EAClB,CAAA;AACA,EAAA,OAAO;AAAA,IACL,UAAA,EAAY,qBAAA;AAAA,IACZ;AAAA,GACF;AACF","file":"index.js","sourcesContent":["import type { QueryClient } from \"@tanstack/react-query\";\nimport type { ReactNode } from \"react\";\nimport { QueryClientProvider } from \"@tanstack/react-query\";\nimport { PersistQueryClientProvider as TanStackPersistProvider } from \"@tanstack/react-query-persist-client\";\nimport { useEffect, useMemo, useState } from \"react\";\nimport { TIME_CONSTANTS } from \"./core/config.js\";\nimport { isOnline, setupOnlineManager, subscribeToOnlineStatus } from \"./features/offline.js\";\nimport { clearCache, createPersister } from \"./features/persistence.js\";\n\nexport interface PersistQueryClientProviderProps {\n  children: ReactNode;\n  client: QueryClient;\n  cacheKey?: string;\n  enablePersistence?: boolean;\n  enableOfflineSupport?: boolean;\n  onPersistError?: (error: Error) => void;\n  onPersistRestore?: () => void;\n}\n\nexport function PersistQueryClientProvider({\n  children,\n  client,\n  cacheKey = \"tanstack-query-cache\",\n  enablePersistence = true,\n  enableOfflineSupport = true,\n  onPersistError: _onPersistError,\n  onPersistRestore\n}: PersistQueryClientProviderProps) {\n  useEffect(() => {\n    if (enableOfflineSupport) {\n      setupOnlineManager();\n    }\n  }, [enableOfflineSupport]);\n\n  const persister = useMemo(() => {\n    if (!enablePersistence) return null;\n    return createPersister(cacheKey, undefined, _onPersistError);\n  }, [cacheKey, enablePersistence, _onPersistError]);\n\n  const persistOptions = useMemo(() => {\n    if (!persister) return null;\n    return {\n      persister,\n      maxAge: TIME_CONSTANTS.ONE_DAY\n    };\n  }, [persister]);\n\n  if (enablePersistence) {\n    if (!persistOptions) {\n      return <QueryClientProvider client={client}>{children}</QueryClientProvider>;\n    }\n    return (\n      <TanStackPersistProvider\n        client={client}\n        persistOptions={persistOptions}\n        onSuccess={onPersistRestore}\n      >\n        {children}\n      </TanStackPersistProvider>\n    );\n  }\n  return <QueryClientProvider client={client}>{children}</QueryClientProvider>;\n}\n\nexport function usePersistenceStatus() {\n  const [online, setOnline] = useState(isOnline());\n  useEffect(() => {\n    return subscribeToOnlineStatus(setOnline);\n  }, []);\n  return {\n    isOnline: online,\n    isOffline: !online\n  };\n}\n\nexport function usePersistenceManager() {\n  const clearPersistenceCache = (cacheKey = \"tanstack-query-cache\") => {\n    clearCache(cacheKey);\n  };\n  const getOnlineStatus = () => {\n    return isOnline();\n  };\n  return {\n    clearCache: clearPersistenceCache,\n    getOnlineStatus\n  };\n}\n\nexport default PersistQueryClientProvider;\n"]}

package/dist/{types/offline.d.ts → offline-DVPtgoAS.d.ts}

@@ -1,6 +1,7 @@
-import type { QueryKey } from "@tanstack/react-query";
-import type { NetworkStatus, OperationResult } from "./base";
-export interface OfflineRecoveryConfig {
+import { QueryKey } from '@tanstack/react-query';
+import { b as NetworkStatus, O as OperationResult } from './base-CHnwqfyz.js';
+
+interface OfflineRecoveryConfig {
     enabled: boolean;
     retryInterval: number;
     maxRetries: number;
@@ -13,7 +14,7 @@ export interface OfflineRecoveryConfig {
     checkInterval?: number;
     refetchOnReconnect?: boolean;
 }
-export interface OfflineQueryInfo {
+interface OfflineQueryInfo {
     queryKey: QueryKey;
     queryFn: () => Promise<unknown>;
     failedAt: Date;
@@ -22,14 +23,14 @@ export interface OfflineQueryInfo {
     isPaused: boolean;
     metadata?: Record<string, unknown>;
 }
-export declare enum MutationOperationType {
+declare enum MutationOperationType {
     CREATE = "create",
     UPDATE = "update",
     DELETE = "delete",
     PATCH = "patch",
     CUSTOM = "custom"
 }
-export interface OfflineMutationOperation {
+interface OfflineMutationOperation {
     id: string;
     type: MutationOperationType;
     mutationKey: QueryKey;
@@ -42,7 +43,7 @@ export interface OfflineMutationOperation {
     dependsOn?: string[];
     metadata?: Record<string, unknown>;
 }
-export interface OfflineQueueConfig {
+interface OfflineQueueConfig {
     enabled: boolean;
     maxSize: number;
     persist: boolean;
@@ -52,14 +53,14 @@ export interface OfflineQueueConfig {
     operationTimeout: number;
     concurrency: number;
 }
-export interface MutationFunctionRegistry {
+interface MutationFunctionRegistry {
     register: (key: string, fn: () => Promise<unknown>) => void;
     get: (key: string) => (() => Promise<unknown>) | undefined;
     unregister: (key: string) => void;
     clear: () => void;
     getKeys: () => string[];
 }
-export interface OfflineManagerConfig {
+interface OfflineManagerConfig {
     networkCheck: {
         interval: number;
         url?: string;
@@ -73,7 +74,7 @@ export interface OfflineManagerConfig {
         onRecoveryComplete?: (recoveredCount: number) => void;
     };
 }
-export interface OfflineState {
+interface OfflineState {
     isOffline: boolean;
     networkStatus: NetworkStatus;
     queuedOperations: number;
@@ -81,17 +82,18 @@ export interface OfflineState {
     lastSyncAt?: Date;
     isRecovering: boolean;
 }
-export interface OfflineQueryOptions {
+interface OfflineQueryOptions {
     enabled?: boolean;
     fallbackData?: unknown;
     showStaleWhileOffline?: boolean;
     onReconnect?: "refetch" | "keep" | "invalidate";
 }
-export interface OfflineMutationOptions {
+interface OfflineMutationOptions {
     enableQueue?: boolean;
     priority?: number;
     dependsOn?: string[];
     optimisticUpdate?: (variables: unknown) => void;
     rollback?: (variables: unknown) => void;
 }
-//# sourceMappingURL=offline.d.ts.map
+
+export { MutationOperationType as M, type OfflineRecoveryConfig as O, type OfflineQueryInfo as a, type OfflineMutationOperation as b, type OfflineQueueConfig as c, type MutationFunctionRegistry as d, type OfflineManagerConfig as e, type OfflineState as f, type OfflineQueryOptions as g, type OfflineMutationOptions as h };

package/dist/offline-xxeA_-6V.d.cts

@@ -0,0 +1,99 @@
+import { QueryKey } from '@tanstack/react-query';
+import { b as NetworkStatus, O as OperationResult } from './base-CHnwqfyz.cjs';
+
+interface OfflineRecoveryConfig {
+    enabled: boolean;
+    retryInterval: number;
+    maxRetries: number;
+    retryDelay: number;
+    customRetryDelay?: (attempt: number) => number;
+    networkCheckInterval: number;
+    retryOnReconnect: boolean;
+    refetchOnWindowFocus: boolean;
+    queryFilter?: (queryKey: QueryKey) => boolean;
+    checkInterval?: number;
+    refetchOnReconnect?: boolean;
+}
+interface OfflineQueryInfo {
+    queryKey: QueryKey;
+    queryFn: () => Promise<unknown>;
+    failedAt: Date;
+    retryCount: number;
+    lastError?: Error;
+    isPaused: boolean;
+    metadata?: Record<string, unknown>;
+}
+declare enum MutationOperationType {
+    CREATE = "create",
+    UPDATE = "update",
+    DELETE = "delete",
+    PATCH = "patch",
+    CUSTOM = "custom"
+}
+interface OfflineMutationOperation {
+    id: string;
+    type: MutationOperationType;
+    mutationKey: QueryKey;
+    mutationFn: () => Promise<unknown>;
+    variables: unknown;
+    createdAt: Date;
+    retryCount: number;
+    lastError?: Error;
+    priority: number;
+    dependsOn?: string[];
+    metadata?: Record<string, unknown>;
+}
+interface OfflineQueueConfig {
+    enabled: boolean;
+    maxSize: number;
+    persist: boolean;
+    storageKey: string;
+    autoExecuteInterval: number;
+    executeOnReconnect: boolean;
+    operationTimeout: number;
+    concurrency: number;
+}
+interface MutationFunctionRegistry {
+    register: (key: string, fn: () => Promise<unknown>) => void;
+    get: (key: string) => (() => Promise<unknown>) | undefined;
+    unregister: (key: string) => void;
+    clear: () => void;
+    getKeys: () => string[];
+}
+interface OfflineManagerConfig {
+    networkCheck: {
+        interval: number;
+        url?: string;
+        timeout: number;
+    };
+    queue: OfflineQueueConfig;
+    recovery: OfflineRecoveryConfig;
+    callbacks?: {
+        onNetworkChange?: (status: NetworkStatus) => void;
+        onQueueOperation?: (operation: OfflineMutationOperation, result: OperationResult) => void;
+        onRecoveryComplete?: (recoveredCount: number) => void;
+    };
+}
+interface OfflineState {
+    isOffline: boolean;
+    networkStatus: NetworkStatus;
+    queuedOperations: number;
+    failedQueries: number;
+    lastSyncAt?: Date;
+    isRecovering: boolean;
+}
+interface OfflineQueryOptions {
+    enabled?: boolean;
+    fallbackData?: unknown;
+    showStaleWhileOffline?: boolean;
+    onReconnect?: "refetch" | "keep" | "invalidate";
+}
+interface OfflineMutationOptions {
+    enableQueue?: boolean;
+    priority?: number;
+    dependsOn?: string[];
+    optimisticUpdate?: (variables: unknown) => void;
+    rollback?: (variables: unknown) => void;
+}
+
+export { MutationOperationType as M, type OfflineRecoveryConfig as O, type OfflineQueryInfo as a, type OfflineMutationOperation as b, type OfflineQueueConfig as c, type MutationFunctionRegistry as d, type OfflineManagerConfig as e, type OfflineState as f, type OfflineQueryOptions as g, type OfflineMutationOptions as h };

package/dist/persistence-MRtkmhqq.d.cts

@@ -0,0 +1,216 @@
+import { QueryKey } from '@tanstack/react-query';
+import { S as StorageType } from './base-CHnwqfyz.cjs';
+
+type Selector<TInput, TOutput> = (data: TInput | undefined) => TOutput;
+type EntityWithId<T = string | number> = {
+    id: T;
+    [key: string]: unknown;
+};
+type PaginatedData<T> = {
+    items: T[];
+    total?: number;
+    [key: string]: unknown;
+};
+
+interface OptimisticUpdateConfig<TData = unknown, TVariables = unknown> {
+    queryKey: QueryKey;
+    updater: (oldData: TData | undefined, variables: TVariables) => TData | undefined;
+    rollback?: (previousData: TData, error: Error) => void;
+    enabled?: boolean;
+}
+interface OptimisticContext<TData = unknown> {
+    previousData?: TData;
+    timestamp: number;
+    operationType: OptimisticOperationTypeValue;
+}
+declare const OptimisticOperationType: {
+    readonly CREATE: "create";
+    readonly UPDATE: "update";
+    readonly DELETE: "delete";
+    readonly BATCH: "batch";
+};
+type OptimisticOperationTypeValue = (typeof OptimisticOperationType)[keyof typeof OptimisticOperationType];
+interface ListOperationConfig<T extends EntityWithId> {
+    queryKey: QueryKey;
+    operation: ListOperationType;
+    onRollback?: (error: Error, context: OptimisticContext<T[]>) => void;
+}
+declare enum ListOperationType {
+    ADD = "add",
+    UPDATE = "update",
+    REMOVE = "remove"
+}
+interface BatchQueryResult<TData = unknown, TError = Error> {
+    data: TData | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: TError | null;
+    status: "pending" | "error" | "success";
+}
+type OptimisticUpdater<TData = unknown, TVariables = unknown> = (oldData: TData | undefined, variables: TVariables) => TData;
+type RollbackFunction<TData = unknown> = (previousData: TData, error: Error) => void;
+type ListUpdater<T extends EntityWithId> = {
+    add: (items: T[] | undefined, newItem: T) => T[];
+    update: (items: T[] | undefined, updatedItem: Partial<T> & {
+        id: T["id"];
+    }) => T[];
+    remove: (items: T[] | undefined, itemId: T["id"]) => T[];
+};
+interface OptimisticGlobalConfig {
+    enabledByDefault: boolean;
+    defaultRollbackDelay: number;
+    debugMode: boolean;
+    maxRetries: number;
+}
+interface BatchQueryStats {
+    total: number;
+    loading: number;
+    success: number;
+    error: number;
+    stale: number;
+    successRate: number;
+    errorRate: number;
+}
+interface BatchQueryConfig<TData = unknown, TError = Error> {
+    enableStats?: boolean;
+    enableBatchOperations?: boolean;
+    autoRefreshInterval?: number;
+    onBatchSuccess?: (results: TData[]) => void;
+    onBatchError?: (errors: TError[]) => void;
+    onBatchSettled?: (results: TData[], errors: TError[]) => void;
+    retryConfig?: BatchRetryConfig;
+    enablePartialSuccess?: boolean;
+    onPartialSuccess?: (report: BatchOperationReport<TData, TError>) => void;
+}
+interface BatchRetryConfig {
+    maxRetries?: number;
+    retryDelay?: number | ((attemptIndex: number) => number);
+    retryOnlyFailed?: boolean;
+    shouldRetry?: (error: Error, attemptCount: number) => boolean;
+}
+interface BatchOperationReport<TData = unknown, TError = Error> {
+    total: number;
+    successful: number;
+    failed: number;
+    successResults: Array<{
+        index: number;
+        data: TData;
+    }>;
+    failureErrors: Array<{
+        index: number;
+        error: TError;
+        queryKey?: unknown[];
+    }>;
+    isPartialSuccess: boolean;
+    isFullSuccess: boolean;
+    isFullFailure: boolean;
+    duration: number;
+    retryCount?: number;
+}
+interface BatchErrorAggregate<TError = Error> {
+    totalErrors: number;
+    errors: Array<{
+        index: number;
+        error: TError;
+        queryKey?: unknown[];
+    }>;
+    errorsByType: Map<string, TError[]>;
+    firstError: TError | null;
+    lastError: TError | null;
+    errorSummary: string;
+}
+interface BatchQueryOperations {
+    refetchAll: () => Promise<PromiseSettledResult<unknown>[]>;
+    invalidateAll: () => Promise<PromiseSettledResult<void>[]>;
+    cancelAll: () => Promise<PromiseSettledResult<void>[]>;
+    resetAll: () => Promise<PromiseSettledResult<void>[]>;
+    removeAll: () => void;
+    retryFailed: () => Promise<BatchOperationReport>;
+    getErrorAggregate: () => BatchErrorAggregate;
+    getOperationReport: () => BatchOperationReport;
+}
+interface EnhancedBatchQueryResult<TData = unknown, TCombinedResult = TData, TError = Error> {
+    data: TCombinedResult;
+    stats: BatchQueryStats;
+    operations: BatchQueryOperations;
+    config: BatchQueryConfig<TData, TError>;
+}
+
+/**
+ * 数据防护策略类型
+ */
+type DataGuardStrategy = "version" | "timestamp" | "hash" | "none";
+/**
+ * 带版本控制的实体基础接口
+ */
+interface VersionedEntity {
+    id: string | number;
+    version?: number;
+    updatedAt?: string;
+}
+/**
+ * 带版本控制的分页响应
+ */
+interface VersionedPaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page?: number;
+    pageSize?: number;
+    version?: number;
+    updatedAt?: string;
+    _hash?: string;
+    _recentlyUpdatedIds?: Array<string | number> | Set<string | number>;
+}
+/**
+ * 旧数据检测信息
+ */
+interface StaleDataInfo {
+    reason: string;
+    strategy: DataGuardStrategy;
+    queryKey: QueryKey;
+    cached: any;
+    rejected: any;
+}
+/**
+ * 数据防护应用信息
+ */
+interface DataGuardInfo {
+    strategy: DataGuardStrategy;
+    passed: boolean;
+    details: any;
+}
+/**
+ * 数据防护配置选项
+ */
+interface DataGuardOptions {
+    /** 时间戳模式下，最大接受的数据年龄（毫秒），默认 10000 */
+    maxDataAge?: number;
+    /** 启用版本号检查，默认 true */
+    enableVersionCheck?: boolean;
+    /** 启用时间戳检查，默认 true */
+    enableTimestampCheck?: boolean;
+    /** 启用哈希检查（兜底），默认 true */
+    enableHashCheck?: boolean;
+    /** 检测到旧数据时的回调 */
+    onStaleDataDetected?: (info: StaleDataInfo) => void;
+    /** 应用防护时的回调 */
+    onDataGuardApplied?: (info: DataGuardInfo) => void;
+}
+/**
+ * 冲突错误类
+ */
+declare class ConflictError extends Error {
+    details: any;
+    constructor(details: any);
+}
+
+interface StorageInfo {
+    type: StorageType;
+    used: number;
+    total: number;
+    usage: number;
+    available: boolean;
+    error?: string;
+}
+
+export { type BatchQueryResult as B, ConflictError as C, type DataGuardStrategy as D, type EnhancedBatchQueryResult as E, type ListOperationConfig as L, type OptimisticUpdateConfig as O, type PaginatedData as P, type RollbackFunction as R, type StaleDataInfo as S, type VersionedEntity as V, type VersionedPaginatedResponse as a, type DataGuardInfo as b, type DataGuardOptions as c, type OptimisticContext as d, OptimisticOperationType as e, type OptimisticOperationTypeValue as f, ListOperationType as g, type OptimisticUpdater as h, type ListUpdater as i, type OptimisticGlobalConfig as j, type BatchQueryStats as k, type BatchQueryConfig as l, type BatchRetryConfig as m, type BatchOperationReport as n, type BatchErrorAggregate as o, type BatchQueryOperations as p, type StorageInfo as q, type Selector as r, type EntityWithId as s };