@vaiftech/sdk-expo 1.0.10 → 1.2.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { VaifClientConfig, User, VaifClient, AuthResponse, OAuthProviderType, MFAMethod, MFASetupResponse, QueryOptions, WhereFilter, OrderByClause, DbOperation, SubscriptionFilter, DbChangeEvent, ConnectionState, PresenceState, PresenceEntry, UploadResult, FileMetadata, RetryConfig, VaifFunction } from '@vaiftech/client';
+import { VaifClientConfig, User, VaifClient, AuthResponse, OAuthProviderType, MFAMethod, MFASetupResponse, QueryOptions, WhereFilter, OrderByClause, DbOperation, SubscriptionFilter, DbChangeEvent, ConnectionState, PresenceState, PresenceEntry, UploadResult, FileMetadata, RetryConfig, VaifFunction, ProjectMetrics, SecurityAuditLog, IncidentStatus, IncidentAlert, StatusComponent, RealtimeStats, RealtimeMonitoringEvent, MongoCollectionClient, MongoFilter, MongoSort, MongoProjection, MongoPipelineStage, MongoInsertOneResult, MongoInsertManyResult, MongoUpdateResult, MongoUpdateOperators, MongoDeleteResult } from '@vaiftech/client';
 export { AuthResponse, ConnectionState, DbChangeEvent, DbOperation, FileMetadata, InvokeResult, OrderByClause, PresenceState, QueryOptions, UploadResult, User, VaifClient, VaifClientConfig, VaifFunction, WhereFilter } from '@vaiftech/client';
+import { AppStateStatus } from 'react-native';
 export { AuthChangeEvent, AuthClientConfig, AuthEventType, AuthProvider, AuthProviderProps, Session as AuthSession, AuthSubscription, MFAFactor, VaifAuthClient, createAuthClient, useAuthClient, useIdentities, useIsAuthenticated, usePassword, useSession, useSessions, useAuth as useStandaloneAuth, useMFA as useStandaloneMFA } from '@vaiftech/auth/react';
 
 /**
@@ -1218,4 +1219,802 @@ declare function useBatchInvoke<TOutput = unknown>(): {
  */
 declare function useScheduledFunction<TInput = unknown>(functionId: string): UseScheduledFunctionReturn<TInput>;
 
