@umituz/react-native-design-system 4.25.86 → 4.25.87

package/dist/tanstack/domain/repositories/RepositoryFactory.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Repository Factory
+ * Domain layer - Factory for creating repository instances
+ *
+ * Provides singleton instances of repositories to avoid multiple instances.
+ * Repositories are registered once and reused throughout the app.
+ *
+ * @example
+ * ```typescript
+ * // Register repositories
+ * RepositoryFactory.register('users', new UserRepository());
+ * RepositoryFactory.register('posts', new PostRepository());
+ *
+ * // Get repository
+ * const userRepo = RepositoryFactory.get<UserRepository>('users');
+ * const users = await userRepo.queryAll();
+ *
+ * // Get all registered keys
+ * const keys = RepositoryFactory.keys(); // ['users', 'posts']
+ *
+ * // Invalidate all repositories
+ * RepositoryFactory.invalidateAll();
+ * ```
+ */
+import type { BaseRepository } from './BaseRepository';
+declare class RepositoryFactoryClass {
+    private repositories;
+    /**
+     * Register a repository instance
+     *
+     * @param key - Unique identifier for the repository
+     * @param repository - Repository instance
+     */
+    register<TRepository extends BaseRepository<unknown, unknown, unknown>>(key: string, repository: TRepository): void;
+    /**
+     * Get a registered repository instance
+     *
+     * @param key - Repository identifier
+     * @throws Error if repository not found
+     */
+    get<TRepository extends BaseRepository<unknown, unknown, unknown>>(key: string): TRepository;
+    /**
+     * Check if repository is registered
+     */
+    has(key: string): boolean;
+    /**
+     * Unregister a repository
+     */
+    unregister(key: string): boolean;
+    /**
+     * Get all registered repository keys
+     */
+    keys(): string[];
+    /**
+     * Clear all registered repositories
+     * Useful for testing or cleanup
+     */
+    clear(): void;
+    /**
+     * Invalidate all queries from all registered repositories
+     */
+    invalidateAll(): Promise<void>;
+    /**
+     * Prefetch all data from all registered repositories
+     * Useful for app initialization or online event
+     */
+    prefetchAll(): Promise<void>;
+}
+/**
+ * Global repository factory instance
+ */
+export declare const RepositoryFactory: RepositoryFactoryClass;
+export {};

package/dist/tanstack/domain/repositories/RepositoryTypes.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Repository Types
+ * Interfaces for data repository operations
+ */
+import type { CacheConfig } from '../types/CacheStrategy';
+export interface CreateParams<TVariables> {
+    variables: TVariables;
+}
+export interface UpdateParams<TVariables> {
+    id: string | number;
+    variables: TVariables;
+}
+export interface ListParams {
+    page?: number;
+    limit?: number;
+    filter?: Record<string, unknown>;
+}
+export interface RepositoryOptions {
+    /**
+     * Cache strategy for queries
+     * @default CacheStrategies.PUBLIC_DATA
+     */
+    cacheStrategy?: CacheConfig;
+    /**
+     * Stale time override
+     */
+    staleTime?: number;
+    /**
+     * GC time override
+     */
+    gcTime?: number;
+}

package/dist/tanstack/domain/repositories/helpers/repositoryHelpers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Repository Helper Functions
+ * Common helper functions for repository operations
+ */
+import type { RepositoryOptions } from '../RepositoryTypes';
+/**
+ * Gets cache options for repository queries
+ *
+ * @param options - Repository options
+ * @returns Cache options with staleTime and gcTime
+ */
+export declare function getCacheOptions(options: RepositoryOptions): {
+    staleTime: number;
+    gcTime: number;
+};
+/**
+ * Merges repository options with defaults
+ *
+ * @param options - User provided options
+ * @returns Merged options
+ */
+export declare function mergeRepositoryOptions(options?: RepositoryOptions): Required<Pick<RepositoryOptions, 'cacheStrategy'>> & RepositoryOptions;
+/**
+ * Checks if a query key matches a resource
+ *
+ * @param queryKey - Query key to check
+ * @param resource - Resource name to match
+ * @returns True if query key matches resource
+ */
+export declare function matchesResource(queryKey: readonly unknown[], resource: string): boolean;

