@vaiftech/sdk-expo 1.0.0 → 1.0.2

package/dist/index.d.mts

@@ -1,7 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
-import { VaifClientConfig, User, VaifClient, AuthResponse, QueryOptions, WhereFilter, OrderByClause, DbOperation, SubscriptionFilter, DbChangeEvent, ConnectionState, PresenceState, PresenceEntry, UploadResult, FileMetadata, RetryConfig, VaifFunction } from '@vaif/client';
-export { AuthResponse, ConnectionState, DbChangeEvent, DbOperation, FileMetadata, InvokeResult, OrderByClause, PresenceState, QueryOptions, UploadResult, User, VaifClient, VaifClientConfig, VaifFunction, WhereFilter } from '@vaif/client';
+import { VaifClientConfig, User, VaifClient, AuthResponse, OAuthProviderType, MFAMethod, MFASetupResponse, QueryOptions, WhereFilter, OrderByClause, DbOperation, SubscriptionFilter, DbChangeEvent, ConnectionState, PresenceState, PresenceEntry, UploadResult, FileMetadata, RetryConfig, VaifFunction } from '@vaiftech/client';
+export { AuthResponse, ConnectionState, DbChangeEvent, DbOperation, FileMetadata, InvokeResult, OrderByClause, PresenceState, QueryOptions, UploadResult, User, VaifClient, VaifClientConfig, VaifFunction, WhereFilter } from '@vaiftech/client';
+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';
 
 /**
  * Storage interface for React Native (AsyncStorage compatible)
@@ -71,6 +72,43 @@ interface UseAuthReturn {
     updateProfile: (updates: Record<string, unknown>) => Promise<User>;
     changePassword: (currentPassword: string, newPassword: string) => Promise<void>;
 }
+interface UsePasswordResetReturn {
+    requestReset: (email: string) => Promise<void>;
+    confirmReset: (token: string, newPassword: string) => Promise<void>;
+    isLoading: boolean;
+    error: Error | null;
+    isRequested: boolean;
+    isConfirmed: boolean;
+}
+interface UseEmailVerificationReturn {
+    requestVerification: (email: string) => Promise<void>;
+    confirmVerification: (token: string) => Promise<void>;
+    isLoading: boolean;
+    error: Error | null;
+    isSent: boolean;
+    isVerified: boolean;
+}
+interface UseMagicLinkReturn {
+    sendMagicLink: (email: string) => Promise<void>;
+    verifyMagicLink: (token: string) => Promise<AuthResponse>;
+    isLoading: boolean;
+    error: Error | null;
+    isSent: boolean;
+}
+interface UseOAuthReturn {
+    signInWithOAuth: (provider: OAuthProviderType, redirectTo?: string) => Promise<{
+        url: string;
+    }>;
+    isLoading: boolean;
+    error: Error | null;
+}
+interface UseMFAReturn {
+    setup: (method: MFAMethod) => Promise<MFASetupResponse>;
+    verify: (mfaToken: string, code: string) => Promise<AuthResponse>;
+    disable: (code: string) => Promise<void>;
+    isLoading: boolean;
+    error: Error | null;
+}
 /**
  * Hook for authentication
  *
@@ -100,6 +138,150 @@ declare function useAuth(): UseAuthReturn;
  * Hook to get just the current user
  */
 declare function useUser(): User | null;