-export { type AsyncStorageInterface, type BroadcastMessage, type MutationStatus, type QueryStatus, type UploadOptions, type UseAuthReturn, type UseBatchDeleteReturn, type UseBatchUpdateReturn, type UseBroadcastReturn, type UseChannelOptions, type UseChannelReturn, type UseCountOptions, type UseCountReturn, type UseCreateReturn, type UseDeleteReturn, type UseDownloadReturn, type UseEmailVerificationReturn, type UseFileReturn, type UseFilesReturn, type UseFunctionListReturn, type UseFunctionOptions, type UseFunctionReturn, type UseInfiniteQueryOptions, type UseInfiniteQueryReturn, type UseMFAReturn, type UseMagicLinkReturn, type UseMutationReturn, type UseOAuthReturn, type UseOptimisticMutationReturn, type UsePaginatedQueryOptions, type UsePaginatedQueryReturn, type UsePasswordResetReturn, type UsePresenceOptions, type UsePresenceReturn, type UseQueryFirstReturn, type UseQueryOptions, type UseQueryReturn, type UseRpcReturn, type UseScheduledFunctionReturn, type UseSubscriptionOptions, type UseSubscriptionReturn, type UseUpdateReturn, type UseUploadReturn, type UseUpsertReturn, type VaifContextValue, VaifProvider, type VaifProviderProps, useAuth, useBatchCreate, useBatchDelete, useBatchInvoke, useBatchUpdate, useBroadcast, useChannel, useCount, useCreate, useDelete, useDownload, useEmailVerification, useFile, useFiles, useFunction, useFunctionList, useFunctionQuery, useInfiniteQuery, useMFA, useMagicLink, useOAuth, useOptimisticMutation, usePaginatedQuery, usePasswordReset, usePresence, usePublicUrl, useQuery, useQueryById, useQueryFirst, useRealtimeConnection, useRpc, useScheduledFunction, useSubscription, useToken, useUpdate, useUpload, useUpsert, useUser, useVaif, useVaifClient };
+interface UseMetricsOptions {
+    /** Auto-refresh interval in ms (0 = disabled) */
+    refetchInterval?: number;
+    /** Enable/disable the query */
+    enabled?: boolean;
+    /** Callback on success */
+    onSuccess?: (metrics: ProjectMetrics) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseMetricsReturn {
+    /** Project metrics data */
+    metrics: ProjectMetrics | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch metrics */
+    refetch: () => Promise<void>;
+}
+interface UseAuditLogsOptions {
+    /** Page size */
+    limit?: number;
+    /** Page offset */
+    offset?: number;
+    /** Enable/disable the query */
+    enabled?: boolean;
+    /** Auto-refresh interval in ms (0 = disabled) */
+    refetchInterval?: number;
+    /** Callback on success */
+    onSuccess?: (logs: SecurityAuditLog[], total: number) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseAuditLogsReturn {
+    /** Audit log entries */
+    logs: SecurityAuditLog[];
+    /** Total count */
+    total: number;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch logs */
+    refetch: () => Promise<void>;
+    /** Load next page */
+    loadMore: () => void;
+    /** Whether there are more pages */
+    hasMore: boolean;
+}
+interface UseIncidentsOptions {
+    /** Filter by status */
+    status?: IncidentStatus;
+    /** Auto-refresh interval in ms (0 = disabled) */
+    refetchInterval?: number;
+    /** Enable/disable the query */
+    enabled?: boolean;
+    /** Callback on success */
+    onSuccess?: (incidents: IncidentAlert[]) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseIncidentsReturn {
+    /** Incident alerts */
+    incidents: IncidentAlert[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch incidents */
+    refetch: () => Promise<void>;
+    /** Acknowledge an incident */
+    acknowledge: (incidentId: string) => Promise<void>;
+    /** Resolve an incident */
+    resolve: (incidentId: string) => Promise<void>;
+    /** Count by severity */
+    countBySeverity: Record<string, number>;
+}
+interface UseSystemHealthOptions {
+    /** Auto-refresh interval in ms (0 = disabled) */
+    refetchInterval?: number;
+    /** Enable/disable the query */
+    enabled?: boolean;
+    /** Callback on status change */
+    onStatusChange?: (components: StatusComponent[]) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseSystemHealthReturn {
+    /** Health components */
+    components: StatusComponent[];
+    /** Overall status */
+    overallStatus: "operational" | "degraded" | "partial_outage" | "major_outage";
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch health status */
+    refetch: () => Promise<void>;
+    /** Check if a specific component is healthy */
+    isHealthy: (componentName: string) => boolean;
+}
+interface UseRealtimeStatsOptions {
+    /** Auto-refresh interval in ms (0 = disabled) */
+    refetchInterval?: number;
+    /** Enable/disable the query */
+    enabled?: boolean;
+    /** Include recent events */
+    includeEvents?: boolean;
+    /** Max events to fetch */
+    eventsLimit?: number;
+    /** Callback on success */
+    onSuccess?: (stats: RealtimeStats, events?: RealtimeMonitoringEvent[]) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseRealtimeStatsReturn {
+    /** Realtime statistics */
+    stats: RealtimeStats | null;
+    /** Recent realtime events */
+    events: RealtimeMonitoringEvent[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch stats */
+    refetch: () => Promise<void>;
+}
+interface UseErrorTrackingOptions {
+    /** Time window in hours (default: 24) */
+    timeWindowHours?: number;
+    /** Auto-refresh interval in ms (0 = disabled) */
+    refetchInterval?: number;
+    /** Enable/disable the query */
+    enabled?: boolean;
+    /** Callback on high error rate */
+    onHighErrorRate?: (errorRate: number) => void;
+    /** Error rate threshold (default: 0.05 = 5%) */
+    errorRateThreshold?: number;
+    /** Refetch when app comes to foreground */
+    refetchOnForeground?: boolean;
+}
+interface UseErrorTrackingReturn {
+    /** Total requests */
+    requestCount: number;
+    /** Total errors */
+    errorCount: number;
+    /** Error rate (0-1) */
+    errorRate: number;
+    /** Average latency in ms */
+    avgLatencyMs: number;
+    /** Whether error rate is above threshold */
+    isHighErrorRate: boolean;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch stats */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for fetching project metrics
+ *
+ * @example
+ * ```tsx
+ * function MetricsDashboard({ projectId }: { projectId: string }) {
+ *   const { metrics, isLoading, error } = useMetrics(projectId, {
+ *     refetchInterval: 30000, // Refresh every 30 seconds
+ *   });
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *   if (error) return <Text>Error: {error.message}</Text>;
+ *
+ *   return (
+ *     <View>
+ *       <Stat label="Requests (24h)" value={metrics?.requestsLast24h} />
+ *       <Stat label="Errors (24h)" value={metrics?.errorsLast24h} />
+ *       <Stat label="Avg Latency" value={`${metrics?.avgLatencyMs}ms`} />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useMetrics(projectId: string, options?: UseMetricsOptions): UseMetricsReturn;
+/**
+ * Hook for fetching security audit logs
+ *
+ * @example
+ * ```tsx
+ * function AuditLogViewer({ projectId }: { projectId: string }) {
+ *   const { logs, total, isLoading, loadMore, hasMore } = useAuditLogs(projectId, {
+ *     limit: 50,
+ *   });
+ *
+ *   return (
+ *     <View>
+ *       <Text>Audit Logs ({total})</Text>
+ *       <FlatList
+ *         data={logs}
+ *         keyExtractor={(log) => log.id}
+ *         renderItem={({ item }) => <LogEntry log={item} />}
+ *         onEndReached={hasMore ? loadMore : undefined}
+ *       />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useAuditLogs(projectId: string, options?: UseAuditLogsOptions): UseAuditLogsReturn;
+/**
+ * Hook for monitoring incidents
+ *
+ * @example
+ * ```tsx
+ * function IncidentMonitor() {
+ *   const {
+ *     incidents,
+ *     countBySeverity,
+ *     acknowledge,
+ *     resolve,
+ *     isLoading,
+ *   } = useIncidents({
+ *     status: 'open',
+ *     refetchInterval: 60000, // Check every minute
+ *   });
+ *
+ *   return (
+ *     <View>
+ *       <SeverityBadges counts={countBySeverity} />
+ *       <FlatList
+ *         data={incidents}
+ *         keyExtractor={(item) => item.id}
+ *         renderItem={({ item }) => (
+ *           <IncidentCard
+ *             incident={item}
+ *             onAcknowledge={() => acknowledge(item.id)}
+ *             onResolve={() => resolve(item.id)}
+ *           />
+ *         )}
+ *       />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useIncidents(options?: UseIncidentsOptions): UseIncidentsReturn;
+/**
+ * Hook for monitoring system health
+ *
+ * @example
+ * ```tsx
+ * function SystemStatus() {
+ *   const {
+ *     components,
+ *     overallStatus,
+ *     isHealthy,
+ *     isLoading,
+ *   } = useSystemHealth({
+ *     refetchInterval: 30000,
+ *     onStatusChange: (components) => {
+ *       const degraded = components.filter(c => c.status !== 'operational');
+ *       if (degraded.length > 0) {
+ *         Alert.alert('System Alert', 'System degradation detected');
+ *       }
+ *     },
+ *   });
+ *
+ *   return (
+ *     <View>
+ *       <StatusBadge status={overallStatus} />
+ *       {components.map(component => (
+ *         <ComponentStatus key={component.id} component={component} />
+ *       ))}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useSystemHealth(options?: UseSystemHealthOptions): UseSystemHealthReturn;
+/**
+ * Hook for monitoring realtime stats
+ *
+ * @example
+ * ```tsx
+ * function RealtimeMonitor({ projectId }: { projectId: string }) {
+ *   const { stats, events, isLoading } = useRealtimeStats(projectId, {
+ *     refetchInterval: 10000,
+ *     includeEvents: true,
+ *     eventsLimit: 20,
+ *   });
+ *
+ *   return (
+ *     <View>
+ *       <StatCard label="Connections" value={stats?.connections} />
+ *       <StatCard label="Subscriptions" value={stats?.subscriptions} />
+ *       <StatCard label="Events (24h)" value={stats?.eventsDelivered24h} />
+ *       <EventList events={events} />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useRealtimeStats(projectId: string, options?: UseRealtimeStatsOptions): UseRealtimeStatsReturn;
+/**
+ * Hook for error tracking and alerting
+ *
+ * @example
+ * ```tsx
+ * function ErrorRateMonitor({ projectId }: { projectId: string }) {
+ *   const {
+ *     requestCount,
+ *     errorCount,
+ *     errorRate,
+ *     avgLatencyMs,
+ *     isHighErrorRate,
+ *   } = useErrorTracking(projectId, {
+ *     refetchInterval: 60000,
+ *     refetchOnForeground: true,
+ *     errorRateThreshold: 0.05, // 5%
+ *     onHighErrorRate: (rate) => {
+ *       Alert.alert('High Error Rate', `Error rate: ${(rate * 100).toFixed(1)}%`);
+ *     },
+ *   });
+ *
+ *   return (
+ *     <View style={isHighErrorRate ? styles.alert : undefined}>
+ *       <Stat label="Requests" value={requestCount} />
+ *       <Stat label="Errors" value={errorCount} />
+ *       <Stat label="Error Rate" value={`${(errorRate * 100).toFixed(2)}%`} />
+ *       <Stat label="Avg Latency" value={`${avgLatencyMs}ms`} />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useErrorTracking(projectId: string, options?: UseErrorTrackingOptions): UseErrorTrackingReturn;
+
+type MongoQueryStatus = "idle" | "loading" | "success" | "error";
+interface UseMongoFindOptions<T extends Record<string, unknown>> {
+    filter?: MongoFilter<T>;
+    sort?: MongoSort<T>;
+    projection?: MongoProjection<T>;
+    skip?: number;
+    limit?: number;
+    enabled?: boolean;
+    refetchOnForeground?: boolean;
+    refetchInterval?: number;
+    keepPreviousData?: boolean;
+    onSuccess?: (data: T[]) => void;
+    onError?: (error: Error) => void;
+    staleTime?: number;
+}
+interface UseMongoFindReturn<T> {
+    data: T[];
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    status: MongoQueryStatus;
+    refetch: () => Promise<void>;
+    isStale: boolean;
+    isEnabled: boolean;
+}
+interface UseMongoFindOneOptions<T extends Record<string, unknown>> {
+    filter?: MongoFilter<T>;
+    projection?: MongoProjection<T>;
+    enabled?: boolean;
+    onSuccess?: (data: T | null) => void;
+    onError?: (error: Error) => void;
+}
+interface UseMongoFindOneReturn<T> {
+    data: T | null;
+    isLoading: boolean;
+    error: Error | null;
+    isNotFound: boolean;
+    refetch: () => Promise<void>;
+}
+interface UseMongoAggregateOptions {
+    enabled?: boolean;
+    allowDiskUse?: boolean;
+    maxTimeMS?: number;
+    onSuccess?: (data: unknown[]) => void;
+    onError?: (error: Error) => void;
+}
+interface UseMongoAggregateReturn<T> {
+    data: T[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface UseMongoMutationReturn<TData, TVariables> {
+    mutate: (variables: TVariables) => Promise<TData>;
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    isLoading: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    data: TData | null;
+    reset: () => void;
+}
+interface UseMongoInsertOneVariables<T> {
+    document: Omit<T, "_id">;
+}
+interface UseMongoInsertManyVariables<T> {
+    documents: Omit<T, "_id">[];
+}
+interface UseMongoUpdateOneVariables<T extends Record<string, unknown>> {
+    filter: MongoFilter<T>;
+    update: MongoUpdateOperators<T>;
+    upsert?: boolean;
+}
+interface UseMongoUpdateManyVariables<T extends Record<string, unknown>> {
+    filter: MongoFilter<T>;
+    update: MongoUpdateOperators<T>;
+    upsert?: boolean;
+}
+interface UseMongoDeleteOneVariables<T extends Record<string, unknown>> {
+    filter: MongoFilter<T>;
+}
+interface UseMongoDeleteManyVariables<T extends Record<string, unknown>> {
+    filter: MongoFilter<T>;
+}
+interface UseMongoInfiniteFindOptions<T extends Record<string, unknown>> {
+    filter?: MongoFilter<T>;
+    sort?: MongoSort<T>;
+    projection?: MongoProjection<T>;
+    pageSize?: number;
+    onSuccess?: (data: T[], hasMore: boolean) => void;
+    onError?: (error: Error) => void;
+}
+interface UseMongoInfiniteFindReturn<T> {
+    data: T[];
+    pages: T[][];
+    hasMore: boolean;
+    isLoading: boolean;
+    isFetchingNextPage: boolean;
+    error: Error | null;
+    fetchNextPage: () => Promise<void>;
+    refetch: () => Promise<void>;
+    reset: () => void;
+}
+interface UseMongoCountOptions<T extends Record<string, unknown>> {
+    filter?: MongoFilter<T>;
+    enabled?: boolean;
+}
+/**
+ * Get a MongoDB collection client for direct operations
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const users = useMongoCollection<User>('users');
+ *
+ *   const handleCreate = async () => {
+ *     await users.insertOne({ name: 'John', email: 'john@example.com' });
+ *   };
+ *
+ *   return <Button onPress={handleCreate} title="Create User" />;
+ * }
+ * ```
+ */
+declare function useMongoCollection<T extends Record<string, unknown>>(collectionName: string): MongoCollectionClient<T>;
+/**
+ * Find documents in a MongoDB collection
+ *
+ * @example
+ * ```tsx
+ * function UserList() {
+ *   const { data: users, isLoading } = useMongoFind<User>('users', {
+ *     filter: { status: 'active' },
+ *     sort: { createdAt: -1 },
+ *     limit: 20,
+ *     refetchOnForeground: true,
+ *   });
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *
+ *   return (
+ *     <FlatList
+ *       data={users}
+ *       keyExtractor={item => item._id}
+ *       renderItem={({ item }) => <Text>{item.name}</Text>}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useMongoFind<T extends Record<string, unknown>>(collection: string, options?: UseMongoFindOptions<T>): UseMongoFindReturn<T>;
+/**
+ * Find a single document in a MongoDB collection
+ *
+ * @example
+ * ```tsx
+ * function UserProfile({ userId }) {
+ *   const { data: user, isLoading, isNotFound } = useMongoFindOne<User>('users', {
+ *     filter: { _id: userId },
+ *   });
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *   if (isNotFound) return <Text>User not found</Text>;
+ *
+ *   return <Text>{user?.name}</Text>;
+ * }
+ * ```
+ */
+declare function useMongoFindOne<T extends Record<string, unknown>>(collection: string, options?: UseMongoFindOneOptions<T>): UseMongoFindOneReturn<T>;
+/**
+ * Run an aggregation pipeline on a MongoDB collection
+ *
+ * @example
+ * ```tsx
+ * function UserStats() {
+ *   const { data: stats, isLoading } = useMongoAggregate('users', [
+ *     { $match: { status: 'active' } },
+ *     { $group: { _id: '$role', count: { $sum: 1 } } },
+ *   ]);
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *
+ *   return (
+ *     <View>
+ *       {stats.map(stat => (
+ *         <Text key={stat._id}>{stat._id}: {stat.count}</Text>
+ *       ))}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useMongoAggregate<TResult = unknown>(collection: string, pipeline: MongoPipelineStage[], options?: UseMongoAggregateOptions): UseMongoAggregateReturn<TResult>;
+/**
+ * Insert a single document into a MongoDB collection
+ *
+ * @example
+ * ```tsx
+ * function CreateUser() {
+ *   const { mutate, isLoading } = useMongoInsertOne<User>('users');
+ *
+ *   const handleCreate = async () => {
+ *     await mutate({ document: { name: 'John', email: 'john@example.com' } });
+ *     Alert.alert('Success', 'User created!');
+ *   };
+ *
+ *   return <Button onPress={handleCreate} disabled={isLoading} title="Create" />;
+ * }
+ * ```
+ */
+declare function useMongoInsertOne<T extends Record<string, unknown>>(collection: string, options?: {
+    onSuccess?: (result: MongoInsertOneResult) => void;
+    onError?: (error: Error) => void;
+}): UseMongoMutationReturn<MongoInsertOneResult, UseMongoInsertOneVariables<T>>;
+/**
+ * Insert multiple documents into a MongoDB collection
+ */
+declare function useMongoInsertMany<T extends Record<string, unknown>>(collection: string, options?: {
+    onSuccess?: (result: MongoInsertManyResult) => void;
+    onError?: (error: Error) => void;
+}): UseMongoMutationReturn<MongoInsertManyResult, UseMongoInsertManyVariables<T>>;
+/**
+ * Update a single document in a MongoDB collection
+ *
+ * @example
+ * ```tsx
+ * function UpdateUser({ userId }) {
+ *   const { mutate, isLoading } = useMongoUpdateOne<User>('users');
+ *
+ *   const handleUpdate = async () => {
+ *     await mutate({
+ *       filter: { _id: userId },
+ *       update: { $set: { status: 'premium' } },
+ *     });
+ *   };
+ *
+ *   return <Button onPress={handleUpdate} disabled={isLoading} title="Upgrade" />;
+ * }
+ * ```
+ */
+declare function useMongoUpdateOne<T extends Record<string, unknown>>(collection: string, options?: {
+    onSuccess?: (result: MongoUpdateResult) => void;
+    onError?: (error: Error) => void;
+}): UseMongoMutationReturn<MongoUpdateResult, UseMongoUpdateOneVariables<T>>;
+/**
+ * Update multiple documents in a MongoDB collection
+ */
+declare function useMongoUpdateMany<T extends Record<string, unknown>>(collection: string, options?: {
+    onSuccess?: (result: MongoUpdateResult) => void;
+    onError?: (error: Error) => void;
+}): UseMongoMutationReturn<MongoUpdateResult, UseMongoUpdateManyVariables<T>>;
+/**
+ * Delete a single document from a MongoDB collection
+ *
+ * @example
+ * ```tsx
+ * function DeleteUser({ userId }) {
+ *   const { mutate, isLoading } = useMongoDeleteOne<User>('users');
+ *
+ *   return (
+ *     <Button
+ *       onPress={() => mutate({ filter: { _id: userId } })}
+ *       disabled={isLoading}
+ *       title="Delete"
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useMongoDeleteOne<T extends Record<string, unknown>>(collection: string, options?: {
+    onSuccess?: (result: MongoDeleteResult) => void;
+    onError?: (error: Error) => void;
+}): UseMongoMutationReturn<MongoDeleteResult, UseMongoDeleteOneVariables<T>>;
+/**
+ * Delete multiple documents from a MongoDB collection
+ */
+declare function useMongoDeleteMany<T extends Record<string, unknown>>(collection: string, options?: {
+    onSuccess?: (result: MongoDeleteResult) => void;
+    onError?: (error: Error) => void;
+}): UseMongoMutationReturn<MongoDeleteResult, UseMongoDeleteManyVariables<T>>;
+/**
+ * Infinite scroll for MongoDB collections
+ *
+ * @example
+ * ```tsx
+ * function InfinitePostList() {
+ *   const {
+ *     data,
+ *     hasMore,
+ *     fetchNextPage,
+ *     isFetchingNextPage,
+ *   } = useMongoInfiniteFind<Post>('posts', {
+ *     filter: { published: true },
+ *     sort: { createdAt: -1 },
+ *     pageSize: 20,
+ *   });
+ *
+ *   return (
+ *     <FlatList
+ *       data={data}
+ *       keyExtractor={item => item._id}
+ *       renderItem={({ item }) => <PostCard post={item} />}
+ *       onEndReached={hasMore ? fetchNextPage : undefined}
+ *       onEndReachedThreshold={0.5}
+ *       ListFooterComponent={isFetchingNextPage ? <ActivityIndicator /> : null}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useMongoInfiniteFind<T extends Record<string, unknown>>(collection: string, options?: UseMongoInfiniteFindOptions<T>): UseMongoInfiniteFindReturn<T>;
+/**
+ * Count documents in a MongoDB collection
+ *
+ * @example
+ * ```tsx
+ * function UserStats() {
+ *   const { count, isLoading } = useMongoCount<User>('users', {
+ *     filter: { status: 'active' },
+ *   });
+ *
+ *   return <Text>Active users: {isLoading ? '...' : count}</Text>;
+ * }
+ * ```
+ */
+declare function useMongoCount<T extends Record<string, unknown>>(collection: string, options?: UseMongoCountOptions<T>): {
+    count: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * Get distinct values for a field in a MongoDB collection
+ *
+ * @example
+ * ```tsx
+ * function RolePicker() {
+ *   const { values: roles, isLoading } = useMongoDistinct<User, string>('users', 'role');
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *
+ *   return (
+ *     <Picker>
+ *       {roles.map(role => (
+ *         <Picker.Item key={role} label={role} value={role} />
+ *       ))}
+ *     </Picker>
+ *   );
+ * }
+ * ```
+ */
+declare function useMongoDistinct<T extends Record<string, unknown>, TValue = unknown>(collection: string, field: keyof T & string, options?: {
+    filter?: MongoFilter<T>;
+    enabled?: boolean;
+}): {
+    values: TValue[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+
+interface UseAppStateOptions {
+    /** Reconnect realtime on foreground (default: true) */
+    reconnectOnForeground?: boolean;
+    /** Refresh auth session on foreground (default: true) */
+    refreshSessionOnForeground?: boolean;
+    /** Callback when app comes to foreground */
+    onForeground?: () => void;
+    /** Callback when app goes to background */
+    onBackground?: () => void;
+}
+interface UseAppStateReturn {
+    /** Current app state */
+    appState: AppStateStatus;
+    /** Whether app is in foreground */
+    isActive: boolean;
+    /** Whether app is in background */
+    isBackground: boolean;
+    /** Time spent in background (ms) */
+    backgroundDuration: number | null;
+}
+/**
+ * React Native app state hook with auto-reconnection
+ *
+ * Automatically handles realtime reconnection and session refresh
+ * when the app transitions from background to foreground.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { appState, isActive } = useAppState({
+ *     reconnectOnForeground: true,
+ *     refreshSessionOnForeground: true,
+ *     onForeground: () => console.log('App foregrounded'),
+ *     onBackground: () => console.log('App backgrounded'),
+ *   });
+ *
+ *   return <Text>App state: {appState}</Text>;
+ * }
+ * ```
+ */
+declare function useAppState(options?: UseAppStateOptions): UseAppStateReturn;
+/**
+ * Hook for network-aware data fetching
+ *
+ * Provides network connectivity state for React Native apps.
+ * Uses a simple polling approach that works without @react-native-community/netinfo.
+ *
+ * @example
+ * ```tsx
+ * function DataFetcher() {
+ *   const { isConnected, checkConnection } = useNetworkState();
+ *
+ *   if (!isConnected) {
+ *     return <Text>You are offline</Text>;
+ *   }
+ *
+ *   return <MyDataComponent />;
+ * }
+ * ```
+ */
+declare function useNetworkState(): {
+    isConnected: boolean;
+    checkConnection: () => Promise<boolean>;
+};
+/**
+ * OAuth deep linking hook for mobile apps
+ *
+ * Handles OAuth callback URLs via deep linking in React Native / Expo.
+ *
+ * @example
+ * ```tsx
+ * import * as Linking from 'expo-linking';
+ *
+ * function AuthScreen() {
+ *   const { handleDeepLink, isProcessing, error } = useDeepLinkAuth();
+ *
+ *   useEffect(() => {
+ *     const subscription = Linking.addEventListener('url', ({ url }) => {
+ *       handleDeepLink(url);
+ *     });
+ *
+ *     // Handle initial URL (app opened from deep link)
+ *     Linking.getInitialURL().then(url => {
+ *       if (url) handleDeepLink(url);
+ *     });
+ *
+ *     return () => subscription.remove();
+ *   }, [handleDeepLink]);
+ *
+ *   if (isProcessing) return <ActivityIndicator />;
+ *   if (error) return <Text>Auth failed: {error.message}</Text>;
+ *
+ *   return <OAuthButtons />;
+ * }
+ * ```
+ */
+declare function useDeepLinkAuth(): {
+    handleDeepLink: (url: string) => Promise<void>;
+    isProcessing: boolean;
+    error: Error | null;
+};
+
+export { type AsyncStorageInterface, type BroadcastMessage, type MongoQueryStatus, type MutationStatus, type QueryStatus, type UploadOptions, type UseAppStateOptions, type UseAppStateReturn, type UseAuditLogsOptions, type UseAuditLogsReturn, type UseAuthReturn, type UseBatchDeleteReturn, type UseBatchUpdateReturn, type UseBroadcastReturn, type UseChannelOptions, type UseChannelReturn, type UseCountOptions, type UseCountReturn, type UseCreateReturn, type UseDeleteReturn, type UseDownloadReturn, type UseEmailVerificationReturn, type UseErrorTrackingOptions, type UseErrorTrackingReturn, type UseFileReturn, type UseFilesReturn, type UseFunctionListReturn, type UseFunctionOptions, type UseFunctionReturn, type UseIncidentsOptions, type UseIncidentsReturn, type UseInfiniteQueryOptions, type UseInfiniteQueryReturn, type UseMFAReturn, type UseMagicLinkReturn, type UseMetricsOptions, type UseMetricsReturn, type UseMongoAggregateOptions, type UseMongoAggregateReturn, type UseMongoCountOptions, type UseMongoDeleteManyVariables, type UseMongoDeleteOneVariables, type UseMongoFindOneOptions, type UseMongoFindOneReturn, type UseMongoFindOptions, type UseMongoFindReturn, type UseMongoInfiniteFindOptions, type UseMongoInfiniteFindReturn, type UseMongoInsertManyVariables, type UseMongoInsertOneVariables, type UseMongoMutationReturn, type UseMongoUpdateManyVariables, type UseMongoUpdateOneVariables, type UseMutationReturn, type UseOAuthReturn, type UseOptimisticMutationReturn, type UsePaginatedQueryOptions, type UsePaginatedQueryReturn, type UsePasswordResetReturn, type UsePresenceOptions, type UsePresenceReturn, type UseQueryFirstReturn, type UseQueryOptions, type UseQueryReturn, type UseRealtimeStatsOptions, type UseRealtimeStatsReturn, type UseRpcReturn, type UseScheduledFunctionReturn, type UseSubscriptionOptions, type UseSubscriptionReturn, type UseSystemHealthOptions, type UseSystemHealthReturn, type UseUpdateReturn, type UseUploadReturn, type UseUpsertReturn, type VaifContextValue, VaifProvider, type VaifProviderProps, useAppState, useAuditLogs, useAuth, useBatchCreate, useBatchDelete, useBatchInvoke, useBatchUpdate, useBroadcast, useChannel, useCount, useCreate, useDeepLinkAuth, useDelete, useDownload, useEmailVerification, useErrorTracking, useFile, useFiles, useFunction, useFunctionList, useFunctionQuery, useIncidents, useInfiniteQuery, useMFA, useMagicLink, useMetrics, useMongoAggregate, useMongoCollection, useMongoCount, useMongoDeleteMany, useMongoDeleteOne, useMongoDistinct, useMongoFind, useMongoFindOne, useMongoInfiniteFind, useMongoInsertMany, useMongoInsertOne, useMongoUpdateMany, useMongoUpdateOne, useNetworkState, useOAuth, useOptimisticMutation, usePaginatedQuery, usePasswordReset, usePresence, usePublicUrl, useQuery, useQueryById, useQueryFirst, useRealtimeConnection, useRealtimeStats, useRpc, useScheduledFunction, useSubscription, useSystemHealth, useToken, useUpdate, useUpload, useUpsert, useUser, useVaif, useVaifClient };