package/dist/tanstack/domain/repositories/mixins/repositoryInvalidationMethods.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Repository Invalidation Methods
+ * Cache invalidation methods for repository operations
+ */
+import type { IBaseRepository } from '../IBaseRepository';
+/**
+ * Invalidate all queries for this resource
+ *
+ * @param repository - Repository instance
+ */
+export declare function invalidateAll<TData>(repository: IBaseRepository<TData, unknown, unknown>): Promise<void>;
+/**
+ * Invalidate list queries
+ *
+ * @param repository - Repository instance
+ */
+export declare function invalidateLists<TData>(repository: IBaseRepository<TData, unknown, unknown>): Promise<void>;
+/**
+ * Invalidate detail query
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export declare function invalidateDetail<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): Promise<void>;
+/**
+ * Set query data (optimistic update)
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @param data - Data to set
+ */
+export declare function setData<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number, data: TData): void;
+/**
+ * Get query data from cache
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @returns Cached data or undefined
+ */
+export declare function getData<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): TData | undefined;
+/**
+ * Remove query data from cache
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export declare function clearData<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): void;

package/dist/tanstack/domain/repositories/mixins/repositoryQueryMethods.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Repository Query Methods
+ * Query methods for repository operations
+ */
+import type { ListParams } from '../RepositoryTypes';
+import type { IBaseRepository } from '../IBaseRepository';
+/**
+ * Query all items with caching
+ *
+ * @param repository - Repository instance
+ * @param params - Optional list parameters
+ * @returns Promise of data array
+ */
+export declare function queryAll<TData>(repository: IBaseRepository<TData, unknown, unknown>, params?: ListParams): Promise<TData[]>;
+/**
+ * Query item by ID with caching
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ * @returns Promise of data or undefined if not found
+ */
+export declare function queryById<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): Promise<TData | undefined>;
+/**
+ * Prefetch all items
+ *
+ * @param repository - Repository instance
+ * @param params - Optional list parameters
+ */
+export declare function prefetchAll<TData>(repository: IBaseRepository<TData, unknown, unknown>, params?: ListParams): Promise<void>;
+/**
+ * Prefetch item by ID
+ *
+ * @param repository - Repository instance
+ * @param id - Item ID
+ */
+export declare function prefetchById<TData>(repository: IBaseRepository<TData, unknown, unknown>, id: string | number): Promise<void>;

package/dist/tanstack/domain/types/CacheStrategy.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Cache Strategy Types
+ * Domain layer - Cache configuration types
+ *
+ * General-purpose cache strategies for any React Native app
+ */
+import type { UseQueryOptions } from '@tanstack/react-query';
+/**
+ * Cache configuration for TanStack Query
+ */
+export interface CacheConfig {
+    /**
+     * Time in ms data is considered fresh (no refetch)
+     */
+    staleTime: number;
+    /**
+     * Time in ms inactive data stays in cache before garbage collection
+     */
+    gcTime: number;
+    /**
+     * Whether to refetch when component mounts
+     */
+    refetchOnMount?: boolean | 'always';
+    /**
+     * Whether to refetch when window regains focus
+     */
+    refetchOnWindowFocus?: boolean | 'always';
+    /**
+     * Whether to refetch when network reconnects
+     */
+    refetchOnReconnect?: boolean | 'always';
+    /**
+     * Number of retry attempts on failure
+     */
+    retry?: boolean | number;
+    /**
+     * Interval for automatic background refetching (in ms)
+     * Set to false to disable
+     */
+    refetchInterval?: number | false;
+}
+/**
+ * Cache strategy enum for different data types
+ */
+export declare enum CacheStrategyType {
+    /**
+     * Real-time data that changes frequently
+     * Example: Live chat, stock prices, sports scores
+     */
+    REALTIME = "REALTIME",
+    /**
+     * User-specific data
+     * Example: User profile, settings, preferences
+     */
+    USER_DATA = "USER_DATA",
+    /**
+     * Master data that rarely changes
+     * Example: Countries list, categories, app configuration
+     */
+    MASTER_DATA = "MASTER_DATA",
+    /**
+     * Public read-heavy data
+     * Example: Blog posts, product catalog, news feed
+     */
+    PUBLIC_DATA = "PUBLIC_DATA",
+    /**
+     * Custom strategy (user-defined)
+     */
+    CUSTOM = "CUSTOM"
+}
+/**
+ * Query options type (generic, works with any data)
+ */
+export type QueryConfig<TData = unknown, TError = Error> = Partial<UseQueryOptions<TData, TError>>;
+/**
+ * Mutation options type (generic, works with any data)
+ */
+export interface MutationConfig<TData = unknown, TError = Error, TVariables = unknown> {
+    /**
+     * Function to call on mutation success
+     */
+    onSuccess?: (data: TData, variables: TVariables) => void | Promise<void>;
+    /**
+     * Function to call on mutation error
+     */
+    onError?: (error: TError, variables: TVariables) => void | Promise<void>;
+    /**
+     * Function to call on mutation settled (success or error)
+     */
+    onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables) => void | Promise<void>;
+    /**
+     * Number of retry attempts
+     */
+    retry?: boolean | number;
+}

