@vaiftech/react 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1609 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { VaifClientConfig, User, VaifClient, AuthResponse, OAuthProviderType, MFAMethod, MFASetupResponse, QueryOptions, PaginatedResult, WhereFilter, DbOperation, DbChangeEvent, PresenceState, PresenceEntry, ConnectionState, UploadOptions, UploadResult, FileMetadata, InvokeResult, VaifFunction } from '@vaif/client';
+export { AuthResponse, ConnectionState, DbChangeEvent, DbOperation, FileMetadata, InvokeResult, OrderByClause, PresenceState, QueryOptions, UploadResult, User, VaifClient, VaifClientConfig, VaifFunction, WhereFilter } from '@vaif/client';
+
+interface VaifContextValue {
+    /** The VAIF client instance */
+    client: VaifClient;
+    /** Current authenticated user (null if not authenticated) */
+    user: User | null;
+    /** Current access token */
+    token: string | null;
+    /** Whether authentication is being checked */
+    isLoading: boolean;
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Sign in with email/password */
+    signIn: (email: string, password: string) => Promise<AuthResponse>;
+    /** Sign up with email/password */
+    signUp: (email: string, password: string, metadata?: Record<string, unknown>) => Promise<AuthResponse>;
+    /** Sign out the current user */
+    signOut: () => Promise<void>;
+    /** Refresh the session */
+    refreshSession: () => Promise<void>;
+    /** Update the current user in state */
+    updateUser: (updates: Partial<User>) => void;
+}
+interface VaifProviderProps {
+    /** VAIF client configuration */
+    config: VaifClientConfig;
+    /** Child components */
+    children: ReactNode;
+    /** Callback when auth state changes */
+    onAuthStateChange?: (user: User | null) => void;
+    /** Auto refresh session before expiry (default: true) */
+    autoRefreshSession?: boolean;
+    /** Storage key for session persistence (default: 'vaif-auth') */
+    storageKey?: string;
+}
+declare function VaifProvider({ config, children, onAuthStateChange, autoRefreshSession, storageKey, }: VaifProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Access the VAIF context
+ *
+ * @throws Error if used outside VaifProvider
+ */
+declare function useVaif(): VaifContextValue;
+/**
+ * Access only the VAIF client (lightweight alternative to useVaif)
+ */
+declare function useVaifClient(): VaifClient;
+
+interface UseAuthReturn {
+    /** Current user */
+    user: User | null;
+    /** Current access token */
+    token: string | null;
+    /** Whether auth is loading */
+    isLoading: boolean;
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Sign in with email/password */
+    signIn: (email: string, password: string) => Promise<AuthResponse>;
+    /** Sign up with email/password */
+    signUp: (email: string, password: string, metadata?: Record<string, unknown>) => Promise<AuthResponse>;
+    /** Sign out */
+    signOut: () => Promise<void>;
+    /** Refresh session */
+    refreshSession: () => Promise<void>;
+}
+interface UsePasswordResetReturn {
+    /** Request password reset email */
+    requestReset: (email: string) => Promise<void>;
+    /** Confirm password reset with token */
+    confirmReset: (token: string, newPassword: string) => Promise<void>;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Whether reset was requested */
+    isRequested: boolean;
+    /** Whether reset was confirmed */
+    isConfirmed: boolean;
+}
+interface UseEmailVerificationReturn {
+    /** Request verification email */
+    requestVerification: (email: string) => Promise<void>;
+    /** Confirm email with token */
+    confirmVerification: (token: string) => Promise<void>;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Whether verification was sent */
+    isSent: boolean;
+    /** Whether email was verified */
+    isVerified: boolean;
+}
+interface UseMagicLinkReturn {
+    /** Send magic link */
+    sendMagicLink: (email: string) => Promise<void>;
+    /** Verify magic link token */
+    verifyMagicLink: (token: string) => Promise<AuthResponse>;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Whether link was sent */
+    isSent: boolean;
+}
+interface UseOAuthReturn {
+    /** Start OAuth flow */
+    signInWithOAuth: (provider: OAuthProviderType, redirectTo?: string) => Promise<void>;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+}
+interface UseMFAReturn {
+    /** Set up MFA */
+    setup: (method: MFAMethod) => Promise<MFASetupResponse>;
+    /** Verify MFA with token and code */
+    verify: (mfaToken: string, code: string) => Promise<AuthResponse>;
+    /** Disable MFA */
+    disable: (code: string) => Promise<void>;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+}
+/**
+ * Main authentication hook
+ *
+ * @example
+ * ```tsx
+ * function LoginForm() {
+ *   const { signIn, isLoading, user } = useAuth();
+ *
+ *   const handleSubmit = async (e: FormEvent) => {
+ *     e.preventDefault();
+ *     await signIn(email, password);
+ *   };
+ *
+ *   if (user) {
+ *     return <div>Welcome, {user.email}!</div>;
+ *   }
+ *
+ *   return <form onSubmit={handleSubmit}>...</form>;
+ * }
+ * ```
+ */
+declare function useAuth(): UseAuthReturn;
+/**
+ * Hook for getting the current user only
+ *
+ * @example
+ * ```tsx
+ * function UserAvatar() {
+ *   const user = useUser();
+ *   if (!user) return null;
+ *   return <img src={user.avatarUrl} alt={user.name} />;
+ * }
+ * ```
+ */
+declare function useUser(): User | null;
+/**
+ * Hook for getting the current access token
+ */
+declare function useToken(): string | null;
+/**
+ * Password reset hook
+ *
+ * @example
+ * ```tsx
+ * function ForgotPassword() {
+ *   const { requestReset, confirmReset, isLoading, isRequested } = usePasswordReset();
+ *
+ *   if (!isRequested) {
+ *     return <button onClick={() => requestReset(email)}>Send Reset Link</button>;
+ *   }
+ *
+ *   return (
+ *     <form onSubmit={() => confirmReset(email, code, newPassword)}>
+ *       <input placeholder="Enter code" />
+ *       <input type="password" placeholder="New password" />
+ *       <button type="submit">Reset Password</button>
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+declare function usePasswordReset(): UsePasswordResetReturn;
+/**
+ * Email verification hook
+ *
+ * @example
+ * ```tsx
+ * function VerifyEmail() {
+ *   const { requestVerification, confirmVerification, isSent, isVerified } = useEmailVerification();
+ *
+ *   if (isVerified) {
+ *     return <div>Email verified successfully!</div>;
+ *   }
+ *
+ *   if (isSent) {
+ *     return (
+ *       <form onSubmit={() => confirmVerification(email, code)}>
+ *         <input placeholder="Enter verification code" />
+ *         <button type="submit">Verify</button>
+ *       </form>
+ *     );
+ *   }
+ *
+ *   return <button onClick={() => requestVerification(email)}>Send Verification</button>;
+ * }
+ * ```
+ */
+declare function useEmailVerification(): UseEmailVerificationReturn;
+/**
+ * Magic link authentication hook
+ *
+ * @example
+ * ```tsx
+ * function MagicLinkLogin() {
+ *   const { sendMagicLink, isSent, isLoading } = useMagicLink();
+ *
+ *   if (isSent) {
+ *     return <div>Check your email for the login link!</div>;
+ *   }
+ *
+ *   return (
+ *     <button onClick={() => sendMagicLink(email)} disabled={isLoading}>
+ *       {isLoading ? 'Sending...' : 'Send Magic Link'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useMagicLink(): UseMagicLinkReturn;
+/**
+ * OAuth authentication hook
+ *
+ * @example
+ * ```tsx
+ * function OAuthButtons() {
+ *   const { signInWithOAuth, isLoading } = useOAuth();
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => signInWithOAuth('google')} disabled={isLoading}>
+ *         Sign in with Google
+ *       </button>
+ *       <button onClick={() => signInWithOAuth('github')} disabled={isLoading}>
+ *         Sign in with GitHub
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useOAuth(): UseOAuthReturn;
+/**
+ * Multi-factor authentication hook
+ *
+ * @example
+ * ```tsx
+ * function MFASetup() {
+ *   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('MFA verified!');
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {qrCode ? (
+ *         <>
+ *           <img src={qrCode} alt="Scan with authenticator app" />
+ *           <input placeholder="Enter code" />
+ *           <button onClick={() => handleVerify(code)}>Verify</button>
+ *         </>
+ *       ) : (
+ *         <button onClick={handleSetup}>Enable 2FA</button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useMFA(): UseMFAReturn;
+
+type QueryStatus = "idle" | "loading" | "success" | "error";
+interface UseQueryOptions<T extends Record<string, unknown>> extends Partial<QueryOptions<T>> {
+    /** Enable/disable the query */
+    enabled?: boolean;
+    /** Refetch on window focus */
+    refetchOnWindowFocus?: boolean;
+    /** Refetch interval in ms (0 = disabled) */
+    refetchInterval?: number;
+    /** Keep previous data while fetching new */
+    keepPreviousData?: boolean;
+    /** Callback on success */
+    onSuccess?: (data: T[]) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Initial data */
+    initialData?: T[];
+    /** Stale time in ms (default: 0) */
+    staleTime?: number;
+}
+interface UseQueryReturn<T> {
+    /** Query result data */
+    data: T[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Fetching state (loading or refetching) */
+    isFetching: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Query status */
+    status: QueryStatus;
+    /** Refetch function */
+    refetch: () => Promise<void>;
+    /** Whether data is stale */
+    isStale: boolean;
+    /** Whether query is enabled */
+    isEnabled: boolean;
+}
+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<T extends Record<string, unknown>> extends Partial<QueryOptions<T>> {
+    /** Page size */
+    pageSize?: number;
+    /** Initial page */
+    initialPage?: number;
+    /** Callback on success */
+    onSuccess?: (result: PaginatedResult<T>) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+interface UsePaginatedQueryReturn<T> {
+    /** Current page data */
+    data: T[];
+    /** Current page number (1-indexed) */
+    page: number;
+    /** Page size */
+    pageSize: number;
+    /** Total items count */
+    totalCount: number;
+    /** Total pages count */
+    totalPages: number;
+    /** Whether there's a next page */
+    hasNextPage: boolean;
+    /** Whether there's a previous page */
+    hasPrevPage: boolean;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Go to next page */
+    nextPage: () => void;
+    /** Go to previous page */
+    prevPage: () => void;
+    /** Go to specific page */
+    goToPage: (page: number) => void;
+    /** Refetch current page */
+    refetch: () => Promise<void>;
+}
+interface UseInfiniteQueryOptions<T extends Record<string, unknown>> extends Partial<QueryOptions<T>> {
+    /** Page size */
+    pageSize?: number;
+    /** Callback on success */
+    onSuccess?: (data: T[], 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;
+}
+/**
+ * Query hook for fetching multiple records
+ *
+ * @example
+ * ```tsx
+ * function UserList() {
+ *   const { data, isLoading, error, refetch } = useQuery<User>('users', {
+ *     where: { status: 'active' },
+ *     orderBy: { field: 'createdAt', direction: 'desc' },
+ *     limit: 20,
+ *     onSuccess: (users) => console.log('Loaded', users.length, 'users'),
+ *   });
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *
+ *   return (
+ *     <ul>
+ *       {data.map(user => (
+ *         <li key={user.id}>{user.name}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useQuery<T extends Record<string, unknown>>(table: string, options?: UseQueryOptions<T>): UseQueryReturn<T>;
+/**
+ * Query hook for fetching a single record by ID
+ *
+ * @example
+ * ```tsx
+ * function UserProfile({ userId }: { userId: string }) {
+ *   const { data: user, isLoading, error } = useQueryById<User>('users', userId);
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (!user) return <NotFound />;
+ *
+ *   return <div>{user.name}</div>;
+ * }
+ * ```
+ */
+declare function useQueryById<T extends Record<string, unknown>>(table: string, id: string | null, options?: {
+    enabled?: boolean;
+}): UseQueryFirstReturn<T>;
+/**
+ * Query hook for fetching the first matching record
+ *
+ * @example
+ * ```tsx
+ * function LatestPost() {
+ *   const { data: post, isLoading } = useQueryFirst<Post>('posts', {
+ *     where: { published: true },
+ *     orderBy: { field: 'createdAt', direction: 'desc' },
+ *   });
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (!post) return <Empty message="No posts yet" />;
+ *
+ *   return <PostCard post={post} />;
+ * }
+ * ```
+ */
+declare function useQueryFirst<T extends Record<string, unknown>>(table: string, options?: UseQueryOptions<T>): UseQueryFirstReturn<T>;
+/**
+ * Paginated query hook with page navigation
+ *
+ * @example
+ * ```tsx
+ * function UserTable() {
+ *   const {
+ *     data,
+ *     page,
+ *     totalPages,
+ *     hasNextPage,
+ *     hasPrevPage,
+ *     nextPage,
+ *     prevPage,
+ *     isLoading,
+ *   } = usePaginatedQuery<User>('users', {
+ *     pageSize: 10,
+ *     orderBy: { field: 'createdAt', direction: 'desc' },
+ *   });
+ *
+ *   return (
+ *     <>
+ *       <table>
+ *         {data.map(user => <UserRow key={user.id} user={user} />)}
+ *       </table>
+ *       <div>
+ *         <button onClick={prevPage} disabled={!hasPrevPage}>Previous</button>
+ *         <span>Page {page} of {totalPages}</span>
+ *         <button onClick={nextPage} disabled={!hasNextPage}>Next</button>
+ *       </div>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function usePaginatedQuery<T extends Record<string, unknown>>(table: string, options?: UsePaginatedQueryOptions<T>): UsePaginatedQueryReturn<T>;
+/**
+ * Infinite scroll query hook
+ *
+ * @example
+ * ```tsx
+ * function InfiniteUserList() {
+ *   const {
+ *     data,
+ *     hasNextPage,
+ *     fetchNextPage,
+ *     isFetchingNextPage,
+ *     isLoading,
+ *   } = useInfiniteQuery<User>('users', {
+ *     pageSize: 20,
+ *     orderBy: { field: 'createdAt', direction: 'desc' },
+ *   });
+ *
+ *   const loadMoreRef = useRef<HTMLDivElement>(null);
+ *
+ *   // Intersection observer for infinite scroll
+ *   useEffect(() => {
+ *     const observer = new IntersectionObserver(([entry]) => {
+ *       if (entry.isIntersecting && hasNextPage && !isFetchingNextPage) {
+ *         fetchNextPage();
+ *       }
+ *     });
+ *
+ *     if (loadMoreRef.current) {
+ *       observer.observe(loadMoreRef.current);
+ *     }
+ *
+ *     return () => observer.disconnect();
+ *   }, [hasNextPage, isFetchingNextPage, fetchNextPage]);
+ *
+ *   if (isLoading) return <Spinner />;
+ *
+ *   return (
+ *     <>
+ *       {data.map(user => <UserCard key={user.id} user={user} />)}
+ *       <div ref={loadMoreRef}>
+ *         {isFetchingNextPage && <Spinner />}
+ *       </div>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useInfiniteQuery<T extends Record<string, unknown>>(table: string, options?: UseInfiniteQueryOptions<T>): UseInfiniteQueryReturn<T>;
+/**
+ * Count query hook
+ *
+ * @example
+ * ```tsx
+ * function UserStats() {
+ *   const { count, isLoading } = useCount('users', {
+ *     where: { status: 'active' }
+ *   });
+ *
+ *   return <div>Active users: {isLoading ? '...' : count}</div>;
+ * }
+ * ```
+ */
+declare function useCount(table: string, options?: {
+    where?: WhereFilter;
+    enabled?: boolean;
+}): {
+    count: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+
+type MutationStatus = "idle" | "loading" | "success" | "error";
+interface UseMutationOptions<TData, TVariables> {
+    /** Callback on success */
+    onSuccess?: (data: TData, variables: TVariables) => void | Promise<void>;
+    /** Callback on error */
+    onError?: (error: Error, variables: TVariables) => void | Promise<void>;
+    /** Callback on mutation settled (success or error) */
+    onSettled?: (data: TData | undefined, error: Error | null, variables: TVariables) => void | Promise<void>;
+    /** Callback before mutation starts */
+    onMutate?: (variables: TVariables) => void | Promise<void>;
+    /** Retry count on failure (default: 0) */
+    retry?: number;
+    /** Retry delay in ms (default: 1000) */
+    retryDelay?: number;
+}
+interface UseMutationReturn<TData, TVariables> {
+    /** Execute the mutation */
+    mutate: (variables: TVariables) => void;
+    /** Execute the mutation (async) */
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    /** Mutation result data */
+    data: TData | undefined;
+    /** Error state */
+    error: Error | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Success state */
+    isSuccess: boolean;
+    /** Error state (boolean) */
+    isError: boolean;
+    /** Idle state */
+    isIdle: boolean;
+    /** Mutation status */
+    status: MutationStatus;
+    /** Reset mutation state */
+    reset: () => void;
+}
+interface UseCreateOptions<T> extends UseMutationOptions<T, Partial<T>> {
+    /** Invalidate query cache for this table after mutation */
+    invalidateQueries?: boolean;
+}
+interface UseUpdateOptions<T> extends UseMutationOptions<T, {
+    id: string;
+    data: Partial<T>;
+}> {
+    invalidateQueries?: boolean;
+}
+interface UseDeleteOptions extends UseMutationOptions<void, string> {
+    invalidateQueries?: boolean;
+}
+interface UseUpsertOptions<T extends Record<string, unknown>> extends UseMutationOptions<T, {
+    data: Partial<T>;
+    conflictFields: (keyof T)[];
+    updateFields?: (keyof T)[];
+}> {
+    invalidateQueries?: boolean;
+}
+/**
+ * Generic mutation hook
+ *
+ * @example
+ * ```tsx
+ * function CreateUserForm() {
+ *   const { mutate, isLoading, error, isSuccess } = useMutation(
+ *     async (data: CreateUserInput) => {
+ *       const response = await fetch('/api/users', {
+ *         method: 'POST',
+ *         body: JSON.stringify(data),
+ *       });
+ *       return response.json();
+ *     },
+ *     {
+ *       onSuccess: (user) => {
+ *         console.log('User created:', user);
+ *       },
+ *     }
+ *   );
+ *
+ *   const handleSubmit = (data: CreateUserInput) => {
+ *     mutate(data);
+ *   };
+ *
+ *   return <form onSubmit={handleSubmit}>...</form>;
+ * }
+ * ```
+ */
+declare function useMutation<TData, TVariables = void>(mutationFn: (variables: TVariables) => Promise<TData>, options?: UseMutationOptions<TData, TVariables>): UseMutationReturn<TData, TVariables>;
+/**
+ * Create mutation hook for a table
+ *
+ * @example
+ * ```tsx
+ * function CreatePost() {
+ *   const { mutate, isLoading, isSuccess } = useCreate<Post>('posts', {
+ *     onSuccess: (post) => {
+ *       console.log('Post created:', post.id);
+ *     },
+ *   });
+ *
+ *   return (
+ *     <button onClick={() => mutate({ title: 'New Post', content: '...' })}>
+ *       {isLoading ? 'Creating...' : 'Create Post'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCreate<T extends Record<string, unknown>>(table: string, options?: UseCreateOptions<T>): UseMutationReturn<T, Partial<T>>;
+/**
+ * Update mutation hook for a table
+ *
+ * @example
+ * ```tsx
+ * function EditPost({ postId }: { postId: string }) {
+ *   const { mutate, isLoading } = useUpdate<Post>('posts', {
+ *     onSuccess: (post) => {
+ *       toast.success('Post updated!');
+ *     },
+ *   });
+ *
+ *   return (
+ *     <button onClick={() => mutate({ id: postId, data: { title: 'Updated Title' } })}>
+ *       {isLoading ? 'Saving...' : 'Save'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useUpdate<T extends Record<string, unknown>>(table: string, options?: UseUpdateOptions<T>): UseMutationReturn<T, {
+    id: string;
+    data: Partial<T>;
+}>;
+/**
+ * Delete mutation hook for a table
+ *
+ * @example
+ * ```tsx
+ * function DeletePost({ postId }: { postId: string }) {
+ *   const { mutate, isLoading } = useDelete('posts', {
+ *     onSuccess: () => {
+ *       toast.success('Post deleted');
+ *       navigate('/posts');
+ *     },
+ *   });
+ *
+ *   return (
+ *     <button onClick={() => mutate(postId)} disabled={isLoading}>
+ *       {isLoading ? 'Deleting...' : 'Delete'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useDelete(table: string, options?: UseDeleteOptions): UseMutationReturn<void, string>;
+/**
+ * Upsert mutation hook for a table
+ *
+ * @example
+ * ```tsx
+ * function SaveProfile({ userId }: { userId: string }) {
+ *   const { mutate, isLoading } = useUpsert<Profile>('profiles', {
+ *     onSuccess: (profile) => {
+ *       toast.success('Profile saved');
+ *     },
+ *   });
+ *
+ *   return (
+ *     <button onClick={() => mutate({
+ *       data: { userId, bio: 'Hello world' },
+ *       conflictFields: ['userId']
+ *     })}>
+ *       {isLoading ? 'Saving...' : 'Save Profile'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useUpsert<T extends Record<string, unknown>>(table: string, options?: UseUpsertOptions<T>): UseMutationReturn<T, {
+    data: Partial<T>;
+    conflictFields: (keyof T)[];
+    updateFields?: (keyof T)[];
+}>;
+/**
+ * Batch create mutation hook
+ *
+ * @example
+ * ```tsx
+ * function ImportUsers() {
+ *   const { mutate, isLoading, data } = useBatchCreate<User>('users');
+ *
+ *   const handleImport = (users: Partial<User>[]) => {
+ *     mutate(users);
+ *   };
+ *
+ *   return (
+ *     <>
+ *       <input type="file" onChange={handleFileSelect} />
+ *       <button onClick={handleImport} disabled={isLoading}>
+ *         {isLoading ? `Importing... ${data?.count || 0}` : 'Import'}
+ *       </button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useBatchCreate<T extends Record<string, unknown>>(table: string, options?: UseMutationOptions<{
+    count: number;
+    records?: T[];
+}, Partial<T>[]>): UseMutationReturn<{
+    count: number;
+    records?: T[];
+}, Partial<T>[]>;
+/**
+ * Batch update mutation hook - updates all records matching the where clause
+ *
+ * @example
+ * ```tsx
+ * function BulkUpdateStatus() {
+ *   const { mutate, isLoading, data } = useBatchUpdate<Task>('tasks');
+ *
+ *   const markAllComplete = () => {
+ *     mutate({
+ *       data: { status: 'completed' },
+ *       where: { assigneeId: currentUserId }
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={markAllComplete}>
+ *       {isLoading ? `Updating... ${data?.count || 0}` : 'Mark All Complete'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useBatchUpdate<T extends Record<string, unknown>>(table: string, options?: UseMutationOptions<{
+    count: number;
+    records?: T[];
+}, {
+    data: Partial<T>;
+    where: WhereFilter;
+}>): UseMutationReturn<{
+    count: number;
+    records?: T[];
+}, {
+    data: Partial<T>;
+    where: WhereFilter;
+}>;
+/**
+ * Batch delete mutation hook - deletes all records matching the where clause
+ *
+ * @example
+ * ```tsx
+ * function BulkDelete() {
+ *   const { mutate, isLoading, data } = useBatchDelete('items');
+ *
+ *   const deleteOldItems = () => {
+ *     mutate({ olderThan: { lt: thirtyDaysAgo } });
+ *   };
+ *
+ *   return (
+ *     <button onClick={deleteOldItems}>
+ *       {isLoading ? 'Deleting...' : `Delete old items (${data?.count || 0} deleted)`}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useBatchDelete(table: string, options?: UseMutationOptions<{
+    count: number;
+}, WhereFilter>): UseMutationReturn<{
+    count: number;
+}, WhereFilter>;
+/**
+ * Optimistic update helper hook
+ *
+ * @example
+ * ```tsx
+ * function LikeButton({ postId, likes }: { postId: string; likes: number }) {
+ *   const { mutate, optimisticData, rollback } = useOptimisticMutation(
+ *     likes,
+ *     async () => {
+ *       await vaif.from('posts').update(postId, { likes: likes + 1 });
+ *     },
+ *     {
+ *       optimisticUpdate: (current) => current + 1,
+ *       onError: () => {
+ *         toast.error('Failed to like post');
+ *       },
+ *     }
+ *   );
+ *
+ *   return (
+ *     <button onClick={() => mutate()}>
+ *       {optimisticData} likes
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+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;
+}): {
+    mutate: (variables: TVariables) => void;
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    optimisticData: TData;
+    rollback: () => void;
+    isLoading: boolean;
+    error: Error | null;
+};
+
+interface UseRealtimeOptions {
+    /** Enable/disable the subscription */
+    enabled?: boolean;
+}
+interface UseSubscriptionOptions<T = Record<string, unknown>> extends UseRealtimeOptions {
+    /** Filter by operations */
+    operations?: DbOperation[];
+    /** Filter expression */
+    filter?: string;
+    /** Callback on insert */
+    onInsert?: (record: T) => void;
+    /** Callback on update */
+    onUpdate?: (record: T, old: T | null) => void;
+    /** Callback on delete */
+    onDelete?: (record: T) => void;
+    /** Callback on any change */
+    onChange?: (event: DbChangeEvent<T>) => void;
+}
+interface UseSubscriptionReturn<T> {
+    /** Latest received record */
+    data: T | null;
+    /** All changes received */
+    changes: DbChangeEvent<T>[];
+    /** Whether subscribed */
+    isSubscribed: boolean;
+    /** Clear changes history */
+    clearChanges: () => void;
+}
+interface UseChannelOptions extends UseRealtimeOptions {
+    /** Channel type */
+    type?: "public" | "private" | "presence";
+}
+interface BroadcastMessage<T = unknown> {
+    event: string;
+    payload: T;
+    senderId?: string;
+}
+interface UseChannelReturn<TMessage = unknown> {
+    /** Send a broadcast message */
+    broadcast: (event: string, payload: TMessage) => void;
+    /** Last received broadcast */
+    lastMessage: BroadcastMessage<TMessage> | null;
+    /** All broadcast messages received */
+    messages: BroadcastMessage<TMessage>[];
+    /** Whether channel is joined */
+    isJoined: boolean;
+    /** Leave channel */
+    leave: () => void;
+}
+interface UsePresenceOptions {
+    /** Enable/disable */
+    enabled?: boolean;
+}
+interface UsePresenceReturn<T extends PresenceState> {
+    /** Current presence state (all users) */
+    presence: Record<string, PresenceEntry<T>[]>;
+    /** Number of online users */
+    count: number;
+    /** List of online user keys */
+    onlineUsers: string[];
+    /** Update own presence state */
+    update: (state: Partial<T>) => void;
+    /** Leave presence (go offline) */
+    leave: () => void;
+    /** Whether currently tracked */
+    isTracking: boolean;
+}
+/**
+ * Subscribe to database table changes in real-time
+ *
+ * @example
+ * ```tsx
+ * function MessageList() {
+ *   const { data, changes } = useSubscription<Message>('messages', {
+ *     operations: ['INSERT'],
+ *     onInsert: (message) => {
+ *       playNotificationSound();
+ *     },
+ *   });
+ *
+ *   return (
+ *     <ul>
+ *       {changes.map((change, i) => (
+ *         <li key={i}>{change.new?.text}</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useSubscription<T = Record<string, unknown>>(table: string, options?: UseSubscriptionOptions<T>): UseSubscriptionReturn<T>;
+/**
+ * Join a realtime channel for broadcast
+ *
+ * @example
+ * ```tsx
+ * function ChatRoom({ roomId }: { roomId: string }) {
+ *   const { broadcast, messages } = useChannel<ChatMessage>(`room:${roomId}`);
+ *
+ *   const sendMessage = (text: string) => {
+ *     broadcast('message', { text, userId: user.id });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <MessageList messages={messages} />
+ *       <MessageInput onSend={sendMessage} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useChannel<TMessage = unknown>(channelName: string, options?: UseChannelOptions): UseChannelReturn<TMessage>;
+/**
+ * Track and observe presence in a channel
+ *
+ * @example
+ * ```tsx
+ * function OnlineIndicator({ documentId }: { documentId: string }) {
+ *   const { count, presence, update } = usePresence<CursorState>(
+ *     `doc:${documentId}`,
+ *     { x: 0, y: 0, color: randomColor() }
+ *   );
+ *
+ *   const handleMouseMove = (e: MouseEvent) => {
+ *     update({ x: e.clientX, y: e.clientY });
+ *   };
+ *
+ *   return (
+ *     <div onMouseMove={handleMouseMove}>
+ *       <span>{count} online</span>
+ *       {Object.entries(presence).map(([key, entries]) => (
+ *         entries.map((entry, i) => (
+ *           <Cursor key={`${key}-${i}`} {...entry.state} />
+ *         ))
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePresence<T extends PresenceState = PresenceState>(channelName: string, initialState?: T, options?: UsePresenceOptions): UsePresenceReturn<T>;
+/**
+ * Hook for realtime connection state
+ *
+ * @example
+ * ```tsx
+ * function ConnectionStatus() {
+ *   const { state, isConnected, reconnect } = useRealtimeConnection();
+ *
+ *   if (!isConnected) {
+ *     return (
+ *       <div className="offline-banner">
+ *         Disconnected. <button onClick={reconnect}>Reconnect</button>
+ *       </div>
+ *     );
+ *   }
+ *
+ *   return null;
+ * }
+ * ```
+ */
+declare function useRealtimeConnection(): {
+    state: ConnectionState;
+    isConnected: boolean;
+    connectionId: string | null;
+    reconnect: () => void;
+    disconnect: () => void;
+};
+/**
+ * Broadcast-only channel hook (simpler than useChannel)
+ *
+ * @example
+ * ```tsx
+ * function Notifications() {
+ *   const { send, messages } = useBroadcast<NotificationPayload>('notifications');
+ *
+ *   return (
+ *     <>
+ *       {messages.map((msg, i) => (
+ *         <Toast key={i} {...msg.payload} />
+ *       ))}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useBroadcast<T = unknown>(channelName: string, options?: {
+    enabled?: boolean;
+}): {
+    send: (event: string, payload: T) => void;
+    messages: BroadcastMessage<T>[];
+    lastMessage: BroadcastMessage<T> | null;
+    isConnected: boolean;
+};
+
+interface UseUploadOptions extends Partial<UploadOptions> {
+    /** Max file size in bytes */
+    maxSize?: number;
+    /** Allowed mime types */
+    allowedTypes?: string[];
+    /** Generate unique key */
+    uniqueKey?: boolean;
+    /** Callback on upload start */
+    onUploadStart?: (file: File) => void;
+    /** Callback on upload progress */
+    onProgress?: (progress: number, file: File) => void;
+    /** Callback on upload success */
+    onSuccess?: (result: UploadResult, file: File) => void;
+    /** Callback on upload error */
+    onError?: (error: Error, file: File) => void;
+}
+interface UseUploadReturn {
+    /** Upload a file */
+    upload: (key: string, file: File) => Promise<UploadResult>;
+    /** Upload multiple files */
+    uploadMultiple: (files: Array<{
+        key: string;
+        file: File;
+    }>) => Promise<UploadResult[]>;
+    /** Current upload progress (0-100) */
+    progress: number;
+    /** Whether upload is in progress */
+    isUploading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Last upload result */
+    result: UploadResult | null;
+    /** All upload results */
+    results: UploadResult[];
+    /** Reset state */
+    reset: () => void;
+}
+interface UseDownloadOptions {
+    /** Callback on download success */
+    onSuccess?: (blob: Blob, filename: string) => void;
+    /** Callback on download error */
+    onError?: (error: Error) => void;
+}
+interface UseDownloadReturn {
+    /** Download a file */
+    download: (key: string, filename?: string) => Promise<Blob>;
+    /** Download and trigger browser download */
+    downloadAndSave: (key: string, filename?: string) => Promise<void>;
+    /** Whether download is in progress */
+    isDownloading: boolean;
+    /** Error state */
+    error: Error | null;
+}
+interface UseFileOptions {
+    /** Expiry time in seconds for signed URL */
+    expiresIn?: number;
+    /** Enable/disable */
+    enabled?: boolean;
+}
+interface UseFileReturn {
+    /** File URL (signed) */
+    url: string | null;
+    /** File metadata */
+    metadata: FileMetadata | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refresh URL and metadata */
+    refresh: () => Promise<void>;
+    /** Delete the file */
+    deleteFile: () => Promise<void>;
+}
+interface UseFilesOptions {
+    /** Path prefix filter */
+    prefix?: string;
+    /** Max files to return */
+    limit?: number;
+    /** Enable/disable */
+    enabled?: boolean;
+}
+interface UseFilesReturn {
+    /** List of files */
+    files: FileMetadata[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refresh file list */
+    refresh: () => Promise<void>;
+}
+interface DropzoneOptions extends UseUploadOptions {
+    /** Base path for uploads */
+    basePath?: string;
+    /** Multiple files allowed */
+    multiple?: boolean;
+}
+interface DropzoneState {
+    /** Whether file is being dragged over */
+    isDragOver: boolean;
+    /** Files selected (before upload) */
+    selectedFiles: File[];
+}
+interface UseDropzoneReturn extends UseUploadReturn {
+    /** Dropzone state */
+    dropzone: DropzoneState;
+    /** Get props for the drop zone element */
+    getDropzoneProps: () => {
+        onDragOver: (e: React.DragEvent) => void;
+        onDragLeave: (e: React.DragEvent) => void;
+        onDrop: (e: React.DragEvent) => void;
+        onClick: () => void;
+    };
+    /** Get props for hidden file input */
+    getInputProps: () => {
+        type: "file";
+        onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+        multiple: boolean;
+        accept: string;
+        style: {
+            display: "none";
+        };
+    };
+    /** Open file picker */
+    openFilePicker: () => void;
+    /** Clear selected files */
+    clearFiles: () => void;
+    /** Remove a specific file */
+    removeFile: (index: number) => void;
+}
+/**
+ * File upload hook
+ *
+ * @example
+ * ```tsx
+ * function FileUploader() {
+ *   const { upload, progress, isUploading, error } = useUpload({
+ *     maxSize: 5 * 1024 * 1024, // 5MB
+ *     allowedTypes: ['image/jpeg', 'image/png'],
+ *     onSuccess: (result) => {
+ *       toast.success(`Uploaded: ${result.key}`);
+ *     },
+ *   });
+ *
+ *   const handleChange = async (e: ChangeEvent<HTMLInputElement>) => {
+ *     const file = e.target.files?.[0];
+ *     if (file) {
+ *       await upload(`uploads/${file.name}`, file);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <input type="file" onChange={handleChange} disabled={isUploading} />
+ *       {isUploading && <progress value={progress} max={100} />}
+ *       {error && <p className="error">{error.message}</p>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useUpload(options?: UseUploadOptions): UseUploadReturn;
+/**
+ * File download hook
+ *
+ * @example
+ * ```tsx
+ * function DownloadButton({ fileKey }: { fileKey: string }) {
+ *   const { downloadAndSave, isDownloading } = useDownload();
+ *
+ *   return (
+ *     <button
+ *       onClick={() => downloadAndSave(fileKey)}
+ *       disabled={isDownloading}
+ *     >
+ *       {isDownloading ? 'Downloading...' : 'Download'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useDownload(options?: UseDownloadOptions): UseDownloadReturn;
+/**
+ * Single file hook (URL, metadata, actions)
+ *
+ * @example
+ * ```tsx
+ * function FilePreview({ fileKey }: { fileKey: string }) {
+ *   const { url, metadata, isLoading, deleteFile } = useFile(fileKey, {
+ *     expiresIn: 3600
+ *   });
+ *
+ *   if (isLoading) return <Skeleton />;
+ *   if (!url) return <Empty />;
+ *
+ *   return (
+ *     <div>
+ *       <img src={url} alt={metadata?.name} />
+ *       <button onClick={deleteFile}>Delete</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useFile(key: string | null, options?: UseFileOptions): UseFileReturn;
+/**
+ * List files
+ *
+ * @example
+ * ```tsx
+ * function FileList({ folder }: { folder: string }) {
+ *   const { files, isLoading, refresh } = useFiles({
+ *     prefix: folder,
+ *     limit: 20,
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {files.map(file => (
+ *         <FileItem key={file.key} file={file} />
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useFiles(options?: UseFilesOptions): UseFilesReturn;
+/**
+ * Drag and drop file upload hook
+ *
+ * @example
+ * ```tsx
+ * function DropZone() {
+ *   const {
+ *     dropzone,
+ *     getDropzoneProps,
+ *     getInputProps,
+ *     isUploading,
+ *     progress,
+ *     results,
+ *   } = useDropzone({
+ *     basePath: 'uploads',
+ *     multiple: true,
+ *     maxSize: 10 * 1024 * 1024,
+ *     allowedTypes: ['image/*'],
+ *   });
+ *
+ *   return (
+ *     <div
+ *       {...getDropzoneProps()}
+ *       className={`dropzone ${dropzone.isDragOver ? 'drag-over' : ''}`}
+ *     >
+ *       <input {...getInputProps()} />
+ *       {isUploading ? (
+ *         <progress value={progress} max={100} />
+ *       ) : (
+ *         <p>Drag files here or click to select</p>
+ *       )}
+ *       {results.length > 0 && (
+ *         <ul>
+ *           {results.map((r, i) => <li key={i}>{r.key}</li>)}
+ *         </ul>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useDropzone(options?: DropzoneOptions): UseDropzoneReturn;
+/**
+ * Get a public URL for a file
+ *
+ * @example
+ * ```tsx
+ * function Avatar({ fileKey }: { fileKey: string }) {
+ *   const url = usePublicUrl(fileKey);
+ *   return <img src={url} alt="Avatar" />;
+ * }
+ * ```
+ */
+declare function usePublicUrl(key: string): string;
+
+interface UseFunctionOptions<TInput, TOutput> {
+    /** Callback on success */
+    onSuccess?: (data: TOutput, input: TInput) => void;
+    /** Callback on error */
+    onError?: (error: Error, input: TInput) => void;
+    /** Timeout in ms */
+    timeout?: number;
+    /** Include execution logs in response */
+    includeLogs?: boolean;
+    /** Enable retry on failure */
+    retry?: boolean;
+    /** Max retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Specific version to invoke */
+    version?: number;
+}
+interface UseFunctionReturn<TInput, TOutput> {
+    /** Invoke the function */
+    invoke: (input: TInput) => Promise<TOutput>;
+    /** Result data */
+    data: TOutput | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Whether invocation succeeded */
+    isSuccess: boolean;
+    /** Invocation metadata */
+    invocation: InvokeResult<TOutput> | null;
+    /** Reset state */
+    reset: () => void;
+}
+interface UseRpcOptions<TInput, TOutput> extends UseFunctionOptions<TInput, TOutput> {
+    /** Cache results */
+    cache?: boolean;
+    /** Cache TTL in ms */
+    cacheTtl?: number;
+}
+interface UseRpcReturn<TInput, TOutput> extends UseFunctionReturn<TInput, TOutput> {
+    /** Clear cache */
+    clearCache: () => void;
+}
+interface UseFunctionListOptions {
+    /** Project ID (required) */
+    projectId: string;
+    /** Environment ID */
+    envId?: string;
+    /** Filter by enabled status */
+    enabled?: boolean;
+    /** Limit results */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+interface UseFunctionListReturn {
+    /** List of functions */
+    functions: VaifFunction[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refresh list */
+    refresh: () => Promise<void>;
+}
+/**
+ * Invoke a serverless function
+ *
+ * @example
+ * ```tsx
+ * function SendEmailButton({ to, subject, body }: EmailProps) {
+ *   const { invoke, isLoading, error } = useFunction<EmailInput, EmailResult>(
+ *     'send-email',
+ *     {
+ *       onSuccess: (result) => {
+ *         toast.success(`Email sent! ID: ${result.messageId}`);
+ *       },
+ *       onError: (error) => {
+ *         toast.error(`Failed: ${error.message}`);
+ *       },
+ *     }
+ *   );
+ *
+ *   return (
+ *     <button
+ *       onClick={() => invoke({ to, subject, body })}
+ *       disabled={isLoading}
+ *     >
+ *       {isLoading ? 'Sending...' : 'Send Email'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useFunction<TInput = unknown, TOutput = unknown>(functionIdOrName: string, options?: UseFunctionOptions<TInput, TOutput>): UseFunctionReturn<TInput, TOutput>;
+/**
+ * RPC-style function hook with caching
+ *
+ * @example
+ * ```tsx
+ * // Define typed RPC
+ * type GetUserInput = { userId: string };
+ * type GetUserOutput = { name: string; email: string };
+ *
+ * function UserProfile({ userId }: { userId: string }) {
+ *   const { invoke, data, isLoading, error } = useRpc<GetUserInput, GetUserOutput>(
+ *     'get-user',
+ *     {
+ *       cache: true,
+ *       cacheTtl: 60000, // 1 minute
+ *     }
+ *   );
+ *
+ *   useEffect(() => {
+ *     invoke({ userId });
+ *   }, [userId, invoke]);
+ *
+ *   if (isLoading) return <Spinner />;
+ *   if (error) return <Error message={error.message} />;
+ *   if (!data) return null;
+ *
+ *   return <div>{data.name} ({data.email})</div>;
+ * }
+ * ```
+ */
+declare function useRpc<TInput = unknown, TOutput = unknown>(functionIdOrName: string, options?: UseRpcOptions<TInput, TOutput>): UseRpcReturn<TInput, TOutput>;
+/**
+ * List available functions
+ *
+ * @example
+ * ```tsx
+ * function FunctionList({ projectId }: { projectId: string }) {
+ *   const { functions, isLoading, refresh } = useFunctionList({
+ *     projectId,
+ *     enabled: true,
+ *   });
+ *
+ *   return (
+ *     <ul>
+ *       {functions.map(fn => (
+ *         <li key={fn.id}>
+ *           {fn.name} - {fn.runtime}
+ *         </li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useFunctionList(options: UseFunctionListOptions): UseFunctionListReturn;
+/**
+ * Batch invoke multiple functions
+ *
+ * @example
+ * ```tsx
+ * function ProcessItems({ items }: { items: Item[] }) {
+ *   const { invoke, results, isLoading, progress } = useBatchInvoke<ProcessInput, ProcessOutput>(
+ *     'process-item',
+ *     {
+ *       concurrency: 5,
+ *       onProgress: (completed, total) => {
+ *         console.log(`${completed}/${total} processed`);
+ *       },
+ *     }
+ *   );
+ *
+ *   return (
+ *     <button onClick={() => invoke(items.map(i => ({ itemId: i.id })))}>
+ *       {isLoading ? `Processing... ${progress}%` : 'Process All'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useBatchInvoke<TInput = unknown, TOutput = unknown>(functionIdOrName: string, options?: {
+    concurrency?: number;
+    onProgress?: (completed: number, total: number) => void;
+    onSuccess?: (results: TOutput[]) => void;
+    onError?: (error: Error) => void;
+}): {
+    invoke: (inputs: TInput[]) => Promise<TOutput[]>;
+    results: TOutput[];
+    isLoading: boolean;
+    progress: number;
+    error: Error | null;
+};
+/**
+ * Scheduled/deferred function invocation
+ *
+ * @example
+ * ```tsx
+ * function ScheduleReminder() {
+ *   const { schedule, cancel, isScheduled, scheduledAt } = useScheduledFunction<ReminderInput>(
+ *     'send-reminder'
+ *   );
+ *
+ *   const handleSchedule = () => {
+ *     schedule(
+ *       { userId: user.id, message: 'Follow up' },
+ *       { delayMs: 24 * 60 * 60 * 1000 } // 24 hours
+ *     );
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {isScheduled ? (
+ *         <>
+ *           <span>Scheduled for {scheduledAt?.toLocaleString()}</span>
+ *           <button onClick={cancel}>Cancel</button>
+ *         </>
+ *       ) : (
+ *         <button onClick={handleSchedule}>Schedule Reminder</button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useScheduledFunction<TInput = unknown>(functionIdOrName: string): {
+    schedule: (input: TInput, options: {
+        delayMs: number;
+    }) => Promise<string>;
+    cancel: () => Promise<void>;
+    isScheduled: boolean;
+    scheduledAt: Date | null;
+    requestId: string | null;
+    error: Error | null;
+};
+
+export { type DropzoneOptions, type DropzoneState, type MutationStatus, type QueryStatus, type UseAuthReturn, type UseChannelOptions, type UseChannelReturn, type UseCreateOptions, type UseDeleteOptions, type UseDownloadOptions, type UseDownloadReturn, type UseDropzoneReturn, type UseEmailVerificationReturn, type UseFileOptions, type UseFileReturn, type UseFilesOptions, type UseFilesReturn, type UseFunctionListOptions, type UseFunctionListReturn, type UseFunctionOptions, type UseFunctionReturn, type UseInfiniteQueryOptions, type UseInfiniteQueryReturn, type UseMFAReturn, type UseMagicLinkReturn, type UseMutationOptions, type UseMutationReturn, type UseOAuthReturn, type UsePaginatedQueryOptions, type UsePaginatedQueryReturn, type UsePasswordResetReturn, type UsePresenceOptions, type UsePresenceReturn, type UseQueryFirstReturn, type UseQueryOptions, type UseQueryReturn, type UseRealtimeOptions, type UseRpcOptions, type UseRpcReturn, type UseSubscriptionOptions, type UseSubscriptionReturn, type UseUpdateOptions, type UseUploadOptions, type UseUploadReturn, type UseUpsertOptions, type VaifContextValue, VaifProvider, type VaifProviderProps, useAuth, useBatchCreate, useBatchDelete, useBatchInvoke, useBatchUpdate, useBroadcast, useChannel, useCount, useCreate, useDelete, useDownload, useDropzone, useEmailVerification, useFile, useFiles, useFunction, useFunctionList, useInfiniteQuery, useMFA, useMagicLink, useMutation, useOAuth, useOptimisticMutation, usePaginatedQuery, usePasswordReset, usePresence, usePublicUrl, useQuery, useQueryById, useQueryFirst, useRealtimeConnection, useRpc, useScheduledFunction, useSubscription, useToken, useUpdate, useUpload, useUpsert, useUser, useVaif, useVaifClient };