@fluxbase/sdk-react 0.1.0-rc.1 → 2026.1.1-rc.10

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 import * as _fluxbase_sdk from '@fluxbase/sdk';
-import { FluxbaseClient, User, AuthSession, SignInCredentials, SignUpCredentials, QueryBuilder, RealtimeCallback, RealtimeChangePayload, ListOptions, UploadOptions, AdminAuthResponse, ListUsersOptions, EnrichedUser, APIKey, CreateAPIKeyRequest, Webhook, CreateWebhookRequest, UpdateWebhookRequest, AppSettings, UpdateAppSettingsRequest, SystemSetting, UpdateSystemSettingRequest } from '@fluxbase/sdk';
-export { APIKey, AdminUser, AppSettings, AuthSession, EnrichedUser, FluxbaseClient, PostgrestResponse, RealtimeChangePayload, SignInCredentials, SignUpCredentials, StorageObject, SystemSetting, User, Webhook } from '@fluxbase/sdk';
+import { FluxbaseClient, User, AuthSession, SignInCredentials, SignUpCredentials, CaptchaConfig, CaptchaProvider, AuthConfig, SAMLProvider, SAMLLoginOptions, GraphQLRequestOptions, GraphQLError, GraphQLResponse, QueryBuilder, RealtimeCallback, RealtimePostgresChangesPayload, ListOptions, UploadOptions, UploadProgress, TransformOptions, SignedUrlOptions, AdminAuthResponse, ListUsersOptions, EnrichedUser, ClientKey, CreateClientKeyRequest, Webhook, CreateWebhookRequest, UpdateWebhookRequest, AppSettings, UpdateAppSettingsRequest, SystemSetting, UpdateSystemSettingRequest } from '@fluxbase/sdk';
+export { APIKey, AdminUser, AppSettings, AuthSession, CaptchaConfig, CaptchaProvider, ClientKey, EnrichedUser, FluxbaseClient, GraphQLError, GraphQLErrorLocation, GraphQLRequestOptions, GraphQLResponse, ImageFitMode, ImageFormat, PostgrestResponse, RealtimeChangePayload, SAMLLoginOptions, SAMLLoginResponse, SAMLProvider, SAMLProvidersResponse, SAMLSession, SignInCredentials, SignUpCredentials, SignedUrlOptions, StorageObject, SystemSetting, TransformOptions, User, Webhook } from '@fluxbase/sdk';
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import { UseQueryOptions } from '@tanstack/react-query';
 import * as _tanstack_query_core from '@tanstack/query-core';
 
 interface FluxbaseProviderProps {
@@ -31,11 +31,11 @@ declare function useSession(): _tanstack_react_query.UseQueryResult<AuthSession
 /**
  * Hook for signing in
  */
-declare function useSignIn(): _tanstack_react_query.UseMutationResult<AuthSession | _fluxbase_sdk.SignInWith2FAResponse, Error, SignInCredentials, unknown>;
+declare function useSignIn(): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.FluxbaseResponse<_fluxbase_sdk.AuthResponseData | _fluxbase_sdk.SignInWith2FAResponse>, Error, SignInCredentials, unknown>;
 /**
  * Hook for signing up
  */
-declare function useSignUp(): _tanstack_react_query.UseMutationResult<AuthSession, Error, SignUpCredentials, unknown>;
+declare function useSignUp(): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.FluxbaseAuthResponse, Error, SignUpCredentials, unknown>;
 /**
  * Hook for signing out
  */
@@ -43,7 +43,7 @@ declare function useSignOut(): _tanstack_react_query.UseMutationResult<void, Err
 /**
  * Hook for updating the current user
  */
-declare function useUpdateUser(): _tanstack_react_query.UseMutationResult<User, Error, Partial<Pick<User, "email" | "metadata">>, unknown>;
+declare function useUpdateUser(): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.UserResponse, Error, Partial<Pick<User, "email" | "metadata">>, unknown>;
 /**
  * Combined auth hook with all auth state and methods
  */
@@ -52,16 +52,578 @@ declare function useAuth(): {
     session: AuthSession | null | undefined;
     isLoading: boolean;
     isAuthenticated: boolean;
-    signIn: _tanstack_react_query.UseMutateAsyncFunction<AuthSession | _fluxbase_sdk.SignInWith2FAResponse, Error, SignInCredentials, unknown>;
-    signUp: _tanstack_react_query.UseMutateAsyncFunction<AuthSession, Error, SignUpCredentials, unknown>;
+    signIn: _tanstack_react_query.UseMutateAsyncFunction<_fluxbase_sdk.FluxbaseResponse<_fluxbase_sdk.AuthResponseData | _fluxbase_sdk.SignInWith2FAResponse>, Error, SignInCredentials, unknown>;
+    signUp: _tanstack_react_query.UseMutateAsyncFunction<_fluxbase_sdk.FluxbaseAuthResponse, Error, SignUpCredentials, unknown>;
     signOut: _tanstack_react_query.UseMutateAsyncFunction<void, Error, void, unknown>;
-    updateUser: _tanstack_react_query.UseMutateAsyncFunction<User, Error, Partial<Pick<User, "email" | "metadata">>, unknown>;
+    updateUser: _tanstack_react_query.UseMutateAsyncFunction<_fluxbase_sdk.UserResponse, Error, Partial<Pick<User, "email" | "metadata">>, unknown>;
     isSigningIn: boolean;
     isSigningUp: boolean;
     isSigningOut: boolean;
     isUpdating: boolean;
 };
 
+/**
+ * Hook to get the CAPTCHA configuration from the server
+ * Use this to determine which CAPTCHA provider to load
+ *
+ * @example
+ * ```tsx
+ * function AuthPage() {
+ *   const { data: captchaConfig, isLoading } = useCaptchaConfig();
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   return captchaConfig?.enabled ? (
+ *     <CaptchaWidget provider={captchaConfig.provider} siteKey={captchaConfig.site_key} />
+ *   ) : null;
+ * }
+ * ```
+ */
+declare function useCaptchaConfig(): _tanstack_react_query.UseQueryResult<CaptchaConfig, Error>;
+/**
+ * CAPTCHA widget state for managing token generation
+ */
+interface CaptchaState {
+    /** Current CAPTCHA token (null until solved) */
+    token: string | null;
+    /** Whether the CAPTCHA widget is ready */
+    isReady: boolean;
+    /** Whether a token is being generated */
+    isLoading: boolean;
+    /** Any error that occurred */
+    error: Error | null;
+    /** Reset the CAPTCHA widget */
+    reset: () => void;
+    /** Execute/trigger the CAPTCHA (for invisible CAPTCHA like reCAPTCHA v3) */
+    execute: () => Promise<string>;
+    /** Callback to be called when CAPTCHA is verified */
+    onVerify: (token: string) => void;
+    /** Callback to be called when CAPTCHA expires */
+    onExpire: () => void;
+    /** Callback to be called when CAPTCHA errors */
+    onError: (error: Error) => void;
+}
+/**
+ * Hook to manage CAPTCHA widget state
+ *
+ * This hook provides a standardized interface for managing CAPTCHA tokens
+ * across different providers (hCaptcha, reCAPTCHA v3, Turnstile, Cap).
+ *
+ * Supported providers:
+ * - hcaptcha: Privacy-focused visual challenge
+ * - recaptcha_v3: Google's invisible risk-based CAPTCHA
+ * - turnstile: Cloudflare's invisible CAPTCHA
+ * - cap: Self-hosted proof-of-work CAPTCHA (https://capjs.js.org/)
+ *
+ * @param provider - The CAPTCHA provider type
+ * @returns CAPTCHA state and callbacks
+ *
+ * @example
+ * ```tsx
+ * function LoginForm() {
+ *   const captcha = useCaptcha('hcaptcha');
+ *
+ *   const handleSubmit = async (e: FormEvent) => {
+ *     e.preventDefault();
+ *
+ *     // Get CAPTCHA token
+ *     const captchaToken = captcha.token || await captcha.execute();
+ *
+ *     // Sign in with CAPTCHA token
+ *     await signIn({
+ *       email,
+ *       password,
+ *       captchaToken
+ *     });
+ *   };
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit}>
+ *       <input name="email" />
+ *       <input name="password" type="password" />
+ *
+ *       <HCaptcha
+ *         sitekey={siteKey}
+ *         onVerify={captcha.onVerify}
+ *         onExpire={captcha.onExpire}
+ *         onError={captcha.onError}
+ *       />
+ *
+ *       <button type="submit" disabled={!captcha.isReady}>
+ *         Sign In
+ *       </button>
+ *     </form>
+ *   );
+ * }
+ * ```
+ *
+ * @example Cap provider
+ * ```tsx
+ * function LoginForm() {
+ *   const { data: config } = useCaptchaConfig();
+ *   const captcha = useCaptcha(config?.provider);
+ *
+ *   // For Cap, load the widget from cap_server_url
+ *   // <script src={`${config.cap_server_url}/widget.js`} />
+ *   // <cap-widget data-cap-url={config.cap_server_url} />
+ * }
+ * ```
+ */
+declare function useCaptcha(provider?: CaptchaProvider): CaptchaState;
+/**
+ * Check if CAPTCHA is required for a specific endpoint
+ *
+ * @param config - CAPTCHA configuration from useCaptchaConfig
+ * @param endpoint - The endpoint to check (e.g., 'signup', 'login', 'password_reset')
+ * @returns Whether CAPTCHA is required for this endpoint
+ */
+declare function isCaptchaRequiredForEndpoint(config: CaptchaConfig | undefined, endpoint: string): boolean;
+
+/**
+ * Hook to get the complete authentication configuration from the server
+ *
+ * Returns all public auth settings in a single request including:
+ * - Signup enabled status
+ * - Email verification requirements
+ * - Magic link availability
+ * - MFA availability
+ * - Password requirements (length, complexity)
+ * - Available OAuth providers (Google, GitHub, etc.)
+ * - Available SAML providers (enterprise SSO)
+ * - CAPTCHA configuration
+ *
+ * Use this to conditionally render UI elements based on server configuration,
+ * such as hiding signup forms when signup is disabled or displaying available
+ * OAuth provider buttons.
+ *
+ * @returns Query result with authentication configuration
+ *
+ * @example
+ * ```tsx
+ * function AuthPage() {
+ *   const { data: config, isLoading } = useAuthConfig();
+ *
+ *   if (isLoading) return <Loading />;
+ *
+ *   return (
+ *     <div>
+ *       {config?.signup_enabled && (
+ *         <SignupForm passwordMinLength={config.password_min_length} />
+ *       )}
+ *
+ *       {config?.oauth_providers.map(provider => (
+ *         <OAuthButton
+ *           key={provider.provider}
+ *           provider={provider.provider}
+ *           displayName={provider.display_name}
+ *           authorizeUrl={provider.authorize_url}
+ *         />
+ *       ))}
+ *
+ *       {config?.saml_providers.map(provider => (
+ *         <SAMLButton
+ *           key={provider.provider}
+ *           provider={provider.provider}
+ *           displayName={provider.display_name}
+ *         />
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example Showing password requirements
+ * ```tsx
+ * function PasswordInput() {
+ *   const { data: config } = useAuthConfig();
+ *
+ *   return (
+ *     <div>
+ *       <input type="password" minLength={config?.password_min_length} />
+ *       <ul>
+ *         <li>Minimum {config?.password_min_length || 8} characters</li>
+ *         {config?.password_require_uppercase && <li>One uppercase letter</li>}
+ *         {config?.password_require_lowercase && <li>One lowercase letter</li>}
+ *         {config?.password_require_number && <li>One number</li>}
+ *         {config?.password_require_special && <li>One special character</li>}
+ *       </ul>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAuthConfig(): _tanstack_react_query.UseQueryResult<AuthConfig, Error>;
+
+/**
+ * Hook to get available SAML SSO providers
+ *
+ * @example
+ * ```tsx
+ * function SAMLProviderList() {
+ *   const { data: providers, isLoading } = useSAMLProviders()
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *
+ *   return (
+ *     <div>
+ *       {providers?.map(provider => (
+ *         <button key={provider.id} onClick={() => signInWithSAML(provider.name)}>
+ *           Sign in with {provider.name}
+ *         </button>
+ *       ))}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useSAMLProviders(): _tanstack_react_query.UseQueryResult<SAMLProvider[], Error>;
+/**
+ * Hook to get SAML login URL for a provider
+ *
+ * This hook returns a function to get the login URL for a specific provider.
+ * Use this when you need more control over the redirect behavior.
+ *
+ * @example
+ * ```tsx
+ * function SAMLLoginButton({ provider }: { provider: string }) {
+ *   const getSAMLLoginUrl = useGetSAMLLoginUrl()
+ *
+ *   const handleClick = async () => {
+ *     const { data, error } = await getSAMLLoginUrl.mutateAsync({
+ *       provider,
+ *       options: { redirectUrl: window.location.href }
+ *     })
+ *     if (!error) {
+ *       window.location.href = data.url
+ *     }
+ *   }
+ *
+ *   return <button onClick={handleClick}>Login with {provider}</button>
+ * }
+ * ```
+ */
+declare function useGetSAMLLoginUrl(): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.DataResponse<_fluxbase_sdk.SAMLLoginResponse>, Error, {
+    provider: string;
+    options?: SAMLLoginOptions;
+}, unknown>;
+/**
+ * Hook to initiate SAML login (redirects to IdP)
+ *
+ * This hook returns a mutation that when called, redirects the user to the
+ * SAML Identity Provider for authentication.
+ *
+ * @example
+ * ```tsx
+ * function SAMLLoginButton() {
+ *   const signInWithSAML = useSignInWithSAML()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => signInWithSAML.mutate({ provider: 'okta' })}
+ *       disabled={signInWithSAML.isPending}
+ *     >
+ *       {signInWithSAML.isPending ? 'Redirecting...' : 'Sign in with Okta'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useSignInWithSAML(): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.DataResponse<{
+    provider: string;
+    url: string;
+}>, Error, {
+    provider: string;
+    options?: SAMLLoginOptions;
+}, unknown>;
+/**
+ * Hook to handle SAML callback after IdP authentication
+ *
+ * Use this in your SAML callback page to complete the authentication flow.
+ *
+ * @example
+ * ```tsx
+ * function SAMLCallbackPage() {
+ *   const handleCallback = useHandleSAMLCallback()
+ *   const navigate = useNavigate()
+ *
+ *   useEffect(() => {
+ *     const params = new URLSearchParams(window.location.search)
+ *     const samlResponse = params.get('SAMLResponse')
+ *
+ *     if (samlResponse) {
+ *       handleCallback.mutate(
+ *         { samlResponse },
+ *         {
+ *           onSuccess: () => navigate('/dashboard'),
+ *           onError: (error) => console.error('SAML login failed:', error)
+ *         }
+ *       )
+ *     }
+ *   }, [])
+ *
+ *   if (handleCallback.isPending) {
+ *     return <div>Completing sign in...</div>
+ *   }
+ *
+ *   if (handleCallback.isError) {
+ *     return <div>Authentication failed: {handleCallback.error.message}</div>
+ *   }
+ *
+ *   return null
+ * }
+ * ```
+ */
+declare function useHandleSAMLCallback(): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.FluxbaseAuthResponse, Error, {
+    samlResponse: string;
+    provider?: string;
+}, unknown>;
+/**
+ * Hook to get SAML Service Provider metadata URL
+ *
+ * Returns a function that generates the SP metadata URL for a given provider.
+ * Use this URL when configuring your SAML IdP.
+ *
+ * @example
+ * ```tsx
+ * function SAMLSetupInfo({ provider }: { provider: string }) {
+ *   const getSAMLMetadataUrl = useSAMLMetadataUrl()
+ *   const metadataUrl = getSAMLMetadataUrl(provider)
+ *
+ *   return (
+ *     <div>
+ *       <p>SP Metadata URL:</p>
+ *       <code>{metadataUrl}</code>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useSAMLMetadataUrl(): (provider: string) => string;
+
+/**
+ * Options for useGraphQLQuery hook
+ */
+interface UseGraphQLQueryOptions<T> {
+    /**
+     * Variables to pass to the GraphQL query
+     */
+    variables?: Record<string, unknown>;
+    /**
+     * Operation name when the document contains multiple operations
+     */
+    operationName?: string;
+    /**
+     * Additional request options
+     */
+    requestOptions?: GraphQLRequestOptions;
+    /**
+     * Whether the query is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Time in milliseconds after which the query is considered stale
+     * @default 0 (considered stale immediately)
+     */
+    staleTime?: number;
+    /**
+     * Time in milliseconds after which inactive query data is garbage collected
+     * @default 5 minutes
+     */
+    gcTime?: number;
+    /**
+     * Whether to refetch on window focus
+     * @default true
+     */
+    refetchOnWindowFocus?: boolean;
+    /**
+     * Transform function to process the response data
+     */
+    select?: (data: T | undefined) => T | undefined;
+}
+/**
+ * Options for useGraphQLMutation hook
+ */
+interface UseGraphQLMutationOptions<T, V> {
+    /**
+     * Operation name when the document contains multiple operations
+     */
+    operationName?: string;
+    /**
+     * Additional request options
+     */
+    requestOptions?: GraphQLRequestOptions;
+    /**
+     * Callback when mutation succeeds
+     */
+    onSuccess?: (data: T, variables: V) => void;
+    /**
+     * Callback when mutation fails
+     */
+    onError?: (error: GraphQLError, variables: V) => void;
+    /**
+     * Query keys to invalidate on success
+     */
+    invalidateQueries?: string[];
+}
+/**
+ * Hook to execute GraphQL queries with React Query caching
+ *
+ * @typeParam T - The expected response data type
+ * @param queryKey - Unique key for caching (string or array)
+ * @param query - The GraphQL query string
+ * @param options - Query options including variables
+ * @returns React Query result object
+ *
+ * @example
+ * ```tsx
+ * interface UsersQuery {
+ *   users: Array<{ id: string; email: string }>
+ * }
+ *
+ * function UsersList() {
+ *   const { data, isLoading } = useGraphQLQuery<UsersQuery>(
+ *     'users',
+ *     `query { users { id email } }`
+ *   )
+ *
+ *   return <div>{data?.users.length} users</div>
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With variables
+ * const { data } = useGraphQLQuery<UserQuery>(
+ *   ['user', userId],
+ *   `query GetUser($id: ID!) { user(id: $id) { id email } }`,
+ *   { variables: { id: userId } }
+ * )
+ * ```
+ */
+declare function useGraphQLQuery<T = unknown>(queryKey: string | readonly unknown[], query: string, options?: UseGraphQLQueryOptions<T>): _tanstack_react_query.UseQueryResult<_tanstack_query_core.NoInfer<T | undefined>, GraphQLError>;
+/**
+ * Hook to execute GraphQL mutations
+ *
+ * @typeParam T - The expected response data type
+ * @typeParam V - The variables type
+ * @param mutation - The GraphQL mutation string
+ * @param options - Mutation options
+ * @returns React Query mutation result object
+ *
+ * @example
+ * ```tsx
+ * interface CreateUserMutation {
+ *   insertUser: { id: string; email: string }
+ * }
+ *
+ * interface CreateUserVariables {
+ *   data: { email: string }
+ * }
+ *
+ * function CreateUserForm() {
+ *   const mutation = useGraphQLMutation<CreateUserMutation, CreateUserVariables>(
+ *     `mutation CreateUser($data: UserInput!) {
+ *       insertUser(data: $data) { id email }
+ *     }`,
+ *     {
+ *       onSuccess: (data) => console.log('Created:', data.insertUser),
+ *       invalidateQueries: ['users']
+ *     }
+ *   )
+ *
+ *   const handleSubmit = (email: string) => {
+ *     mutation.mutate({ data: { email } })
+ *   }
+ *
+ *   return (
+ *     <button
+ *       onClick={() => handleSubmit('new@example.com')}
+ *       disabled={mutation.isPending}
+ *     >
+ *       Create User
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+declare function useGraphQLMutation<T = unknown, V extends Record<string, unknown> = Record<string, unknown>>(mutation: string, options?: UseGraphQLMutationOptions<T, V>): _tanstack_react_query.UseMutationResult<T | undefined, GraphQLError, V, unknown>;
+/**
+ * Hook to fetch the GraphQL schema via introspection
+ *
+ * @param options - Query options
+ * @returns React Query result with schema introspection data
+ *
+ * @example
+ * ```tsx
+ * function SchemaExplorer() {
+ *   const { data, isLoading } = useGraphQLIntrospection()
+ *
+ *   if (isLoading) return <div>Loading schema...</div>
+ *
+ *   return (
+ *     <div>
+ *       <p>Query type: {data?.__schema.queryType.name}</p>
+ *       <p>Types: {data?.__schema.types.length}</p>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useGraphQLIntrospection(options?: {
+    enabled?: boolean;
+    staleTime?: number;
+    requestOptions?: GraphQLRequestOptions;
+}): _tanstack_react_query.UseQueryResult<{
+    __schema: _fluxbase_sdk.IntrospectionSchema;
+} | undefined, Error>;
+/**
+ * Hook to execute raw GraphQL operations (query or mutation)
+ *
+ * This is a lower-level hook that doesn't use React Query caching.
+ * Useful for one-off operations or when you need full control.
+ *
+ * @returns Functions to execute queries and mutations
+ *
+ * @example
+ * ```tsx
+ * function AdminPanel() {
+ *   const { executeQuery, executeMutation } = useGraphQL()
+ *
+ *   const handleExport = async () => {
+ *     const result = await executeQuery<ExportData>(
+ *       `query { exportAllData { url } }`
+ *     )
+ *     if (result.data) {
+ *       window.open(result.data.exportAllData.url)
+ *     }
+ *   }
+ *
+ *   return <button onClick={handleExport}>Export Data</button>
+ * }
+ * ```
+ */
+declare function useGraphQL(): {
+    /**
+     * Execute a GraphQL query
+     */
+    executeQuery: <T = unknown>(query: string, variables?: Record<string, unknown>, options?: GraphQLRequestOptions) => Promise<GraphQLResponse<T>>;
+    /**
+     * Execute a GraphQL mutation
+     */
+    executeMutation: <T = unknown>(mutation: string, variables?: Record<string, unknown>, options?: GraphQLRequestOptions) => Promise<GraphQLResponse<T>>;
+    /**
+     * Execute a GraphQL operation with an explicit operation name
+     */
+    execute: <T = unknown>(document: string, variables?: Record<string, unknown>, operationName?: string, options?: GraphQLRequestOptions) => Promise<GraphQLResponse<T>>;
+    /**
+     * Fetch the GraphQL schema via introspection
+     */
+    introspect: (options?: GraphQLRequestOptions) => Promise<GraphQLResponse<{
+        __schema: _fluxbase_sdk.IntrospectionSchema;
+    }>>;
+};
+
 interface UseFluxbaseQueryOptions<T> extends Omit<UseQueryOptions<T[], Error>, 'queryKey' | 'queryFn'> {
     /**
      * Custom query key. If not provided, will use table name and filters.
@@ -108,7 +670,7 @@ interface UseRealtimeOptions {
     /**
      * Event type to listen for ('INSERT', 'UPDATE', 'DELETE', or '*' for all)
      */
-    event?: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+    event?: "INSERT" | "UPDATE" | "DELETE" | "*";
     /**
      * Callback function when an event is received
      */
@@ -140,40 +702,93 @@ declare function useRealtime(options: UseRealtimeOptions): {
  * @param table - Table name (with optional schema, e.g., 'public.products')
  * @param options - Subscription options
  */
-declare function useTableSubscription(table: string, options?: Omit<UseRealtimeOptions, 'channel'>): {
+declare function useTableSubscription(table: string, options?: Omit<UseRealtimeOptions, "channel">): {
     channel: _fluxbase_sdk.RealtimeChannel | null;
 };
 /**
  * Hook to subscribe to INSERT events on a table
  */
-declare function useTableInserts(table: string, callback: (payload: RealtimeChangePayload) => void, options?: Omit<UseRealtimeOptions, 'channel' | 'event' | 'callback'>): {
+declare function useTableInserts(table: string, callback: (payload: RealtimePostgresChangesPayload) => void, options?: Omit<UseRealtimeOptions, "channel" | "event" | "callback">): {
     channel: _fluxbase_sdk.RealtimeChannel | null;
 };
 /**
  * Hook to subscribe to UPDATE events on a table
  */
-declare function useTableUpdates(table: string, callback: (payload: RealtimeChangePayload) => void, options?: Omit<UseRealtimeOptions, 'channel' | 'event' | 'callback'>): {
+declare function useTableUpdates(table: string, callback: (payload: RealtimePostgresChangesPayload) => void, options?: Omit<UseRealtimeOptions, "channel" | "event" | "callback">): {
     channel: _fluxbase_sdk.RealtimeChannel | null;
 };
 /**
  * Hook to subscribe to DELETE events on a table
  */
-declare function useTableDeletes(table: string, callback: (payload: RealtimeChangePayload) => void, options?: Omit<UseRealtimeOptions, 'channel' | 'event' | 'callback'>): {
+declare function useTableDeletes(table: string, callback: (payload: RealtimePostgresChangesPayload) => void, options?: Omit<UseRealtimeOptions, "channel" | "event" | "callback">): {
     channel: _fluxbase_sdk.RealtimeChannel | null;
 };
 
 /**
  * Hook to list files in a bucket
  */
-declare function useStorageList(bucket: string, options?: ListOptions & Omit<UseQueryOptions<any[], Error>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<any[], Error>;
+declare function useStorageList(bucket: string, options?: ListOptions & Omit<UseQueryOptions<any[], Error>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<any[], Error>;
 /**
  * Hook to upload a file to a bucket
+ *
+ * Note: You can track upload progress by passing an `onUploadProgress` callback in the options:
+ *
+ * @example
+ * ```tsx
+ * const upload = useStorageUpload('avatars')
+ *
+ * upload.mutate({
+ *   path: 'user.jpg',
+ *   file: file,
+ *   options: {
+ *     onUploadProgress: (progress) => {
+ *       console.log(`${progress.percentage}% uploaded`)
+ *     }
+ *   }
+ * })
+ * ```
+ *
+ * For automatic progress state management, use `useStorageUploadWithProgress` instead.
  */
-declare function useStorageUpload(bucket: string): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.StorageObject | null, Error, {
+declare function useStorageUpload(bucket: string): _tanstack_react_query.UseMutationResult<{
+    id: string;
+    path: string;
+    fullPath: string;
+} | null, Error, {
     path: string;
     file: File | Blob | ArrayBuffer;
     options?: UploadOptions;
 }, unknown>;
+/**
+ * Hook to upload a file to a bucket with built-in progress tracking
+ *
+ * @example
+ * ```tsx
+ * const { upload, progress, reset } = useStorageUploadWithProgress('avatars')
+ *
+ * // Upload with automatic progress tracking
+ * upload.mutate({
+ *   path: 'user.jpg',
+ *   file: file
+ * })
+ *
+ * // Display progress
+ * console.log(progress) // { loaded: 1024, total: 2048, percentage: 50 }
+ * ```
+ */
+declare function useStorageUploadWithProgress(bucket: string): {
+    upload: _tanstack_react_query.UseMutationResult<{
+        id: string;
+        path: string;
+        fullPath: string;
+    } | null, Error, {
+        path: string;
+        file: File | Blob | ArrayBuffer;
+        options?: Omit<UploadOptions, "onUploadProgress">;
+    }, unknown>;
+    progress: UploadProgress | null;
+    reset: () => void;
+};
 /**
  * Hook to download a file from a bucket
  */
@@ -186,21 +801,78 @@ declare function useStorageDelete(bucket: string): _tanstack_react_query.UseMuta
  * Hook to get a public URL for a file
  */
 declare function useStoragePublicUrl(bucket: string, path: string | null): string | null;
+/**
+ * Hook to get a public URL for an image with transformations applied
+ *
+ * Only works for image files (JPEG, PNG, WebP, GIF, AVIF, etc.)
+ *
+ * @param bucket - The storage bucket name
+ * @param path - The file path (or null to disable)
+ * @param transform - Transformation options (width, height, format, quality, fit)
+ *
+ * @example
+ * ```tsx
+ * function ImageThumbnail({ path }: { path: string }) {
+ *   const url = useStorageTransformUrl('images', path, {
+ *     width: 300,
+ *     height: 200,
+ *     format: 'webp',
+ *     quality: 85,
+ *     fit: 'cover'
+ *   });
+ *
+ *   return <img src={url || ''} alt="Thumbnail" />;
+ * }
+ * ```
+ */
+declare function useStorageTransformUrl(bucket: string, path: string | null, transform: TransformOptions): string | null;
 /**
  * Hook to create a signed URL
+ *
+ * @deprecated Use useStorageSignedUrlWithOptions for more control including transforms
  */
 declare function useStorageSignedUrl(bucket: string, path: string | null, expiresIn?: number): _tanstack_react_query.UseQueryResult<string | null, Error>;
+/**
+ * Hook to create a signed URL with full options including image transformations
+ *
+ * @param bucket - The storage bucket name
+ * @param path - The file path (or null to disable)
+ * @param options - Signed URL options including expiration and transforms
+ *
+ * @example
+ * ```tsx
+ * function SecureThumbnail({ path }: { path: string }) {
+ *   const { data: url } = useStorageSignedUrlWithOptions('images', path, {
+ *     expiresIn: 3600,
+ *     transform: {
+ *       width: 400,
+ *       height: 300,
+ *       format: 'webp',
+ *       quality: 85,
+ *       fit: 'cover'
+ *     }
+ *   });
+ *
+ *   return <img src={url || ''} alt="Secure Thumbnail" />;
+ * }
+ * ```
+ */
+declare function useStorageSignedUrlWithOptions(bucket: string, path: string | null, options?: SignedUrlOptions): _tanstack_react_query.UseQueryResult<string | null, Error>;
 /**
  * Hook to move a file
  */
-declare function useStorageMove(bucket: string): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.StorageObject | null, Error, {
+declare function useStorageMove(bucket: string): _tanstack_react_query.UseMutationResult<{
+    message: string;
+} | null, Error, {
     fromPath: string;
     toPath: string;
 }, unknown>;
 /**
  * Hook to copy a file
  */
-declare function useStorageCopy(bucket: string): _tanstack_react_query.UseMutationResult<_fluxbase_sdk.StorageObject | null, Error, {
+declare function useStorageCopy(bucket: string): _tanstack_react_query.UseMutationResult<{
+    path: string;
+} | null, Error, {
     fromPath: string;
     toPath: string;
 }, unknown>;
@@ -220,52 +892,6 @@ declare function useCreateBucket(): _tanstack_react_query.UseMutationResult<void
  */
 declare function useDeleteBucket(): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
 
-/**
- * Hook to call a PostgreSQL function and cache the result
- *
- * @example
- * ```tsx
- * const { data, isLoading, error } = useRPC(
- *   'calculate_total',
- *   { order_id: 123 },
- *   { enabled: !!orderId }
- * )
- * ```
- */
-declare function useRPC<TData = unknown, TParams extends Record<string, unknown> = Record<string, unknown>>(functionName: string, params?: TParams, options?: Omit<UseQueryOptions<TData, Error>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<_tanstack_query_core.NoInfer<TData>, Error>;
-/**
- * Hook to create a mutation for calling PostgreSQL functions
- * Useful for functions that modify data
- *
- * @example
- * ```tsx
- * const createOrder = useRPCMutation('create_order')
- *
- * const handleSubmit = async () => {
- *   await createOrder.mutateAsync({
- *     user_id: 123,
- *     items: [{ product_id: 1, quantity: 2 }]
- *   })
- * }
- * ```
- */
-declare function useRPCMutation<TData = unknown, TParams extends Record<string, unknown> = Record<string, unknown>>(functionName: string, options?: Omit<UseMutationOptions<TData, Error, TParams>, 'mutationFn'>): _tanstack_react_query.UseMutationResult<TData, Error, TParams, unknown>;
-/**
- * Hook to call multiple RPC functions in parallel
- *
- * @example
- * ```tsx
- * const { data, isLoading } = useRPCBatch([
- *   { name: 'get_user_stats', params: { user_id: 123 } },
- *   { name: 'get_recent_orders', params: { limit: 10 } },
- * ])
- * ```
- */
-declare function useRPCBatch<TData = unknown>(calls: Array<{
-    name: string;
-    params?: Record<string, unknown>;
-}>, options?: Omit<UseQueryOptions<TData[], Error, TData[], readonly unknown[]>, 'queryKey' | 'queryFn'>): _tanstack_react_query.UseQueryResult<TData[], Error>;
-
 /**
  * Simplified admin user type returned by authentication
  */
@@ -419,18 +1045,18 @@ interface UseUsersReturn {
  */
 declare function useUsers(options?: UseUsersOptions): UseUsersReturn;
 
-interface UseAPIKeysOptions {
+interface UseClientKeysOptions {
     /**
-     * Whether to automatically fetch API keys on mount
+     * Whether to automatically fetch client keys on mount
      * @default true
      */
     autoFetch?: boolean;
 }
-interface UseAPIKeysReturn {
+interface UseClientKeysReturn {
     /**
-     * Array of API keys
+     * Array of client keys
      */
-    keys: APIKey[];
+    keys: ClientKey[];
     /**
      * Whether keys are being fetched
      */
@@ -440,46 +1066,46 @@ interface UseAPIKeysReturn {
      */
     error: Error | null;
     /**
-     * Refetch API keys
+     * Refetch client keys
      */
     refetch: () => Promise<void>;
     /**
-     * Create a new API key
+     * Create a new client key
      */
-    createKey: (request: CreateAPIKeyRequest) => Promise<{
+    createKey: (request: CreateClientKeyRequest) => Promise<{
         key: string;
-        keyData: APIKey;
+        keyData: ClientKey;
     }>;
     /**
-     * Update an API key
+     * Update a client key
      */
     updateKey: (keyId: string, update: {
         name?: string;
         description?: string;
     }) => Promise<void>;
     /**
-     * Revoke an API key
+     * Revoke a client key
      */
     revokeKey: (keyId: string) => Promise<void>;
     /**
-     * Delete an API key
+     * Delete a client key
      */
     deleteKey: (keyId: string) => Promise<void>;
 }
 /**
- * Hook for managing API keys
+ * Hook for managing client keys
  *
- * Provides API key list and management functions.
+ * Provides client key list and management functions.
  *
  * @example
  * ```tsx
- * function APIKeyManager() {
- *   const { keys, isLoading, createKey, revokeKey } = useAPIKeys()
+ * function ClientKeyManager() {
+ *   const { keys, isLoading, createKey, revokeKey } = useClientKeys()
  *
  *   const handleCreate = async () => {
  *     const { key, keyData } = await createKey({
  *       name: 'Backend Service',
- *       description: 'API key for backend',
+ *       description: 'Client key for backend',
  *       expires_at: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString()
  *     })
  *     alert(`Key created: ${key}`)
@@ -499,7 +1125,11 @@ interface UseAPIKeysReturn {
  * }
  * ```
  */
-declare function useAPIKeys(options?: UseAPIKeysOptions): UseAPIKeysReturn;
+declare function useClientKeys(options?: UseClientKeysOptions): UseClientKeysReturn;
+/**
+ * @deprecated Use useClientKeys instead
+ */
+declare const useAPIKeys: typeof useClientKeys;
 
 /**
  * Admin Settings and Management Hooks
@@ -603,4 +1233,4 @@ interface UseWebhooksReturn {
  */
 declare function useWebhooks(options?: UseWebhooksOptions): UseWebhooksReturn;
 
-export { FluxbaseProvider, useAPIKeys, useAdminAuth, useAppSettings, useAuth, useCreateBucket, useDelete, useDeleteBucket, useFluxbaseClient, useFluxbaseQuery, useInsert, useRPC, useRPCBatch, useRPCMutation, useRealtime, useSession, useSignIn, useSignOut, useSignUp, useStorageBuckets, useStorageCopy, useStorageDelete, useStorageDownload, useStorageList, useStorageMove, useStoragePublicUrl, useStorageSignedUrl, useStorageUpload, useSystemSettings, useTable, useTableDeletes, useTableInserts, useTableSubscription, useTableUpdates, useUpdate, useUpdateUser, useUpsert, useUser, useUsers, useWebhooks };
+export { type CaptchaState, FluxbaseProvider, type UseGraphQLMutationOptions, type UseGraphQLQueryOptions, isCaptchaRequiredForEndpoint, useAPIKeys, useAdminAuth, useAppSettings, useAuth, useAuthConfig, useCaptcha, useCaptchaConfig, useClientKeys, useCreateBucket, useDelete, useDeleteBucket, useFluxbaseClient, useFluxbaseQuery, useGetSAMLLoginUrl, useGraphQL, useGraphQLIntrospection, useGraphQLMutation, useGraphQLQuery, useHandleSAMLCallback, useInsert, useRealtime, useSAMLMetadataUrl, useSAMLProviders, useSession, useSignIn, useSignInWithSAML, useSignOut, useSignUp, useStorageBuckets, useStorageCopy, useStorageDelete, useStorageDownload, useStorageList, useStorageMove, useStoragePublicUrl, useStorageSignedUrl, useStorageSignedUrlWithOptions, useStorageTransformUrl, useStorageUpload, useStorageUploadWithProgress, useSystemSettings, useTable, useTableDeletes, useTableInserts, useTableSubscription, useTableUpdates, useUpdate, useUpdateUser, useUpsert, useUser, useUsers, useWebhooks };