+/**
+ * Hook to get the current access token
+ */
+declare function useToken(): string | null;
+/**
+ * Password reset hook for Expo/React Native
+ *
+ * @example
+ * ```tsx
+ * function ForgotPasswordScreen() {
+ *   const { requestReset, confirmReset, isLoading, isRequested } = usePasswordReset();
+ *
+ *   if (!isRequested) {
+ *     return <Button onPress={() => requestReset(email)} title="Send Reset Link" />;
+ *   }
+ *
+ *   return (
+ *     <View>
+ *       <TextInput placeholder="Enter code" />
+ *       <TextInput placeholder="New password" secureTextEntry />
+ *       <Button onPress={() => confirmReset(token, newPassword)} title="Reset Password" />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function usePasswordReset(): UsePasswordResetReturn;
+/**
+ * Email verification hook for Expo/React Native
+ *
+ * @example
+ * ```tsx
+ * function VerifyEmailScreen() {
+ *   const { requestVerification, confirmVerification, isSent, isVerified } = useEmailVerification();
+ *
+ *   if (isVerified) {
+ *     return <Text>Email verified successfully!</Text>;
+ *   }
+ *
+ *   if (isSent) {
+ *     return (
+ *       <View>
+ *         <TextInput placeholder="Enter verification code" />
+ *         <Button onPress={() => confirmVerification(token)} title="Verify" />
+ *       </View>
+ *     );
+ *   }
+ *
+ *   return <Button onPress={() => requestVerification(email)} title="Send Verification" />;
+ * }
+ * ```
+ */
+declare function useEmailVerification(): UseEmailVerificationReturn;
+/**
+ * Magic link authentication hook for Expo/React Native
+ *
+ * @example
+ * ```tsx
+ * function MagicLinkScreen() {
+ *   const { sendMagicLink, isSent, isLoading } = useMagicLink();
+ *
+ *   if (isSent) {
+ *     return <Text>Check your email for the login link!</Text>;
+ *   }
+ *
+ *   return (
+ *     <Button
+ *       onPress={() => sendMagicLink(email)}
+ *       disabled={isLoading}
+ *       title={isLoading ? 'Sending...' : 'Send Magic Link'}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useMagicLink(): UseMagicLinkReturn;
+/**
+ * OAuth authentication hook for Expo/React Native
+ *
+ * Note: For React Native, you'll need to handle the OAuth flow using
+ * expo-auth-session or react-native-app-auth to open the URL in a browser.
+ *
+ * @example
+ * ```tsx
+ * import * as WebBrowser from 'expo-web-browser';
+ *
+ * function OAuthScreen() {
+ *   const { signInWithOAuth, isLoading, error } = useOAuth();
+ *
+ *   const handleGoogleSignIn = async () => {
+ *     const { url } = await signInWithOAuth('google', 'myapp://auth/callback');
+ *     await WebBrowser.openAuthSessionAsync(url, 'myapp://auth/callback');
+ *   };
+ *
+ *   return (
+ *     <Button
+ *       onPress={handleGoogleSignIn}
+ *       disabled={isLoading}
+ *       title="Sign in with Google"
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useOAuth(): UseOAuthReturn;
+/**
+ * Multi-factor authentication hook for Expo/React Native
+ *
+ * @example
+ * ```tsx
+ * function MFASetupScreen() {
+ *   const { setup, verify, isLoading } = useMFA();
+ *   const [qrCode, setQrCode] = useState<string | null>(null);
+ *   const [mfaToken, setMfaToken] = useState<string | null>(null);
+ *
+ *   const handleSetup = async () => {
+ *     const result = await setup('totp');
+ *     setQrCode(result.qrCode);
+ *   };
+ *
+ *   const handleVerify = async (code: string) => {
+ *     if (mfaToken) {
+ *       await verify(mfaToken, code);
+ *       Alert.alert('Success', 'MFA verified!');
+ *     }
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       {qrCode ? (
+ *         <>
+ *           <Image source={{ uri: qrCode }} style={{ width: 200, height: 200 }} />
+ *           <TextInput placeholder="Enter code" />
+ *           <Button onPress={() => handleVerify(code)} title="Verify" />
+ *         </>
+ *       ) : (
+ *         <Button onPress={handleSetup} title="Enable 2FA" />
+ *       )}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useMFA(): UseMFAReturn;
 
 type QueryStatus = "idle" | "loading" | "success" | "error";
 interface UseQueryOptions extends Omit<QueryOptions, "where" | "orderBy"> {
@@ -121,6 +303,18 @@ interface UseQueryReturn<T> {
     error: Error | null;
     refetch: () => Promise<void>;
 }
+interface UseQueryFirstReturn<T> {
+    /** Query result (single item) */
+    data: T | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Not found state */
+    isNotFound: boolean;
+    /** Refetch function */
+    refetch: () => Promise<void>;
+}
 interface UsePaginatedQueryOptions extends UseQueryOptions {
     pageSize?: number;
     initialPage?: number;
@@ -136,6 +330,50 @@ interface UsePaginatedQueryReturn<T> extends UseQueryReturn<T> {
     previousPage: () => void;
     goToPage: (page: number) => void;
 }
+interface UseInfiniteQueryOptions extends UseQueryOptions {
+    /** Page size for each page */
+    pageSize?: number;
+    /** Callback on success */
+    onSuccess?: (data: unknown[], hasMore: boolean) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UseInfiniteQueryReturn<T> {
+    /** All loaded data (flattened) */
+    data: T[];
+    /** Pages loaded */
+    pages: T[][];
+    /** Whether there's a next page */
+    hasNextPage: boolean;
+    /** Loading state */
+    isLoading: boolean;
+    /** Fetching next page state */
+    isFetchingNextPage: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Fetch next page */
+    fetchNextPage: () => Promise<void>;
+    /** Refetch all pages */
+    refetch: () => Promise<void>;
+    /** Reset to first page */
+    reset: () => void;
+}
+interface UseCountOptions {
+    /** Where conditions */
+    where?: WhereFilter;
+    /** Skip fetching */
+    enabled?: boolean;
+}
+interface UseCountReturn {
+    /** Count result */
+    count: number;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch function */
+    refetch: () => Promise<void>;
+}
 /**
  * Hook for querying data from a table
  *
@@ -179,6 +417,76 @@ declare function useQueryById<T extends Record<string, unknown> = Record<string,
  * Hook for paginated queries
  */
 declare function usePaginatedQuery<T extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: UsePaginatedQueryOptions): UsePaginatedQueryReturn<T>;
+/**
+ * Hook for fetching the first matching record
+ *
+ * @example
+ * ```tsx
+ * function LatestPost() {
+ *   const { data: post, isLoading, isNotFound } = useQueryFirst<Post>('posts', {
+ *     where: { published: true },
+ *     orderBy: { column: 'created_at', direction: 'desc' },
+ *   });
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *   if (isNotFound) return <Text>No posts yet</Text>;
+ *
+ *   return <PostCard post={post} />;
+ * }
+ * ```
+ */
+declare function useQueryFirst<T extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: UseQueryOptions): UseQueryFirstReturn<T>;
+/**
+ * Hook for infinite scroll / load more pagination
+ *
+ * @example
+ * ```tsx
+ * function InfiniteTaskList() {
+ *   const {
+ *     data: tasks,
+ *     isLoading,
+ *     isFetchingNextPage,
+ *     hasNextPage,
+ *     fetchNextPage,
+ *   } = useInfiniteQuery<Task>('tasks', {
+ *     where: { status: 'active' },
+ *     orderBy: { column: 'created_at', direction: 'desc' },
+ *     pageSize: 20,
+ *   });
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *
+ *   return (
+ *     <FlatList
+ *       data={tasks}
+ *       keyExtractor={(item) => item.id}
+ *       renderItem={({ item }) => <TaskItem task={item} />}
+ *       onEndReached={() => hasNextPage && fetchNextPage()}
+ *       onEndReachedThreshold={0.5}
+ *       ListFooterComponent={isFetchingNextPage ? <ActivityIndicator /> : null}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useInfiniteQuery<T extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: UseInfiniteQueryOptions): UseInfiniteQueryReturn<T>;
+/**
+ * Hook for counting records
+ *
+ * @example
+ * ```tsx
+ * function TaskStats() {
+ *   const { count: activeCount, isLoading } = useCount('tasks', {
+ *     where: { status: 'active' },
+ *   });
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *
+ *   return <Text>Active tasks: {activeCount}</Text>;
+ * }
+ * ```
+ */
+declare function useCount(table: string, options?: UseCountOptions): UseCountReturn;
 
 type MutationStatus = "idle" | "loading" | "success" | "error";
 interface UseMutationReturn<T, TInput = Partial<T>> {
@@ -323,6 +631,121 @@ declare function useBatchCreate<T extends Record<string, unknown> = Record<strin
     isError: boolean;
     error: Error | null;
 };