package/dist/tanstack/domain/utils/ErrorHelpers.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Error Helpers
+ * Domain layer - Error handling utilities
+ *
+ * General-purpose error handling for TanStack Query
+ */
+/**
+ * Check if error is a QueryError (from TanStack Query)
+ */
+export declare function isQueryError(error: unknown): boolean;
+/**
+ * Check if error is a MutationError (from TanStack Query)
+ */
+export declare function isMutationError(error: unknown): boolean;
+/**
+ * Check if error is a network error
+ */
+export declare function isNetworkError(error: unknown): boolean;
+/**
+ * Check if error is an abort error
+ */
+export declare function isAbortError(error: unknown): boolean;
+/**
+ * Extract error message from error
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Get user-friendly error message
+ * Maps technical errors to user-friendly messages
+ */
+export declare function getUserFriendlyMessage(error: unknown): string;
+/**
+ * Parse error response (for API errors with structured data)
+ */
+export interface ErrorResponse {
+    message: string;
+    errors?: Record<string, string[]>;
+    code?: string;
+}
+export declare function parseErrorResponse(error: unknown): ErrorResponse | null;
+/**
+ * Get validation errors from error response
+ */
+export declare function getValidationErrors(error: unknown): Record<string, string[]> | null;
+/**
+ * Get error code from error response
+ */
+export declare function getErrorCode(error: unknown): string | null;
+/**
+ * Log error in development
+ */
+export declare function logError(_context: string, _error: unknown): void;

package/dist/tanstack/domain/utils/MetricsCalculator.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Metrics Calculator
+ *
+ * Calculates query performance metrics for monitoring.
+ */
+import type { Query } from '@tanstack/react-query';
+import type { QueryMetrics, DevMonitorOptions } from '../../infrastructure/monitoring/DevMonitor.types';
+/**
+ * Metrics calculator for query performance
+ */
+export declare class MetricsCalculator {
+    /**
+     * Gets unique key string for query
+     */
+    static getQueryKeyString(queryKey: readonly unknown[]): string;
+    /**
+     * Calculates fetch time for a query
+     */
+    static calculateFetchTime(query: Query): number;
+    /**
+     * Creates initial metrics for a query
+     */
+    static createInitialMetrics(query: Query): QueryMetrics;
+    /**
+     * Updates metrics with new fetch data
+     */
+    static updateMetrics(current: QueryMetrics, fetchTime: number): QueryMetrics;
+    /**
+     * Checks if fetch time exceeds slow query threshold
+     */
+    static isSlowQuery(fetchTime: number, threshold: number): boolean;
+    /**
+     * Increments slow fetch count if query is slow
+     */
+    static incrementSlowCountIfNeeded(metrics: QueryMetrics, fetchTime: number, threshold: number): QueryMetrics;
+    /**
+     * Calculates complete metrics for a query
+     */
+    static calculateQueryMetrics(query: Query, currentMetrics: QueryMetrics | null, options: Required<DevMonitorOptions>): QueryMetrics;
+}

