@fluxbase/sdk-react 2026.2.8 → 2026.3.2-rc.3

package/dist/index.d.mts

@@ -1,1457 +0,0 @@
-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, CaptchaConfig, CaptchaProvider, AuthConfig, SAMLLoginOptions, SAMLProvider, GraphQLRequestOptions, GraphQLError, GraphQLResponse, QueryBuilder, RealtimeCallback, RealtimePostgresChangesPayload, ListOptions, SignedUrlOptions, TransformOptions, UploadOptions, UploadProgress, AdminAuthResponse, ListUsersOptions, EnrichedUser, ClientKey, CreateClientKeyRequest, AppSettings, UpdateAppSettingsRequest, SystemSetting, UpdateSystemSettingRequest, Webhook, CreateWebhookRequest, UpdateWebhookRequest, CreateTableExportSyncConfig, TableExportSyncConfig, ExportTableOptions, ExportTableResult, TableDetails, UpdateTableExportSyncConfig } 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 } from '@tanstack/react-query';
-import * as _tanstack_query_core from '@tanstack/query-core';
-
-interface FluxbaseProviderProps {
-    client: FluxbaseClient;
-    children: ReactNode;
-}
-/**
- * Provider component to make Fluxbase client available throughout the app
- */
-declare function FluxbaseProvider({ client, children }: FluxbaseProviderProps): react_jsx_runtime.JSX.Element;
-/**
- * Hook to access the Fluxbase client from context
- */
-declare function useFluxbaseClient(): FluxbaseClient;
-
-/**
- * Hook to get the current user
- */
-declare function useUser(): _tanstack_react_query.UseQueryResult<User | null, Error>;
-/**
- * Hook to get the current session
- */
-declare function useSession(): _tanstack_react_query.UseQueryResult<AuthSession | null, Error>;
-/**
- * Hook for signing in
- */
-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<_fluxbase_sdk.FluxbaseAuthResponse, Error, SignUpCredentials, unknown>;
-/**
- * Hook for signing out
- */
-declare function useSignOut(): _tanstack_react_query.UseMutationResult<void, Error, void, unknown>;
-/**
- * Hook for updating the current user
- */
-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
- */
-declare function useAuth(): {
-    user: User | null | undefined;
-    session: AuthSession | null | undefined;
-    isLoading: boolean;
-    isAuthenticated: boolean;
-    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<_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.
-     */
-    queryKey?: unknown[];
-}
-/**
- * Hook to execute a database query
- * @param buildQuery - Function that builds and returns the query
- * @param options - React Query options
- *
- * IMPORTANT: You must provide a stable `queryKey` in options for proper caching.
- * Without a custom queryKey, each render may create a new cache entry.
- *
- * @example
- * ```tsx
- * // Always provide a queryKey for stable caching
- * useFluxbaseQuery(
- *   (client) => client.from('users').select('*'),
- *   { queryKey: ['users', 'all'] }
- * )
- * ```
- */
-declare function useFluxbaseQuery<T = any>(buildQuery: (client: ReturnType<typeof useFluxbaseClient>) => QueryBuilder<T>, options?: UseFluxbaseQueryOptions<T>): _tanstack_react_query.UseQueryResult<T[], Error>;
-/**
- * Hook for table queries with a simpler API
- * @param table - Table name
- * @param buildQuery - Optional function to build the query (e.g., add filters)
- * @param options - Query options including a stable queryKey
- *
- * NOTE: When using buildQuery with filters, provide a custom queryKey that includes
- * the filter values to ensure proper caching.
- *
- * @example
- * ```tsx
- * // Simple query - queryKey is auto-generated from table name
- * useTable('users')
- *
- * // With filters - provide queryKey including filter values
- * useTable('users',
- *   (q) => q.eq('status', 'active'),
- *   { queryKey: ['users', 'active'] }
- * )
- * ```
- */
-declare function useTable<T = any>(table: string, buildQuery?: (query: QueryBuilder<T>) => QueryBuilder<T>, options?: UseFluxbaseQueryOptions<T>): _tanstack_react_query.UseQueryResult<T[], Error>;
-/**
- * Hook to insert data into a table
- */
-declare function useInsert<T = any>(table: string): _tanstack_react_query.UseMutationResult<T | null, Error, Partial<T> | Partial<T>[], unknown>;
-/**
- * Hook to update data in a table
- */
-declare function useUpdate<T = any>(table: string): _tanstack_react_query.UseMutationResult<T | null, Error, {
-    data: Partial<T>;
-    buildQuery: (query: QueryBuilder<T>) => QueryBuilder<T>;
-}, unknown>;
-/**
- * Hook to upsert data into a table
- */
-declare function useUpsert<T = any>(table: string): _tanstack_react_query.UseMutationResult<T | null, Error, Partial<T> | Partial<T>[], unknown>;
-/**
- * Hook to delete data from a table
- */
-declare function useDelete<T = any>(table: string): _tanstack_react_query.UseMutationResult<void, Error, (query: QueryBuilder<T>) => QueryBuilder<T>, unknown>;
-
-interface UseRealtimeOptions {
-    /**
-     * The channel name (e.g., 'table:public.products')
-     */
-    channel: string;
-    /**
-     * Event type to listen for ('INSERT', 'UPDATE', 'DELETE', or '*' for all)
-     */
-    event?: "INSERT" | "UPDATE" | "DELETE" | "*";
-    /**
-     * Callback function when an event is received
-     */
-    callback?: RealtimeCallback;
-    /**
-     * Whether to automatically invalidate queries for the table
-     * Default: true
-     */
-    autoInvalidate?: boolean;
-    /**
-     * Custom query key to invalidate (if autoInvalidate is true)
-     * Default: ['fluxbase', 'table', tableName]
-     */
-    invalidateKey?: unknown[];
-    /**
-     * Whether the subscription is enabled
-     * Default: true
-     */
-    enabled?: boolean;
-}
-/**
- * Hook to subscribe to realtime changes for a channel
- *
- * NOTE: The callback and invalidateKey are stored in refs to prevent
- * subscription recreation on every render when inline functions/arrays are used.
- */
-declare function useRealtime(options: UseRealtimeOptions): {
-    channel: _fluxbase_sdk.RealtimeChannel | null;
-};
-/**
- * Hook to subscribe to a table's changes
- * @param table - Table name (with optional schema, e.g., 'public.products')
- * @param options - Subscription options
- */
-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: 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: 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: 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>;
-/**
- * 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<{
-    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
- */
-declare function useStorageDownload(bucket: string, path: string | null, enabled?: boolean): _tanstack_react_query.UseQueryResult<Blob | null, Error>;
-/**
- * Hook to delete files from a bucket
- */
-declare function useStorageDelete(bucket: string): _tanstack_react_query.UseMutationResult<void, Error, string[], unknown>;
-/**
- * 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<{
-    message: string;
-} | null, Error, {
-    fromPath: string;
-    toPath: string;
-}, unknown>;
-/**
- * Hook to copy a file
- */
-declare function useStorageCopy(bucket: string): _tanstack_react_query.UseMutationResult<{
-    path: string;
-} | null, Error, {
-    fromPath: string;
-    toPath: string;
-}, unknown>;
-/**
- * Hook to manage buckets
- */
-declare function useStorageBuckets(): _tanstack_react_query.UseQueryResult<{
-    name: string;
-    created_at: string;
-}[], Error>;
-/**
- * Hook to create a bucket
- */
-declare function useCreateBucket(): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
-/**
- * Hook to delete a bucket
- */
-declare function useDeleteBucket(): _tanstack_react_query.UseMutationResult<void, Error, string, unknown>;
-
-/**
- * Simplified admin user type returned by authentication
- */
-interface AdminUser {
-    id: string;
-    email: string;
-    role: string;
-}
-interface UseAdminAuthOptions {
-    /**
-     * Automatically check authentication status on mount
-     * @default true
-     */
-    autoCheck?: boolean;
-}
-interface UseAdminAuthReturn {
-    /**
-     * Current admin user if authenticated
-     */
-    user: AdminUser | null;
-    /**
-     * Whether the admin is authenticated
-     */
-    isAuthenticated: boolean;
-    /**
-     * Whether the authentication check is in progress
-     */
-    isLoading: boolean;
-    /**
-     * Any error that occurred during authentication
-     */
-    error: Error | null;
-    /**
-     * Login as admin
-     */
-    login: (email: string, password: string) => Promise<AdminAuthResponse>;
-    /**
-     * Logout admin
-     */
-    logout: () => Promise<void>;
-    /**
-     * Refresh admin user info
-     */
-    refresh: () => Promise<void>;
-}
-/**
- * Hook for admin authentication
- *
- * Manages admin login state, authentication checks, and user info.
- *
- * @example
- * ```tsx
- * function AdminLogin() {
- *   const { user, isAuthenticated, isLoading, login, logout } = useAdminAuth()
- *
- *   const handleLogin = async (e: React.FormEvent) => {
- *     e.preventDefault()
- *     await login(email, password)
- *   }
- *
- *   if (isLoading) return <div>Loading...</div>
- *   if (isAuthenticated) return <div>Welcome {user?.email}</div>
- *
- *   return <form onSubmit={handleLogin}>...</form>
- * }
- * ```
- */
-declare function useAdminAuth(options?: UseAdminAuthOptions): UseAdminAuthReturn;
-
-interface UseUsersOptions extends ListUsersOptions {
-    /**
-     * Whether to automatically fetch users on mount
-     * @default true
-     */
-    autoFetch?: boolean;
-    /**
-     * Refetch interval in milliseconds (0 to disable)
-     * @default 0
-     */
-    refetchInterval?: number;
-}
-interface UseUsersReturn {
-    /**
-     * Array of users
-     */
-    users: EnrichedUser[];
-    /**
-     * Total number of users (for pagination)
-     */
-    total: number;
-    /**
-     * Whether users are being fetched
-     */
-    isLoading: boolean;
-    /**
-     * Any error that occurred
-     */
-    error: Error | null;
-    /**
-     * Refetch users
-     */
-    refetch: () => Promise<void>;
-    /**
-     * Invite a new user
-     */
-    inviteUser: (email: string, role: 'user' | 'admin') => Promise<void>;
-    /**
-     * Update user role
-     */
-    updateUserRole: (userId: string, role: 'user' | 'admin') => Promise<void>;
-    /**
-     * Delete a user
-     */
-    deleteUser: (userId: string) => Promise<void>;
-    /**
-     * Reset user password
-     */
-    resetPassword: (userId: string) => Promise<{
-        message: string;
-    }>;
-}
-/**
- * Hook for managing users
- *
- * Provides user list with pagination, search, and management functions.
- *
- * @example
- * ```tsx
- * function UserList() {
- *   const { users, total, isLoading, refetch, inviteUser, deleteUser } = useUsers({
- *     limit: 20,
- *     search: searchTerm
- *   })
- *
- *   return (
- *     <div>
- *       {isLoading ? <Spinner /> : (
- *         <ul>
- *           {users.map(user => (
- *             <li key={user.id}>
- *               {user.email} - {user.role}
- *               <button onClick={() => deleteUser(user.id)}>Delete</button>
- *             </li>
- *           ))}
- *         </ul>
- *       )}
- *     </div>
- *   )
- * }
- * ```
- */
-declare function useUsers(options?: UseUsersOptions): UseUsersReturn;
-
-interface UseClientKeysOptions {
-    /**
-     * Whether to automatically fetch client keys on mount
-     * @default true
-     */
-    autoFetch?: boolean;
-}
-interface UseClientKeysReturn {
-    /**
-     * Array of client keys
-     */
-    keys: ClientKey[];
-    /**
-     * Whether keys are being fetched
-     */
-    isLoading: boolean;
-    /**
-     * Any error that occurred
-     */
-    error: Error | null;
-    /**
-     * Refetch client keys
-     */
-    refetch: () => Promise<void>;
-    /**
-     * Create a new client key
-     */
-    createKey: (request: CreateClientKeyRequest) => Promise<{
-        key: string;
-        keyData: ClientKey;
-    }>;
-    /**
-     * Update a client key
-     */
-    updateKey: (keyId: string, update: {
-        name?: string;
-        description?: string;
-    }) => Promise<void>;
-    /**
-     * Revoke a client key
-     */
-    revokeKey: (keyId: string) => Promise<void>;
-    /**
-     * Delete a client key
-     */
-    deleteKey: (keyId: string) => Promise<void>;
-}
-/**
- * Hook for managing client keys
- *
- * Provides client key list and management functions.
- *
- * @example
- * ```tsx
- * function ClientKeyManager() {
- *   const { keys, isLoading, createKey, revokeKey } = useClientKeys()
- *
- *   const handleCreate = async () => {
- *     const { key, keyData } = await createKey({
- *       name: 'Backend Service',
- *       description: 'Client key for backend',
- *       expires_at: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString()
- *     })
- *     alert(`Key created: ${key}`)
- *   }
- *
- *   return (
- *     <div>
- *       <button onClick={handleCreate}>Create Key</button>
- *       {keys.map(k => (
- *         <div key={k.id}>
- *           {k.name}
- *           <button onClick={() => revokeKey(k.id)}>Revoke</button>
- *         </div>
- *       ))}
- *     </div>
- *   )
- * }
- * ```
- */
-declare function useClientKeys(options?: UseClientKeysOptions): UseClientKeysReturn;
-/**
- * @deprecated Use useClientKeys instead
- */
-declare const useAPIKeys: typeof useClientKeys;
-
-/**
- * Admin Settings and Management Hooks
- *
- * Hooks for managing application settings, system settings, and webhooks.
- */
-
-interface UseAppSettingsOptions {
-    autoFetch?: boolean;
-}
-interface UseAppSettingsReturn {
-    settings: AppSettings | null;
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-    updateSettings: (update: UpdateAppSettingsRequest) => Promise<void>;
-}
-/**
- * Hook for managing application settings
- *
- * @example
- * ```tsx
- * function SettingsPanel() {
- *   const { settings, isLoading, updateSettings } = useAppSettings({ autoFetch: true })
- *
- *   const handleToggleFeature = async (feature: string, enabled: boolean) => {
- *     await updateSettings({
- *       features: { ...settings?.features, [feature]: enabled }
- *     })
- *   }
- *
- *   return <div>...</div>
- * }
- * ```
- */
-declare function useAppSettings(options?: UseAppSettingsOptions): UseAppSettingsReturn;
-interface UseSystemSettingsOptions {
-    autoFetch?: boolean;
-}
-interface UseSystemSettingsReturn {
-    settings: SystemSetting[];
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-    getSetting: (key: string) => SystemSetting | undefined;
-    updateSetting: (key: string, update: UpdateSystemSettingRequest) => Promise<void>;
-    deleteSetting: (key: string) => Promise<void>;
-}
-/**
- * Hook for managing system settings (key-value storage)
- *
- * @example
- * ```tsx
- * function SystemSettings() {
- *   const { settings, isLoading, updateSetting } = useSystemSettings({ autoFetch: true })
- *
- *   const handleUpdateSetting = async (key: string, value: any) => {
- *     await updateSetting(key, { value })
- *   }
- *
- *   return <div>...</div>
- * }
- * ```
- */
-declare function useSystemSettings(options?: UseSystemSettingsOptions): UseSystemSettingsReturn;
-interface UseWebhooksOptions {
-    autoFetch?: boolean;
-    refetchInterval?: number;
-}
-interface UseWebhooksReturn {
-    webhooks: Webhook[];
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-    createWebhook: (webhook: CreateWebhookRequest) => Promise<Webhook>;
-    updateWebhook: (id: string, update: UpdateWebhookRequest) => Promise<Webhook>;
-    deleteWebhook: (id: string) => Promise<void>;
-    testWebhook: (id: string) => Promise<void>;
-}
-/**
- * Hook for managing webhooks
- *
- * @example
- * ```tsx
- * function WebhooksManager() {
- *   const { webhooks, isLoading, createWebhook, deleteWebhook } = useWebhooks({
- *     autoFetch: true
- *   })
- *
- *   const handleCreate = async () => {
- *     await createWebhook({
- *       url: 'https://example.com/webhook',
- *       events: ['user.created', 'user.updated'],
- *       enabled: true
- *     })
- *   }
- *
- *   return <div>...</div>
- * }
- * ```
- */
-declare function useWebhooks(options?: UseWebhooksOptions): UseWebhooksReturn;
-
-/**
- * Table Export Hooks
- *
- * React hooks for exporting database tables to knowledge bases and managing sync configurations.
- */
-
-interface UseTableDetailsOptions {
-    schema?: string;
-    table?: string;
-    autoFetch?: boolean;
-}
-interface UseTableDetailsReturn {
-    data: TableDetails | null;
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-}
-/**
- * Hook for fetching detailed table information including columns
- *
- * @example
- * ```tsx
- * function TableColumnsList({ schema, table }: { schema: string; table: string }) {
- *   const { data, isLoading, error } = useTableDetails({ schema, table })
- *
- *   if (isLoading) return <div>Loading...</div>
- *   if (error) return <div>Error: {error.message}</div>
- *
- *   return (
- *     <ul>
- *       {data?.columns.map(col => (
- *         <li key={col.name}>
- *           {col.name} ({col.data_type})
- *           {col.is_primary_key && ' 🔑'}
- *         </li>
- *       ))}
- *     </ul>
- *   )
- * }
- * ```
- */
-declare function useTableDetails(options: UseTableDetailsOptions): UseTableDetailsReturn;
-interface UseExportTableReturn {
-    exportTable: (options: ExportTableOptions) => Promise<ExportTableResult | null>;
-    isLoading: boolean;
-    error: Error | null;
-    reset: () => void;
-}
-/**
- * Hook for exporting a table to a knowledge base
- *
- * @example
- * ```tsx
- * function ExportTableButton({ kbId, schema, table }: Props) {
- *   const { exportTable, isLoading, error } = useExportTable(kbId)
- *
- *   const handleExport = async () => {
- *     const result = await exportTable({
- *       schema,
- *       table,
- *       columns: ['id', 'name', 'email'],
- *       include_foreign_keys: true,
- *     })
- *     if (result) {
- *       console.log('Exported document:', result.document_id)
- *     }
- *   }
- *
- *   return (
- *     <button onClick={handleExport} disabled={isLoading}>
- *       {isLoading ? 'Exporting...' : 'Export Table'}
- *     </button>
- *   )
- * }
- * ```
- */
-declare function useExportTable(knowledgeBaseId: string): UseExportTableReturn;
-interface UseTableExportSyncsOptions {
-    autoFetch?: boolean;
-}
-interface UseTableExportSyncsReturn {
-    configs: TableExportSyncConfig[];
-    isLoading: boolean;
-    error: Error | null;
-    refetch: () => Promise<void>;
-}
-/**
- * Hook for listing table export sync configurations
- *
- * @example
- * ```tsx
- * function SyncConfigsList({ kbId }: { kbId: string }) {
- *   const { configs, isLoading, error } = useTableExportSyncs(kbId)
- *
- *   if (isLoading) return <div>Loading...</div>
- *
- *   return (
- *     <ul>
- *       {configs.map(config => (
- *         <li key={config.id}>
- *           {config.schema_name}.{config.table_name} ({config.sync_mode})
- *         </li>
- *       ))}
- *     </ul>
- *   )
- * }
- * ```
- */
-declare function useTableExportSyncs(knowledgeBaseId: string, options?: UseTableExportSyncsOptions): UseTableExportSyncsReturn;
-interface UseCreateTableExportSyncReturn {
-    createSync: (config: CreateTableExportSyncConfig) => Promise<TableExportSyncConfig | null>;
-    isLoading: boolean;
-    error: Error | null;
-}
-/**
- * Hook for creating a table export sync configuration
- *
- * @example
- * ```tsx
- * function CreateSyncForm({ kbId }: { kbId: string }) {
- *   const { createSync, isLoading, error } = useCreateTableExportSync(kbId)
- *
- *   const handleSubmit = async (e: React.FormEvent) => {
- *     e.preventDefault()
- *     const config = await createSync({
- *       schema_name: 'public',
- *       table_name: 'users',
- *       columns: ['id', 'name', 'email'],
- *       sync_mode: 'automatic',
- *       sync_on_insert: true,
- *       sync_on_update: true,
- *     })
- *     if (config) {
- *       console.log('Created sync config:', config.id)
- *     }
- *   }
- *
- *   return <form onSubmit={handleSubmit}>...</form>
- * }
- * ```
- */
-declare function useCreateTableExportSync(knowledgeBaseId: string): UseCreateTableExportSyncReturn;
-interface UseUpdateTableExportSyncReturn {
-    updateSync: (syncId: string, updates: UpdateTableExportSyncConfig) => Promise<TableExportSyncConfig | null>;
-    isLoading: boolean;
-    error: Error | null;
-}
-/**
- * Hook for updating a table export sync configuration
- */
-declare function useUpdateTableExportSync(knowledgeBaseId: string): UseUpdateTableExportSyncReturn;
-interface UseDeleteTableExportSyncReturn {
-    deleteSync: (syncId: string) => Promise<boolean>;
-    isLoading: boolean;
-    error: Error | null;
-}
-/**
- * Hook for deleting a table export sync configuration
- */
-declare function useDeleteTableExportSync(knowledgeBaseId: string): UseDeleteTableExportSyncReturn;
-interface UseTriggerTableExportSyncReturn {
-    triggerSync: (syncId: string) => Promise<ExportTableResult | null>;
-    isLoading: boolean;
-    error: Error | null;
-}
-/**
- * Hook for manually triggering a table export sync
- *
- * @example
- * ```tsx
- * function TriggerSyncButton({ kbId, syncId }: Props) {
- *   const { triggerSync, isLoading, error } = useTriggerTableExportSync(kbId)
- *
- *   const handleTrigger = async () => {
- *     const result = await triggerSync(syncId)
- *     if (result) {
- *       console.log('Sync completed:', result.document_id)
- *     }
- *   }
- *
- *   return (
- *     <button onClick={handleTrigger} disabled={isLoading}>
- *       {isLoading ? 'Syncing...' : 'Sync Now'}
- *     </button>
- *   )
- * }
- * ```
- */
-declare function useTriggerTableExportSync(knowledgeBaseId: string): UseTriggerTableExportSyncReturn;
-
-export { type CaptchaState, FluxbaseProvider, type UseCreateTableExportSyncReturn, type UseDeleteTableExportSyncReturn, type UseExportTableReturn, type UseGraphQLMutationOptions, type UseGraphQLQueryOptions, type UseTableDetailsOptions, type UseTableDetailsReturn, type UseTableExportSyncsOptions, type UseTableExportSyncsReturn, type UseTriggerTableExportSyncReturn, type UseUpdateTableExportSyncReturn, isCaptchaRequiredForEndpoint, useAPIKeys, useAdminAuth, useAppSettings, useAuth, useAuthConfig, useCaptcha, useCaptchaConfig, useClientKeys, useCreateBucket, useCreateTableExportSync, useDelete, useDeleteBucket, useDeleteTableExportSync, useExportTable, 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, useTableDetails, useTableExportSyncs, useTableInserts, useTableSubscription, useTableUpdates, useTriggerTableExportSync, useUpdate, useUpdateTableExportSync, useUpdateUser, useUpsert, useUser, useUsers, useWebhooks };