+interface UseBatchUpdateReturn<T> {
+    batchUpdate: (where: WhereFilter, data: Partial<T>) => Promise<{
+        count: number;
+        records?: T[];
+    }>;
+    data: {
+        count: number;
+        records?: T[];
+    } | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+interface UseBatchDeleteReturn {
+    batchDelete: (where: WhereFilter) => Promise<{
+        count: number;
+    }>;
+    data: {
+        count: number;
+    } | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+interface UseOptimisticMutationReturn<TData, TVariables> {
+    mutate: (variables: TVariables) => void;
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    optimisticData: TData;
+    rollback: () => void;
+    isLoading: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for batch updating records
+ *
+ * @example
+ * ```tsx
+ * function BulkUpdateStatus() {
+ *   const { batchUpdate, isLoading, data } = useBatchUpdate<Task>('tasks');
+ *
+ *   const markAllComplete = async () => {
+ *     await batchUpdate(
+ *       { assigneeId: currentUserId },
+ *       { status: 'completed' }
+ *     );
+ *   };
+ *
+ *   return (
+ *     <Button onPress={markAllComplete} disabled={isLoading}>
+ *       {isLoading ? `Updating... ${data?.count || 0}` : 'Mark All Complete'}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useBatchUpdate<T extends Record<string, unknown> = Record<string, unknown>>(table: string): UseBatchUpdateReturn<T>;
+/**
+ * Hook for batch deleting records
+ *
+ * @example
+ * ```tsx
+ * function BulkDelete() {
+ *   const { batchDelete, isLoading, data } = useBatchDelete('items');
+ *
+ *   const deleteOldItems = async () => {
+ *     await batchDelete({ createdAt: { lt: thirtyDaysAgo } });
+ *   };
+ *
+ *   return (
+ *     <Button onPress={deleteOldItems} disabled={isLoading}>
+ *       {isLoading ? 'Deleting...' : `Delete old items (${data?.count || 0} deleted)`}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useBatchDelete(table: string): UseBatchDeleteReturn;
+/**
+ * Hook for optimistic mutations
+ *
+ * @example
+ * ```tsx
+ * function LikeButton({ postId, likes }: { postId: string; likes: number }) {
+ *   const client = useVaifClient();
+ *
+ *   const { mutate, optimisticData, isLoading } = useOptimisticMutation(
+ *     likes,
+ *     async () => {
+ *       const result = await client.from('posts').update(postId, { likes: likes + 1 });
+ *       return result.data.likes;
+ *     },
+ *     {
+ *       optimisticUpdate: (current) => current + 1,
+ *       onError: () => {
+ *         Alert.alert('Error', 'Failed to like post');
+ *       },
+ *     }
+ *   );
+ *
+ *   return (
+ *     <TouchableOpacity onPress={() => mutate()}>
+ *       <Text>{optimisticData} likes</Text>
+ *     </TouchableOpacity>
+ *   );
+ * }
+ * ```
+ */
+declare function useOptimisticMutation<TData, TVariables = void>(currentData: TData, mutationFn: (variables: TVariables) => Promise<TData>, options: {
+    optimisticUpdate: (current: TData, variables: TVariables) => TData;
+    onSuccess?: (data: TData, variables: TVariables) => void;
+    onError?: (error: Error, variables: TVariables) => void;
+    onSettled?: (data: TData | undefined, error: Error | null, variables: TVariables) => void;
+}): UseOptimisticMutationReturn<TData, TVariables>;
 
 interface UseSubscriptionOptions<T> {
     /** Filter by operation type */
@@ -374,6 +797,29 @@ interface UseBroadcastReturn<T> {
     /** Connection state */
     isConnected: boolean;
 }
+interface UseChannelOptions {
+    /** Channel type */
+    type?: "public" | "private" | "presence";
+    /** Skip subscription */
+    enabled?: boolean;
+}
+interface BroadcastMessage<T = unknown> {
+    event: string;
+    payload: T;
+    senderId?: string;
+}
+interface UseChannelReturn<T> {
+    /** Send a broadcast message */
+    broadcast: (event: string, payload: T) => void;
+    /** Last received broadcast */
+    lastMessage: BroadcastMessage<T> | null;
+    /** All broadcast messages received */
+    messages: BroadcastMessage<T>[];
+    /** Whether channel is joined */
+    isJoined: boolean;
+    /** Leave channel */
+    leave: () => void;
+}
 /**
  * Hook for realtime database subscriptions
  *
@@ -445,6 +891,35 @@ declare function usePresence<T extends PresenceState = PresenceState>(channelNam
  * ```
  */
 declare function useBroadcast<T = unknown>(channelName: string): UseBroadcastReturn<T>;
+/**
+ * Hook for joining a realtime channel
+ *
+ * @example
+ * ```tsx
+ * function ChatRoom({ roomId }: { roomId: string }) {
+ *   const { broadcast, messages, isJoined } = useChannel<{ text: string; userId: string }>(
+ *     `room:${roomId}`
+ *   );
+ *
+ *   const sendMessage = (text: string) => {
+ *     broadcast('message', { text, userId: currentUser.id });
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       {!isJoined && <ActivityIndicator />}
+ *       <FlatList
+ *         data={messages}
+ *         keyExtractor={(_, index) => index.toString()}
+ *         renderItem={({ item }) => <Text>{item.payload.text}</Text>}
+ *       />
+ *       <MessageInput onSend={sendMessage} />
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useChannel<T = unknown>(channelName: string, options?: UseChannelOptions): UseChannelReturn<T>;
 /**
  * Hook for realtime connection state
  */
@@ -601,6 +1076,22 @@ interface UseFunctionListReturn {
     error: Error | null;
     refetch: () => Promise<void>;
 }
+interface UseScheduledFunctionReturn<TInput> {
+    /** Schedule function execution with delay */
+    schedule: (input: TInput, options: {
+        delayMs: number;
+    }) => Promise<string>;
+    /** Cancel scheduled execution */
+    cancel: () => Promise<void>;
+    /** Whether function is currently scheduled */
+    isScheduled: boolean;
+    /** Scheduled execution time */
+    scheduledAt: Date | null;
+    /** Request ID for tracking */
+    requestId: string | null;
+    /** Error state */
+    error: Error | null;
+}
 /**
  * Hook for invoking serverless functions
  *
@@ -692,5 +1183,39 @@ declare function useBatchInvoke<TOutput = unknown>(): {
     isLoading: boolean;
     errors: (Error | null)[];
 };
+/**
+ * Hook for scheduling deferred function invocations
+ *
+ * @example
+ * ```tsx
+ * function ScheduleReminder() {
+ *   const { schedule, cancel, isScheduled, scheduledAt } = useScheduledFunction<{ userId: string; message: string }>(
+ *     'send-reminder'
+ *   );
+ *
+ *   const handleSchedule = async () => {
+ *     await schedule(
+ *       { userId: currentUser.id, message: 'Follow up on task' },
+ *       { delayMs: 24 * 60 * 60 * 1000 } // 24 hours
+ *     );
+ *     Alert.alert('Reminder scheduled!');
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       {isScheduled ? (
+ *         <>
+ *           <Text>Scheduled for {scheduledAt?.toLocaleString()}</Text>
+ *           <Button onPress={cancel} title="Cancel" />
+ *         </>
+ *       ) : (
+ *         <Button onPress={handleSchedule} title="Schedule Reminder" />
+ *       )}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useScheduledFunction<TInput = unknown>(functionId: string): UseScheduledFunctionReturn<TInput>;
 
-export { type AsyncStorageInterface, type MutationStatus, type QueryStatus, type UploadOptions, type UseAuthReturn, type UseBroadcastReturn, type UseCreateReturn, type UseDeleteReturn, type UseDownloadReturn, type UseFileReturn, type UseFilesReturn, type UseFunctionListReturn, type UseFunctionOptions, type UseFunctionReturn, type UseMutationReturn, type UsePaginatedQueryOptions, type UsePaginatedQueryReturn, type UsePresenceOptions, type UsePresenceReturn, type UseQueryOptions, type UseQueryReturn, type UseRpcReturn, type UseSubscriptionOptions, type UseSubscriptionReturn, type UseUpdateReturn, type UseUploadReturn, type UseUpsertReturn, type VaifContextValue, VaifProvider, type VaifProviderProps, useAuth, useBatchCreate, useBatchInvoke, useBroadcast, useCreate, useDelete, useDownload, useFile, useFiles, useFunction, useFunctionList, useFunctionQuery, usePaginatedQuery, usePresence, usePublicUrl, useQuery, useQueryById, useRealtimeConnection, useRpc, useSubscription, useUpdate, useUpload, useUpsert, useUser, useVaif, useVaifClient };
+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 };