package/dist/tanstack/domain/utils/QueryKeyFactory.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Query Key Factory
+ * Domain layer - Query key generation utilities
+ *
+ * General-purpose query key patterns for any React Native app
+ */
+/**
+ * Create a typed query key factory for a resource
+ *
+ * @example
+ * ```typescript
+ * const postKeys = createQueryKeyFactory('posts');
+ *
+ * // All posts
+ * postKeys.all() // ['posts']
+ *
+ * // Posts list
+ * postKeys.lists() // ['posts', 'list']
+ *
+ * // Posts list with filters
+ * postKeys.list({ status: 'published' }) // ['posts', 'list', { status: 'published' }]
+ *
+ * // Single post detail
+ * postKeys.detail(123) // ['posts', 'detail', 123]
+ * ```
+ */
+export declare function createQueryKeyFactory(resource: string): {
+    /**
+     * All queries for this resource
+     */
+    all: () => readonly [string];
+    /**
+     * All list queries for this resource
+     */
+    lists: () => readonly [string, "list"];
+    /**
+     * List query with optional filters
+     */
+    list: (filters?: Record<string, unknown>) => readonly [string, "list"] | readonly [string, "list", Record<string, unknown>];
+    /**
+     * All detail queries for this resource
+     */
+    details: () => readonly [string, "detail"];
+    /**
+     * Detail query for specific item
+     */
+    detail: (id: string | number) => readonly [string, "detail", string | number];
+    /**
+     * Custom query key
+     */
+    custom: (...args: unknown[]) => readonly [string, ...unknown[]];
+};
+/**
+ * Create a query key for a list with pagination
+ *
+ * @example
+ * ```typescript
+ * createPaginatedQueryKey('posts', { page: 1, limit: 10 })
+ * // ['posts', 'list', { page: 1, limit: 10 }]
+ * ```
+ */
+export declare function createPaginatedQueryKey(resource: string, pagination: {
+    page?: number;
+    limit?: number;
+    cursor?: string;
+}): readonly [string, 'list', typeof pagination];
+/**
+ * Create a query key for infinite scroll
+ *
+ * @example
+ * ```typescript
+ * createInfiniteQueryKey('feed', { limit: 20 })
+ * // ['feed', 'infinite', { limit: 20 }]
+ * ```
+ */
+export declare function createInfiniteQueryKey(resource: string, params?: Record<string, unknown>): readonly [string, 'infinite', Record<string, unknown>] | readonly [string, 'infinite'];
+/**
+ * Create a scoped query key (for user-specific data)
+ *
+ * @example
+ * ```typescript
+ * createScopedQueryKey('user123', 'posts')
+ * // ['user', 'user123', 'posts']
+ * ```
+ */
+export declare function createScopedQueryKey(scopeId: string, resource: string, ...args: unknown[]): readonly [string, string, string, ...unknown[]];
+/**
+ * Match query keys by pattern
+ * Useful for invalidating multiple related queries
+ *
+ * @example
+ * ```typescript
+ * // Invalidate all post queries
+ * queryClient.invalidateQueries({
+ *   predicate: (query) => matchQueryKey(query.queryKey, ['posts'])
+ * })
+ * ```
+ */
+export declare function matchQueryKey(queryKey: readonly unknown[], pattern: readonly unknown[]): boolean;

package/dist/tanstack/domain/utils/TypeUtilities.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Type Utilities
+ * Domain layer - Type extractors and helpers
+ *
+ * General-purpose type utilities for TanStack Query
+ */
+import type { UseQueryResult, UseMutationResult } from '@tanstack/react-query';
+/**
+ * Extract data type from UseQueryResult
+ *
+ * @example
+ * ```typescript
+ * const result = useQuery({ queryKey: ['user'], queryFn: fetchUser });
+ * type User = ExtractQueryDataType<typeof result>; // User
+ * ```
+ */
+export type ExtractQueryDataType<TQuery extends UseQueryResult<unknown, unknown>> = TQuery extends UseQueryResult<infer TData, unknown> ? TData : never;
+/**
+ * Extract error type from UseQueryResult
+ *
+ * @example
+ * ```typescript
+ * const result = useQuery({ queryKey: ['user'], queryFn: fetchUser });
+ * type Error = ExtractQueryErrorType<typeof result>; // Error
+ * ```
+ */
+export type ExtractQueryErrorType<TQuery extends UseQueryResult<unknown, unknown>> = TQuery extends UseQueryResult<unknown, infer TError> ? TError : never;
+/**
+ * Extract data type from UseMutationResult
+ *
+ * @example
+ * ```typescript
+ * const mutation = useMutation({ mutationFn: createUser });
+ * type User = ExtractMutationDataType<typeof mutation>; // User
+ * ```
+ */
+export type ExtractMutationDataType<TMutation extends UseMutationResult<unknown, unknown, unknown>> = TMutation extends UseMutationResult<infer TData, unknown, unknown> ? TData : never;
+/**
+ * Extract error type from UseMutationResult
+ *
+ * @example
+ * ```typescript
+ * const mutation = useMutation({ mutationFn: createUser });
+ * type Error = ExtractMutationErrorType<typeof mutation>; // Error
+ * ```
+ */
+export type ExtractMutationErrorType<TMutation extends UseMutationResult<unknown, unknown, unknown>> = TMutation extends UseMutationResult<unknown, infer TError, unknown> ? TError : never;
+/**
+ * Extract variables type from UseMutationResult
+ *
+ * @example
+ * ```typescript
+ * const mutation = useMutation({ mutationFn: createUser });
+ * type Variables = ExtractMutationVariables<typeof mutation>; // CreateUserVars
+ * ```
+ */
+export type ExtractMutationVariables<TMutation extends UseMutationResult<unknown, unknown, unknown>> = TMutation extends UseMutationResult<unknown, unknown, infer TVariables> ? TVariables : never;
+/**
+ * Extract data type from infinite query
+ *
+ * @example
+ * ```typescript
+ * const result = useInfiniteQuery({ queryKey: ['posts'], queryFn: fetchPosts });
+ * type Posts = ExtractInfiniteDataType<typeof result>; // InfiniteData<PostsResponse>
+ * ```
+ */
+export type ExtractInfiniteDataType<TQuery extends UseQueryResult<unknown, unknown>> = TQuery extends UseQueryResult<infer TData, unknown> ? TData : never;
+/**
+ * Extract page data type from infinite query
+ *
+ * @example
+ * ```typescript
+ * const result = useInfiniteQuery({ queryKey: ['posts'], queryFn: fetchPosts });
+ * type Page = ExtractInfinitePageType<typeof result>; // PostsResponse
+ * ```
+ */
+export type ExtractInfinitePageType<TQuery> = TQuery extends {
+    data: {
+        pages: infer TPages;
+    };
+} ? TPages extends Array<infer TPage> ? TPage : never : never;
+/**
+ * Make specific keys required from a type
+ *
+ * @example
+ * ```typescript
+ * type User = { id?: number; name: string; email?: string };
+ * type UserWithId = RequireKeys<User, 'id' | 'email'>;
+ * // { id: number; name: string; email: string }
+ * ```
+ */
+export type RequireKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/**
+ * Make specific keys optional from a type
+ *
+ * @example
+ * ```typescript
+ * type User = { id: number; name: string; email: string };
+ * type PartialUser = OptionalKeys<User, 'id' | 'email'>;
+ * // { id?: number; name: string; email?: string }
+ * ```
+ */
+export type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Deep partial type
+ *
+ * @example
+ * ```typescript
+ * type User = { id: number; profile: { name: string; email: string } };
+ * type PartialUser = DeepPartial<User>;
+ * // { id?: number; profile?: { name?: string; email?: string } }
+ * ```
+ */
+export type DeepPartial<T> = T extends object ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : T;
+/**
+ * Deep required type
+ *
+ * @example
+ * ```typescript
+ * type User = { id?: number; profile?: { name?: string; email?: string } };
+ * type RequiredUser = DeepRequired<User>;
+ * // { id: number; profile: { name: string; email: string } }
+ * ```
+ */
+export type DeepRequired<T> = T extends object ? {
+    [K in keyof T]-?: DeepRequired<T[K]>;
+} : T;

package/dist/tanstack/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @umituz/react-native-tanstack
+ * TanStack Query configuration and utilities for React Native apps
+ *
+ * General-purpose package for hundreds of React Native apps
+ */
+export { TIME_MS as QUERY_TIME_MS, DEFAULT_STALE_TIME, DEFAULT_GC_TIME, DEFAULT_RETRY, DEFAULT_REFETCH_INTERVAL, } from './domain/constants/CacheDefaults';
+export { CacheStrategyType, type CacheConfig as QueryCacheConfig, type QueryConfig, type MutationConfig, } from './domain/types/CacheStrategy';
+export { createQueryKeyFactory, createPaginatedQueryKey, createInfiniteQueryKey, createScopedQueryKey, matchQueryKey, } from './domain/utils/QueryKeyFactory';
+export type { ExtractQueryDataType, ExtractQueryErrorType, ExtractMutationDataType, ExtractMutationErrorType, ExtractMutationVariables, ExtractInfiniteDataType, ExtractInfinitePageType, RequireKeys, OptionalKeys, DeepPartial, DeepRequired, } from './domain/utils/TypeUtilities';
+export { isQueryError, isMutationError, isNetworkError, isAbortError, getErrorMessage, getUserFriendlyMessage, parseErrorResponse, getValidationErrors, getErrorCode, logError, type ErrorResponse, } from './domain/utils/ErrorHelpers';
+export { BaseRepository } from './domain/repositories/BaseRepository';
+export type { CreateParams, UpdateParams, ListParams, RepositoryOptions, } from './domain/repositories/RepositoryTypes';
+export { RepositoryFactory } from './domain/repositories/RepositoryFactory';
+export { CacheStrategies, createQueryClient, getCacheStrategy, type QueryClientFactoryOptions, } from './infrastructure/config/QueryClientConfig';
+export { createPersister, clearPersistedCache, getPersistedCacheSize, type PersisterFactoryOptions, } from './infrastructure/config/PersisterConfig';
+export { getGlobalQueryClient, hasGlobalQueryClient, setGlobalQueryClient, clearGlobalQueryClient, } from './infrastructure/config/QueryClientSingleton';
+export { DevMonitor } from './infrastructure/monitoring/DevMonitor';
+export type { QueryMetrics, CacheStats as QueryCacheStats, DevMonitorOptions, } from './infrastructure/monitoring/DevMonitor.types';
+export { TanstackProvider, type TanstackProviderProps } from './infrastructure/providers/TanstackProvider';
+export { useInvalidateQueries, useInvalidateMultipleQueries, useRemoveQueries, useResetQueries, } from './presentation/hooks/useInvalidateQueries';
+export { useCursorPagination, useOffsetPagination, type CursorPageParam, type OffsetPageParam, type CursorPaginatedResponse, type OffsetPaginatedResponse, } from './presentation/hooks/usePaginatedQuery';
+export { useOptimisticUpdate, useOptimisticListUpdate, type OptimisticUpdateConfig, } from './presentation/hooks/useOptimisticUpdate';
+export { usePrefetchQuery, usePrefetchInfiniteQuery, usePrefetchOnMount, usePrefetchMultiple, type PrefetchOptions, } from './presentation/hooks/usePrefetch';
+export { createConditionalRetry, createQuotaAwareRetry, type RetryFunction, type ErrorChecker, } from './presentation/utils/RetryHelpers';
+export { useQuery, useMutation, useInfiniteQuery, useQueryClient, useIsFetching, useIsMutating, type UseQueryResult, type UseMutationResult, type UseInfiniteQueryResult, type InfiniteData, type QueryKey, type QueryClient, } from '@tanstack/react-query';