@fluxbase/sdk 0.0.1-rc.41 → 0.0.1-rc.43

package/dist/index.d.ts

@@ -226,6 +226,7 @@ interface RealtimeMessage {
     broadcast?: any;
     messageId?: string;
     status?: string;
+    subscription_id?: string;
 }
 interface PostgresChangesConfig {
     event: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
@@ -1220,6 +1221,11 @@ interface FunctionInvokeOptions {
      * @default 'POST'
      */
     method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /**
+     * Namespace of the function to invoke
+     * If not provided, the first function with the given name is used (alphabetically by namespace)
+     */
+    namespace?: string;
 }
 /**
  * Edge function metadata
@@ -1227,6 +1233,7 @@ interface FunctionInvokeOptions {
 interface EdgeFunction {
     id: string;
     name: string;
+    namespace: string;
     description?: string;
     code: string;
     version: number;
@@ -1292,6 +1299,375 @@ interface EdgeFunctionExecution {
     executed_at: string;
     completed_at?: string;
 }
+/**
+ * Function specification for bulk sync operations
+ */
+interface FunctionSpec {
+    name: string;
+    description?: string;
+    code: string;
+    enabled?: boolean;
+    timeout_seconds?: number;
+    memory_limit_mb?: number;
+    allow_net?: boolean;
+    allow_env?: boolean;
+    allow_read?: boolean;
+    allow_write?: boolean;
+    allow_unauthenticated?: boolean;
+    is_public?: boolean;
+    cron_schedule?: string;
+}
+/**
+ * Options for syncing functions
+ */
+interface SyncFunctionsOptions {
+    /** Namespace to sync functions to (defaults to "default") */
+    namespace?: string;
+    /** Functions to sync */
+    functions: FunctionSpec[];
+    /** Options for sync operation */
+    options?: {
+        /** Delete functions in namespace that are not in the sync payload */
+        delete_missing?: boolean;
+        /** Preview changes without applying them */
+        dry_run?: boolean;
+    };
+}
+/**
+ * Sync operation error details
+ */
+interface SyncError {
+    /** Name of the function that failed */
+    function: string;
+    /** Error message */
+    error: string;
+    /** Operation that failed */
+    action: 'create' | 'update' | 'delete' | 'bundle';
+}
+/**
+ * Result of a function sync operation
+ */
+interface SyncFunctionsResult {
+    /** Status message */
+    message: string;
+    /** Namespace that was synced */
+    namespace: string;
+    /** Summary counts */
+    summary: {
+        created: number;
+        updated: number;
+        deleted: number;
+        unchanged: number;
+        errors: number;
+    };
+    /** Detailed results */
+    details: {
+        created: string[];
+        updated: string[];
+        deleted: string[];
+        unchanged: string[];
+    };
+    /** Errors encountered */
+    errors: SyncError[];
+    /** Whether this was a dry run */
+    dry_run: boolean;
+}
+/**
+ * Job function metadata
+ */
+interface JobFunction {
+    id: string;
+    name: string;
+    namespace: string;
+    description?: string;
+    code?: string;
+    original_code?: string;
+    is_bundled: boolean;
+    bundle_error?: string;
+    enabled: boolean;
+    schedule?: string;
+    timeout_seconds: number;
+    memory_limit_mb: number;
+    max_retries: number;
+    progress_timeout_seconds: number;
+    allow_net: boolean;
+    allow_env: boolean;
+    allow_read: boolean;
+    allow_write: boolean;
+    require_role?: string;
+    version: number;
+    created_by?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Request to create a new job function
+ */
+interface CreateJobFunctionRequest {
+    name: string;
+    namespace?: string;
+    description?: string;
+    code: string;
+    enabled?: boolean;
+    schedule?: string;
+    timeout_seconds?: number;
+    memory_limit_mb?: number;
+    max_retries?: number;
+    progress_timeout_seconds?: number;
+    allow_net?: boolean;
+    allow_env?: boolean;
+    allow_read?: boolean;
+    allow_write?: boolean;
+    require_role?: string;
+}
+/**
+ * Request to update an existing job function
+ */
+interface UpdateJobFunctionRequest {
+    description?: string;
+    code?: string;
+    enabled?: boolean;
+    schedule?: string;
+    timeout_seconds?: number;
+    memory_limit_mb?: number;
+    max_retries?: number;
+    progress_timeout_seconds?: number;
+    allow_net?: boolean;
+    allow_env?: boolean;
+    allow_read?: boolean;
+    allow_write?: boolean;
+    require_role?: string;
+}
+/**
+ * Job execution status
+ */
+type JobStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timeout';
+/**
+ * Job execution record
+ */
+interface Job {
+    id: string;
+    namespace: string;
+    job_function_id?: string;
+    job_name: string;
+    status: JobStatus;
+    payload?: any;
+    result?: any;
+    error?: string;
+    logs?: string;
+    priority: number;
+    max_duration_seconds?: number;
+    progress_timeout_seconds?: number;
+    progress_percent?: number;
+    progress_message?: string;
+    progress_data?: any;
+    max_retries: number;
+    retry_count: number;
+    worker_id?: string;
+    created_by?: string;
+    user_role?: string;
+    user_email?: string;
+    created_at: string;
+    started_at?: string;
+    completed_at?: string;
+    scheduled_at?: string;
+    last_progress_at?: string;
+    /** Estimated completion time (computed, only for running jobs with progress > 0) */
+    estimated_completion_at?: string;
+    /** Estimated seconds remaining (computed, only for running jobs with progress > 0) */
+    estimated_seconds_left?: number;
+}
+/**
+ * Job statistics
+ */
+interface JobStats {
+    namespace?: string;
+    pending: number;
+    running: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    total: number;
+}
+/**
+ * Job worker information
+ */
+interface JobWorker {
+    id: string;
+    hostname: string;
+    status: 'active' | 'idle' | 'dead';
+    current_jobs: number;
+    total_completed: number;
+    started_at: string;
+    last_heartbeat_at: string;
+}
+/**
+ * Job function specification for sync operations
+ */
+interface JobFunctionSpec {
+    name: string;
+    description?: string;
+    code: string;
+    /** If true, code is already bundled and server will skip bundling */
+    is_pre_bundled?: boolean;
+    /** Original source code (for debugging when pre-bundled) */
+    original_code?: string;
+    enabled?: boolean;
+    schedule?: string;
+    timeout_seconds?: number;
+    memory_limit_mb?: number;
+    max_retries?: number;
+    progress_timeout_seconds?: number;
+    allow_net?: boolean;
+    allow_env?: boolean;
+    allow_read?: boolean;
+    allow_write?: boolean;
+    require_role?: string;
+}
+/**
+ * Options for syncing job functions
+ */
+interface SyncJobsOptions {
+    namespace: string;
+    functions?: JobFunctionSpec[];
+    options?: {
+        delete_missing?: boolean;
+        dry_run?: boolean;
+    };
+}
+/**
+ * Result of a job sync operation
+ */
+interface SyncJobsResult {
+    message: string;
+    namespace: string;
+    summary: {
+        created: number;
+        updated: number;
+        deleted: number;
+        unchanged: number;
+        errors: number;
+    };
+    details: {
+        created: string[];
+        updated: string[];
+        deleted: string[];
+        unchanged: string[];
+    };
+    errors: SyncError[];
+    dry_run: boolean;
+}
+/**
+ * Database migration metadata
+ */
+interface Migration {
+    id: string;
+    namespace: string;
+    name: string;
+    description?: string;
+    up_sql: string;
+    down_sql?: string;
+    version: number;
+    status: 'pending' | 'applied' | 'failed' | 'rolled_back';
+    created_by?: string;
+    applied_by?: string;
+    created_at: string;
+    updated_at: string;
+    applied_at?: string;
+    rolled_back_at?: string;
+}
+/**
+ * Request to create a new migration
+ */
+interface CreateMigrationRequest {
+    namespace?: string;
+    name: string;
+    description?: string;
+    up_sql: string;
+    down_sql?: string;
+}
+/**
+ * Request to update a migration (only if pending)
+ */
+interface UpdateMigrationRequest {
+    description?: string;
+    up_sql?: string;
+    down_sql?: string;
+}
+/**
+ * Migration execution record (audit log)
+ */
+interface MigrationExecution {
+    id: string;
+    migration_id: string;
+    action: 'apply' | 'rollback';
+    status: 'success' | 'failed';
+    duration_ms?: number;
+    error_message?: string;
+    logs?: string;
+    executed_at: string;
+    executed_by?: string;
+}
+/**
+ * Request to apply a migration
+ */
+interface ApplyMigrationRequest {
+    namespace?: string;
+}
+/**
+ * Request to rollback a migration
+ */
+interface RollbackMigrationRequest {
+    namespace?: string;
+}
+/**
+ * Request to apply pending migrations
+ */
+interface ApplyPendingRequest {
+    namespace?: string;
+}
+/**
+ * Options for syncing migrations
+ */
+interface SyncMigrationsOptions {
+    /** Update pending migrations if SQL content changed */
+    update_if_changed?: boolean;
+    /** Automatically apply new migrations after sync */
+    auto_apply?: boolean;
+    /** Preview changes without applying them */
+    dry_run?: boolean;
+}
+/**
+ * Result of a migration sync operation
+ */
+interface SyncMigrationsResult {
+    /** Status message */
+    message: string;
+    /** Namespace that was synced */
+    namespace: string;
+    /** Summary counts */
+    summary: {
+        created: number;
+        updated: number;
+        unchanged: number;
+        skipped: number;
+        applied: number;
+        errors: number;
+    };
+    /** Detailed results */
+    details: {
+        created: string[];
+        updated: string[];
+        unchanged: string[];
+        skipped: string[];
+        applied: string[];
+        errors: string[];
+    };
+    /** Whether this was a dry run */
+    dry_run: boolean;
+    /** Warning messages */
+    warnings?: string[];
+}
 /**
  * Base Fluxbase response type (Supabase-compatible)
  * Returns either `{ data, error: null }` on success or `{ data: null, error }` on failure
@@ -1365,6 +1741,7 @@ declare class RealtimeChannel {
     private presenceCallbacks;
     private broadcastCallbacks;
     private subscriptionConfig;
+    private subscriptionId;
     private _presenceState;
     private myPresenceKey;
     private config;
@@ -2159,9 +2536,11 @@ declare class FluxbaseStorage {
  */
 
 /**
- * Edge Functions client for invoking and managing serverless functions
+ * Edge Functions client for invoking serverless functions
  * API-compatible with Supabase Functions
  *
+ * For admin operations (create, update, delete, sync), use client.admin.functions
+ *
  * @category Functions
  */
 declare class FluxbaseFunctions {
@@ -2173,16 +2552,22 @@ declare class FluxbaseFunctions {
      * This method is fully compatible with Supabase's functions.invoke() API.
      *
      * @param functionName - The name of the function to invoke
-     * @param options - Invocation options including body, headers, and HTTP method
+     * @param options - Invocation options including body, headers, HTTP method, and namespace
      * @returns Promise resolving to { data, error } tuple
      *
      * @example
      * ```typescript
-     * // Simple invocation
+     * // Simple invocation (uses first matching function by namespace alphabetically)
      * const { data, error } = await client.functions.invoke('hello', {
      *   body: { name: 'World' }
      * })
      *
+     * // Invoke a specific namespace's function
+     * const { data, error } = await client.functions.invoke('hello', {
+     *   body: { name: 'World' },
+     *   namespace: 'my-app'
+     * })
+     *
      * // With GET method
      * const { data, error } = await client.functions.invoke('get-data', {
      *   method: 'GET'
@@ -2201,28 +2586,9 @@ declare class FluxbaseFunctions {
         error: Error | null;
     }>;
     /**
-     * Create a new edge function
-     *
-     * @param request - Function configuration and code
-     * @returns Promise resolving to { data, error } tuple with created function metadata
-     *
-     * @example
-     * ```typescript
-     * const { data, error } = await client.functions.create({
-     *   name: 'my-function',
-     *   code: 'export default async function handler(req) { return { hello: "world" } }',
-     *   enabled: true
-     * })
-     * ```
-     */
-    create(request: CreateFunctionRequest): Promise<{
-        data: EdgeFunction | null;
-        error: Error | null;
-    }>;
-    /**
-     * List all edge functions
+     * List all public edge functions
      *
-     * @returns Promise resolving to { data, error } tuple with array of functions
+     * @returns Promise resolving to { data, error } tuple with array of public functions
      *
      * @example
      * ```typescript
@@ -2254,65 +2620,178 @@ declare class FluxbaseFunctions {
         data: EdgeFunction | null;
         error: Error | null;
     }>;
+}
+
+/**
+ * Jobs module for Fluxbase SDK
+ * Client-facing API for submitting and monitoring background jobs
+ *
+ * @example
+ * ```typescript
+ * // Submit a job
+ * const { data, error } = await client.jobs.submit('process-data', {
+ *   items: [1, 2, 3]
+ * })
+ *
+ * // Get job status
+ * const { data: job, error } = await client.jobs.get(data.id)
+ * console.log('Job status:', job.status)
+ *
+ * // Cancel a running job
+ * await client.jobs.cancel(data.id)
+ * ```
+ */
+
+/**
+ * Jobs client for submitting and monitoring background jobs
+ *
+ * For admin operations (create job functions, manage workers, view all jobs),
+ * use client.admin.jobs
+ *
+ * @category Jobs
+ */
+declare class FluxbaseJobs {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
     /**
-     * Update an existing edge function
+     * Submit a new job for execution
      *
-     * @param name - Function name
-     * @param updates - Fields to update
-     * @returns Promise resolving to { data, error } tuple with updated function metadata
+     * @param jobName - Name of the job function to execute
+     * @param payload - Job input data
+     * @param options - Additional options (priority, namespace, scheduled time)
+     * @returns Promise resolving to { data, error } tuple with submitted job details
      *
      * @example
      * ```typescript
-     * const { data, error } = await client.functions.update('my-function', {
-     *   enabled: false,
-     *   description: 'Updated description'
+     * // Submit a simple job
+     * const { data, error } = await client.jobs.submit('send-email', {
+     *   to: 'user@example.com',
+     *   subject: 'Hello',
+     *   body: 'Welcome!'
+     * })
+     *
+     * if (data) {
+     *   console.log('Job submitted:', data.id)
+     *   console.log('Status:', data.status)
+     * }
+     *
+     * // Submit with priority
+     * const { data } = await client.jobs.submit('high-priority-task', payload, {
+     *   priority: 10
+     * })
+     *
+     * // Schedule for later
+     * const { data } = await client.jobs.submit('scheduled-task', payload, {
+     *   scheduled: '2025-01-01T00:00:00Z'
      * })
      * ```
      */
-    update(name: string, updates: UpdateFunctionRequest): Promise<{
-        data: EdgeFunction | null;
+    submit(jobName: string, payload?: any, options?: {
+        priority?: number;
+        namespace?: string;
+        scheduled?: string;
+    }): Promise<{
+        data: Job | null;
         error: Error | null;
     }>;
     /**
-     * Delete an edge function
+     * Get status and details of a specific job
      *
-     * @param name - Function name
-     * @returns Promise resolving to { data, error } tuple
+     * @param jobId - Job ID
+     * @returns Promise resolving to { data, error } tuple with job details
+     *
+     * @example
+     * ```typescript
+     * const { data: job, error } = await client.jobs.get('550e8400-e29b-41d4-a716-446655440000')
+     *
+     * if (job) {
+     *   console.log('Status:', job.status)
+     *   console.log('Progress:', job.progress_percent + '%')
+     *   console.log('Result:', job.result)
+     *   console.log('Logs:', job.logs)
+     * }
+     * ```
+     */
+    get(jobId: string): Promise<{
+        data: Job | null;
+        error: Error | null;
+    }>;
+    /**
+     * List jobs submitted by the current user
+     *
+     * @param filters - Optional filters (status, namespace, limit, offset)
+     * @returns Promise resolving to { data, error } tuple with array of jobs
      *
      * @example
      * ```typescript
-     * const { data, error } = await client.functions.delete('my-function')
+     * // List all your jobs
+     * const { data: jobs, error } = await client.jobs.list()
+     *
+     * // Filter by status
+     * const { data: running } = await client.jobs.list({
+     *   status: 'running'
+     * })
+     *
+     * // Paginate
+     * const { data: page } = await client.jobs.list({
+     *   limit: 20,
+     *   offset: 40
+     * })
      * ```
      */
-    delete(name: string): Promise<{
-        data: null;
+    list(filters?: {
+        status?: string;
+        namespace?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        data: Job[] | null;
         error: Error | null;
     }>;
     /**
-     * Get execution history for an edge function
+     * Cancel a pending or running job
      *
-     * @param name - Function name
-     * @param limit - Maximum number of executions to return (optional)
-     * @returns Promise resolving to { data, error } tuple with execution records
+     * @param jobId - Job ID to cancel
+     * @returns Promise resolving to { data, error } tuple
      *
      * @example
      * ```typescript
-     * const { data, error } = await client.functions.getExecutions('my-function', 10)
-     * if (data) {
-     *   data.forEach(exec => {
-     *     console.log(`${exec.executed_at}: ${exec.status} (${exec.duration_ms}ms)`)
-     *   })
+     * const { error } = await client.jobs.cancel('550e8400-e29b-41d4-a716-446655440000')
+     *
+     * if (!error) {
+     *   console.log('Job cancelled successfully')
      * }
      * ```
      */
-    getExecutions(name: string, limit?: number): Promise<{
-        data: EdgeFunctionExecution[] | null;
+    cancel(jobId: string): Promise<{
+        data: null;
         error: Error | null;
     }>;
-}
-
-/**
- * System Settings Manager
+    /**
+     * Retry a failed job
+     *
+     * Creates a new job execution with the same parameters
+     *
+     * @param jobId - Job ID to retry
+     * @returns Promise resolving to { data, error } tuple with new job
+     *
+     * @example
+     * ```typescript
+     * const { data: newJob, error } = await client.jobs.retry('550e8400-e29b-41d4-a716-446655440000')
+     *
+     * if (newJob) {
+     *   console.log('Job retried, new ID:', newJob.id)
+     * }
+     * ```
+     */
+    retry(jobId: string): Promise<{
+        data: Job | null;
+        error: Error | null;
+    }>;
+}
+
+/**
+ * System Settings Manager
  *
  * Manages low-level system settings with key-value storage.
  * For application-level settings, use AppSettingsManager instead.
@@ -4137,35 +4616,907 @@ declare class FluxbaseManagement {
 }
 
 /**
- * Admin client for managing Fluxbase instance
+ * Admin Functions module for managing edge functions
+ * Provides administrative operations for function lifecycle management
  */
-declare class FluxbaseAdmin {
+
+/**
+ * Admin Functions manager for managing edge functions
+ * Provides create, update, delete, and bulk sync operations
+ *
+ * @category Admin
+ */
+declare class FluxbaseAdminFunctions {
     private fetch;
-    private adminToken;
+    constructor(fetch: FluxbaseFetch);
     /**
-     * Settings manager for system and application settings
+     * Create a new edge function
+     *
+     * @param request - Function configuration and code
+     * @returns Promise resolving to { data, error } tuple with created function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.functions.create({
+     *   name: 'my-function',
+     *   code: 'export default async function handler(req) { return { hello: "world" } }',
+     *   enabled: true
+     * })
+     * ```
      */
-    settings: FluxbaseSettings;
+    create(request: CreateFunctionRequest): Promise<{
+        data: EdgeFunction | null;
+        error: Error | null;
+    }>;
     /**
-     * DDL manager for database schema and table operations
+     * List all namespaces that have edge functions
+     *
+     * @returns Promise resolving to { data, error } tuple with array of namespace strings
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.functions.listNamespaces()
+     * if (data) {
+     *   console.log('Available namespaces:', data)
+     * }
+     * ```
      */
-    ddl: DDLManager;
+    listNamespaces(): Promise<{
+        data: string[] | null;
+        error: Error | null;
+    }>;
     /**
-     * OAuth configuration manager for provider and auth settings
+     * List all edge functions (admin view)
+     *
+     * @param namespace - Optional namespace filter (if not provided, lists all public functions)
+     * @returns Promise resolving to { data, error } tuple with array of functions
+     *
+     * @example
+     * ```typescript
+     * // List all public functions
+     * const { data, error } = await client.admin.functions.list()
+     *
+     * // List functions in a specific namespace
+     * const { data, error } = await client.admin.functions.list('my-namespace')
+     * if (data) {
+     *   console.log('Functions:', data.map(f => f.name))
+     * }
+     * ```
      */
-    oauth: FluxbaseOAuth;
+    list(namespace?: string): Promise<{
+        data: EdgeFunction[] | null;
+        error: Error | null;
+    }>;
     /**
-     * Impersonation manager for user impersonation and audit trail
+     * Get details of a specific edge function
+     *
+     * @param name - Function name
+     * @returns Promise resolving to { data, error } tuple with function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.functions.get('my-function')
+     * if (data) {
+     *   console.log('Function version:', data.version)
+     * }
+     * ```
      */
-    impersonation: ImpersonationManager;
+    get(name: string): Promise<{
+        data: EdgeFunction | null;
+        error: Error | null;
+    }>;
     /**
-     * Management namespace for API keys, webhooks, and invitations
+     * Update an existing edge function
+     *
+     * @param name - Function name
+     * @param updates - Fields to update
+     * @returns Promise resolving to { data, error } tuple with updated function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.functions.update('my-function', {
+     *   enabled: false,
+     *   description: 'Updated description'
+     * })
+     * ```
      */
-    management: FluxbaseManagement;
+    update(name: string, updates: UpdateFunctionRequest): Promise<{
+        data: EdgeFunction | null;
+        error: Error | null;
+    }>;
     /**
-     * Email template manager for customizing authentication and notification emails
+     * Delete an edge function
+     *
+     * @param name - Function name
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.functions.delete('my-function')
+     * ```
      */
-    emailTemplates: EmailTemplateManager;
+    delete(name: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Get execution history for an edge function
+     *
+     * @param name - Function name
+     * @param limit - Maximum number of executions to return (optional)
+     * @returns Promise resolving to { data, error } tuple with execution records
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.functions.getExecutions('my-function', 10)
+     * if (data) {
+     *   data.forEach(exec => {
+     *     console.log(`${exec.executed_at}: ${exec.status} (${exec.duration_ms}ms)`)
+     *   })
+     * }
+     * ```
+     */
+    getExecutions(name: string, limit?: number): Promise<{
+        data: EdgeFunctionExecution[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Sync multiple functions to a namespace
+     *
+     * Bulk create/update/delete functions in a specific namespace. This is useful for
+     * deploying functions from your application to Fluxbase in Kubernetes or other
+     * container environments.
+     *
+     * Requires service_role or admin authentication.
+     *
+     * @param options - Sync configuration including namespace, functions, and options
+     * @returns Promise resolving to { data, error } tuple with sync results
+     *
+     * @example
+     * ```typescript
+     * // Sync functions to "payment-service" namespace
+     * const { data, error } = await client.admin.functions.sync({
+     *   namespace: 'payment-service',
+     *   functions: [
+     *     {
+     *       name: 'process-payment',
+     *       code: 'export default async function handler(req) { ... }',
+     *       enabled: true,
+     *       allow_net: true
+     *     },
+     *     {
+     *       name: 'refund-payment',
+     *       code: 'export default async function handler(req) { ... }',
+     *       enabled: true
+     *     }
+     *   ],
+     *   options: {
+     *     delete_missing: true  // Remove functions not in this list
+     *   }
+     * })
+     *
+     * if (data) {
+     *   console.log(`Synced: ${data.summary.created} created, ${data.summary.updated} updated`)
+     * }
+     *
+     * // Dry run to preview changes
+     * const { data, error } = await client.admin.functions.sync({
+     *   namespace: 'myapp',
+     *   functions: [...],
+     *   options: { dry_run: true }
+     * })
+     * ```
+     */
+    sync(options: SyncFunctionsOptions): Promise<{
+        data: SyncFunctionsResult | null;
+        error: Error | null;
+    }>;
+}
+
+/**
+ * Admin Migrations module for managing database migrations
+ * Provides API-based migration management without filesystem coupling
+ */
+
+/**
+ * Admin Migrations manager for database migration operations
+ * Provides create, update, delete, apply, rollback, and smart sync operations
+ *
+ * @category Admin
+ */
+declare class FluxbaseAdminMigrations {
+    private fetch;
+    private localMigrations;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Register a migration locally for smart sync
+     *
+     * Call this method to register migrations in your application code.
+     * When you call sync(), only new or changed migrations will be sent to the server.
+     *
+     * @param migration - Migration definition
+     * @returns { error } tuple (always succeeds unless validation fails)
+     *
+     * @example
+     * ```typescript
+     * // In your app initialization
+     * const { error: err1 } = client.admin.migrations.register({
+     *   name: '001_create_users_table',
+     *   namespace: 'myapp',
+     *   up_sql: 'CREATE TABLE app.users (...)',
+     *   down_sql: 'DROP TABLE app.users',
+     *   description: 'Initial users table'
+     * })
+     *
+     * const { error: err2 } = client.admin.migrations.register({
+     *   name: '002_add_posts_table',
+     *   namespace: 'myapp',
+     *   up_sql: 'CREATE TABLE app.posts (...)',
+     *   down_sql: 'DROP TABLE app.posts'
+     * })
+     *
+     * // Sync all registered migrations
+     * await client.admin.migrations.sync()
+     * ```
+     */
+    register(migration: CreateMigrationRequest): {
+        error: Error | null;
+    };
+    /**
+     * Trigger schema refresh which will restart the server
+     * Handles the restart gracefully by waiting for the server to come back online
+     *
+     * @private
+     */
+    private triggerSchemaRefreshWithRestart;
+    /**
+     * Helper function to sleep for a given duration
+     * @private
+     */
+    private sleep;
+    /**
+     * Smart sync all registered migrations
+     *
+     * Automatically determines which migrations need to be created or updated by:
+     * 1. Fetching existing migrations from the server
+     * 2. Comparing content hashes to detect changes
+     * 3. Only sending new or changed migrations
+     *
+     * After successful sync, can optionally auto-apply new migrations and refresh
+     * the server's schema cache.
+     *
+     * @param options - Sync options
+     * @returns Promise resolving to { data, error } tuple with sync results
+     *
+     * @example
+     * ```typescript
+     * // Basic sync (idempotent - safe to call on every app startup)
+     * const { data, error } = await client.admin.migrations.sync()
+     * if (data) {
+     *   console.log(`Created: ${data.summary.created}, Updated: ${data.summary.updated}`)
+     * }
+     *
+     * // Sync with auto-apply (applies new migrations automatically)
+     * const { data, error } = await client.admin.migrations.sync({
+     *   auto_apply: true
+     * })
+     *
+     * // Dry run to preview changes without applying
+     * const { data, error } = await client.admin.migrations.sync({
+     *   dry_run: true
+     * })
+     * ```
+     */
+    sync(options?: Partial<SyncMigrationsOptions>): Promise<{
+        data: SyncMigrationsResult | null;
+        error: Error | null;
+    }>;
+    /**
+     * Create a new migration
+     *
+     * @param request - Migration configuration
+     * @returns Promise resolving to { data, error } tuple with created migration
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.migrations.create({
+     *   namespace: 'myapp',
+     *   name: '001_create_users',
+     *   up_sql: 'CREATE TABLE app.users (id UUID PRIMARY KEY, email TEXT)',
+     *   down_sql: 'DROP TABLE app.users',
+     *   description: 'Create users table'
+     * })
+     * ```
+     */
+    create(request: CreateMigrationRequest): Promise<{
+        data: Migration | null;
+        error: Error | null;
+    }>;
+    /**
+     * List migrations in a namespace
+     *
+     * @param namespace - Migration namespace (default: 'default')
+     * @param status - Filter by status: 'pending', 'applied', 'failed', 'rolled_back'
+     * @returns Promise resolving to { data, error } tuple with migrations array
+     *
+     * @example
+     * ```typescript
+     * // List all migrations
+     * const { data, error } = await client.admin.migrations.list('myapp')
+     *
+     * // List only pending migrations
+     * const { data, error } = await client.admin.migrations.list('myapp', 'pending')
+     * ```
+     */
+    list(namespace?: string, status?: 'pending' | 'applied' | 'failed' | 'rolled_back'): Promise<{
+        data: Migration[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get details of a specific migration
+     *
+     * @param name - Migration name
+     * @param namespace - Migration namespace (default: 'default')
+     * @returns Promise resolving to { data, error } tuple with migration details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.migrations.get('001_create_users', 'myapp')
+     * ```
+     */
+    get(name: string, namespace?: string): Promise<{
+        data: Migration | null;
+        error: Error | null;
+    }>;
+    /**
+     * Update a migration (only if status is pending)
+     *
+     * @param name - Migration name
+     * @param updates - Fields to update
+     * @param namespace - Migration namespace (default: 'default')
+     * @returns Promise resolving to { data, error } tuple with updated migration
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.migrations.update(
+     *   '001_create_users',
+     *   { description: 'Updated description' },
+     *   'myapp'
+     * )
+     * ```
+     */
+    update(name: string, updates: UpdateMigrationRequest, namespace?: string): Promise<{
+        data: Migration | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a migration (only if status is pending)
+     *
+     * @param name - Migration name
+     * @param namespace - Migration namespace (default: 'default')
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.migrations.delete('001_create_users', 'myapp')
+     * ```
+     */
+    delete(name: string, namespace?: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Apply a specific migration
+     *
+     * @param name - Migration name
+     * @param namespace - Migration namespace (default: 'default')
+     * @returns Promise resolving to { data, error } tuple with result message
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.migrations.apply('001_create_users', 'myapp')
+     * if (data) {
+     *   console.log(data.message) // "Migration applied successfully"
+     * }
+     * ```
+     */
+    apply(name: string, namespace?: string): Promise<{
+        data: {
+            message: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Rollback a specific migration
+     *
+     * @param name - Migration name
+     * @param namespace - Migration namespace (default: 'default')
+     * @returns Promise resolving to { data, error } tuple with result message
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.migrations.rollback('001_create_users', 'myapp')
+     * ```
+     */
+    rollback(name: string, namespace?: string): Promise<{
+        data: {
+            message: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Apply all pending migrations in order
+     *
+     * @param namespace - Migration namespace (default: 'default')
+     * @returns Promise resolving to { data, error } tuple with applied/failed counts
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.migrations.applyPending('myapp')
+     * if (data) {
+     *   console.log(`Applied: ${data.applied.length}, Failed: ${data.failed.length}`)
+     * }
+     * ```
+     */
+    applyPending(namespace?: string): Promise<{
+        data: {
+            message: string;
+            applied: string[];
+            failed: string[];
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get execution history for a migration
+     *
+     * @param name - Migration name
+     * @param namespace - Migration namespace (default: 'default')
+     * @param limit - Maximum number of executions to return (default: 50, max: 100)
+     * @returns Promise resolving to { data, error } tuple with execution records
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.migrations.getExecutions(
+     *   '001_create_users',
+     *   'myapp',
+     *   10
+     * )
+     * if (data) {
+     *   data.forEach(exec => {
+     *     console.log(`${exec.executed_at}: ${exec.action} - ${exec.status}`)
+     *   })
+     * }
+     * ```
+     */
+    getExecutions(name: string, namespace?: string, limit?: number): Promise<{
+        data: MigrationExecution[] | null;
+        error: Error | null;
+    }>;
+}
+
+/**
+ * Admin Jobs module for managing job functions and executions
+ * Provides administrative operations for job lifecycle management
+ */
+
+/**
+ * Options for bundling job code
+ */
+interface BundleOptions {
+    /** Entry point code */
+    code: string;
+    /** External modules to exclude from bundle */
+    external?: string[];
+    /** Source map generation */
+    sourcemap?: boolean;
+    /** Minify output */
+    minify?: boolean;
+}
+/**
+ * Result of bundling job code
+ */
+interface BundleResult {
+    /** Bundled code */
+    code: string;
+    /** Source map (if enabled) */
+    sourceMap?: string;
+}
+/**
+ * Admin Jobs manager for managing background job functions
+ * Provides create, update, delete, sync, and monitoring operations
+ *
+ * @category Admin
+ */
+declare class FluxbaseAdminJobs {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Create a new job function
+     *
+     * @param request - Job function configuration and code
+     * @returns Promise resolving to { data, error } tuple with created job function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.create({
+     *   name: 'process-data',
+     *   code: 'export async function handler(req) { return { success: true } }',
+     *   enabled: true,
+     *   timeout_seconds: 300
+     * })
+     * ```
+     */
+    create(request: CreateJobFunctionRequest): Promise<{
+        data: JobFunction | null;
+        error: Error | null;
+    }>;
+    /**
+     * List all namespaces that have job functions
+     *
+     * @returns Promise resolving to { data, error } tuple with array of namespace strings
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.listNamespaces()
+     * if (data) {
+     *   console.log('Available namespaces:', data)
+     * }
+     * ```
+     */
+    listNamespaces(): Promise<{
+        data: string[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * List all job functions (admin view)
+     *
+     * @param namespace - Optional namespace filter
+     * @returns Promise resolving to { data, error } tuple with array of job functions
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.list('default')
+     * if (data) {
+     *   console.log('Job functions:', data.map(f => f.name))
+     * }
+     * ```
+     */
+    list(namespace?: string): Promise<{
+        data: JobFunction[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get details of a specific job function
+     *
+     * @param namespace - Namespace
+     * @param name - Job function name
+     * @returns Promise resolving to { data, error } tuple with job function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.get('default', 'process-data')
+     * if (data) {
+     *   console.log('Job function version:', data.version)
+     * }
+     * ```
+     */
+    get(namespace: string, name: string): Promise<{
+        data: JobFunction | null;
+        error: Error | null;
+    }>;
+    /**
+     * Update an existing job function
+     *
+     * @param namespace - Namespace
+     * @param name - Job function name
+     * @param updates - Fields to update
+     * @returns Promise resolving to { data, error } tuple with updated job function metadata
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.update('default', 'process-data', {
+     *   enabled: false,
+     *   timeout_seconds: 600
+     * })
+     * ```
+     */
+    update(namespace: string, name: string, updates: UpdateJobFunctionRequest): Promise<{
+        data: JobFunction | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a job function
+     *
+     * @param namespace - Namespace
+     * @param name - Job function name
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.delete('default', 'process-data')
+     * ```
+     */
+    delete(namespace: string, name: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * List all jobs (executions) across all namespaces (admin view)
+     *
+     * @param filters - Optional filters (status, namespace, limit, offset)
+     * @returns Promise resolving to { data, error } tuple with array of jobs
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.listJobs({
+     *   status: 'running',
+     *   namespace: 'default',
+     *   limit: 50
+     * })
+     * if (data) {
+     *   data.forEach(job => {
+     *     console.log(`${job.job_name}: ${job.status}`)
+     *   })
+     * }
+     * ```
+     */
+    listJobs(filters?: {
+        status?: string;
+        namespace?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        data: Job[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get details of a specific job (execution)
+     *
+     * @param jobId - Job ID
+     * @returns Promise resolving to { data, error } tuple with job details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.getJob('550e8400-e29b-41d4-a716-446655440000')
+     * if (data) {
+     *   console.log(`Job ${data.job_name}: ${data.status}`)
+     * }
+     * ```
+     */
+    getJob(jobId: string): Promise<{
+        data: Job | null;
+        error: Error | null;
+    }>;
+    /**
+     * Cancel a running or pending job
+     *
+     * @param jobId - Job ID
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.cancel('550e8400-e29b-41d4-a716-446655440000')
+     * ```
+     */
+    cancel(jobId: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Terminate a running job immediately
+     *
+     * @param jobId - Job ID
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.terminate('550e8400-e29b-41d4-a716-446655440000')
+     * ```
+     */
+    terminate(jobId: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Retry a failed job
+     *
+     * @param jobId - Job ID
+     * @returns Promise resolving to { data, error } tuple with new job
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.retry('550e8400-e29b-41d4-a716-446655440000')
+     * ```
+     */
+    retry(jobId: string): Promise<{
+        data: Job | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get job statistics
+     *
+     * @param namespace - Optional namespace filter
+     * @returns Promise resolving to { data, error } tuple with job stats
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.getStats('default')
+     * if (data) {
+     *   console.log(`Pending: ${data.pending}, Running: ${data.running}`)
+     * }
+     * ```
+     */
+    getStats(namespace?: string): Promise<{
+        data: JobStats | null;
+        error: Error | null;
+    }>;
+    /**
+     * List active workers
+     *
+     * @returns Promise resolving to { data, error } tuple with array of workers
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.listWorkers()
+     * if (data) {
+     *   data.forEach(worker => {
+     *     console.log(`Worker ${worker.id}: ${worker.current_jobs} jobs`)
+     *   })
+     * }
+     * ```
+     */
+    listWorkers(): Promise<{
+        data: JobWorker[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Sync multiple job functions to a namespace
+     *
+     * Can sync from:
+     * 1. Filesystem (if no jobs provided) - loads from configured jobs directory
+     * 2. API payload (if jobs array provided) - syncs provided job specifications
+     *
+     * Requires service_role or admin authentication.
+     *
+     * @param options - Sync options including namespace and optional jobs array
+     * @returns Promise resolving to { data, error } tuple with sync results
+     *
+     * @example
+     * ```typescript
+     * // Sync from filesystem
+     * const { data, error } = await client.admin.jobs.sync({ namespace: 'default' })
+     *
+     * // Sync with pre-bundled code (client-side bundling)
+     * const bundled = await FluxbaseAdminJobs.bundleCode({ code: myJobCode })
+     * const { data, error } = await client.admin.jobs.sync({
+     *   namespace: 'default',
+     *   functions: [{
+     *     name: 'my-job',
+     *     code: bundled.code,
+     *     is_pre_bundled: true,
+     *     original_code: myJobCode,
+     *   }],
+     *   options: {
+     *     delete_missing: true, // Remove jobs not in this sync
+     *     dry_run: false,       // Preview changes without applying
+     *   }
+     * })
+     *
+     * if (data) {
+     *   console.log(`Synced: ${data.summary.created} created, ${data.summary.updated} updated`)
+     * }
+     * ```
+     */
+    sync(options: SyncJobsOptions | string): Promise<{
+        data: SyncJobsResult | null;
+        error: Error | null;
+    }>;
+    /**
+     * Sync job functions with automatic client-side bundling
+     *
+     * This is a convenience method that bundles all job code using esbuild
+     * before sending to the server. Requires esbuild as a peer dependency.
+     *
+     * @param options - Sync options including namespace and jobs array
+     * @param bundleOptions - Optional bundling configuration
+     * @returns Promise resolving to { data, error } tuple with sync results
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.jobs.syncWithBundling({
+     *   namespace: 'default',
+     *   functions: [
+     *     { name: 'process-data', code: processDataCode },
+     *     { name: 'send-email', code: sendEmailCode },
+     *   ],
+     *   options: { delete_missing: true }
+     * })
+     * ```
+     */
+    syncWithBundling(options: SyncJobsOptions, bundleOptions?: Partial<BundleOptions>): Promise<{
+        data: SyncJobsResult | null;
+        error: Error | null;
+    }>;
+    /**
+     * Bundle job code using esbuild (client-side)
+     *
+     * Transforms and bundles TypeScript/JavaScript code into a single file
+     * that can be executed by the Fluxbase jobs runtime.
+     *
+     * Requires esbuild as a peer dependency.
+     *
+     * @param options - Bundle options including source code
+     * @returns Promise resolving to bundled code
+     * @throws Error if esbuild is not available
+     *
+     * @example
+     * ```typescript
+     * const bundled = await FluxbaseAdminJobs.bundleCode({
+     *   code: `
+     *     import { helper } from './utils'
+     *     export async function handler(req) {
+     *       return helper(req.payload)
+     *     }
+     *   `,
+     *   minify: true,
+     * })
+     *
+     * // Use bundled code in sync
+     * await client.admin.jobs.sync({
+     *   namespace: 'default',
+     *   functions: [{
+     *     name: 'my-job',
+     *     code: bundled.code,
+     *     is_pre_bundled: true,
+     *   }]
+     * })
+     * ```
+     */
+    static bundleCode(options: BundleOptions): Promise<BundleResult>;
+}
+
+/**
+ * Admin client for managing Fluxbase instance
+ */
+declare class FluxbaseAdmin {
+    private fetch;
+    private adminToken;
+    /**
+     * Settings manager for system and application settings
+     */
+    settings: FluxbaseSettings;
+    /**
+     * DDL manager for database schema and table operations
+     */
+    ddl: DDLManager;
+    /**
+     * OAuth configuration manager for provider and auth settings
+     */
+    oauth: FluxbaseOAuth;
+    /**
+     * Impersonation manager for user impersonation and audit trail
+     */
+    impersonation: ImpersonationManager;
+    /**
+     * Management namespace for API keys, webhooks, and invitations
+     */
+    management: FluxbaseManagement;
+    /**
+     * Email template manager for customizing authentication and notification emails
+     */
+    emailTemplates: EmailTemplateManager;
+    /**
+     * Functions manager for edge function management (create, update, delete, sync)
+     */
+    functions: FluxbaseAdminFunctions;
+    /**
+     * Jobs manager for background job management (create, update, delete, sync, monitoring)
+     */
+    jobs: FluxbaseAdminJobs;
+    /**
+     * Migrations manager for database migration operations (create, apply, rollback, sync)
+     */
+    migrations: FluxbaseAdminMigrations;
     constructor(fetch: FluxbaseFetch);
     /**
      * Set admin authentication token
@@ -4883,6 +6234,8 @@ declare class FluxbaseClient<Database = any, _SchemaName extends string & keyof
     storage: FluxbaseStorage;
     /** Functions module for invoking and managing edge functions */
     functions: FluxbaseFunctions;
+    /** Jobs module for submitting and monitoring background jobs */
+    jobs: FluxbaseJobs;
     /** Admin module for instance management (requires admin authentication) */
     admin: FluxbaseAdmin;
     /** Management module for API keys, webhooks, and invitations */
@@ -5071,4 +6424,4 @@ declare class FluxbaseClient<Database = any, _SchemaName extends string & keyof
  */
 declare function createClient<Database = any, SchemaName extends string & keyof Database = any>(fluxbaseUrl: string, fluxbaseKey: string, options?: FluxbaseClientOptions): FluxbaseClient<Database, SchemaName>;
 
-export { type APIKey, APIKeysManager, type AcceptInvitationRequest, type AcceptInvitationResponse, type AdminAuthResponse, type AdminLoginRequest, type AdminMeResponse, type AdminRefreshRequest, type AdminRefreshResponse, type AdminSetupRequest, type AdminSetupStatusResponse, type AdminUser, type AppSettings, AppSettingsManager, type AuthResponse, type AuthResponseData, type AuthSession, type AuthSettings, AuthSettingsManager, type AuthenticationSettings, type BroadcastCallback, type BroadcastMessage, type Column, type CreateAPIKeyRequest, type CreateAPIKeyResponse, type CreateColumnRequest, type CreateFunctionRequest, type CreateInvitationRequest, type CreateInvitationResponse, type CreateOAuthProviderRequest, type CreateOAuthProviderResponse, type CreateSchemaRequest, type CreateSchemaResponse, type CreateTableRequest, type CreateTableResponse, type CreateWebhookRequest, DDLManager, type DataResponse, type DeleteAPIKeyResponse, type DeleteOAuthProviderResponse, type DeleteTableResponse, type DeleteUserResponse, type DeleteWebhookResponse, type EdgeFunction, type EdgeFunctionExecution, type EmailSettings, type EmailTemplate, EmailTemplateManager, type EmailTemplateType, type EnrichedUser, type FeatureSettings, type FileObject, type FilterOperator, FluxbaseAdmin, FluxbaseAuth, type FluxbaseAuthResponse, FluxbaseClient, type FluxbaseClientOptions, type FluxbaseError, FluxbaseFetch, FluxbaseFunctions, FluxbaseManagement, FluxbaseOAuth, FluxbaseRealtime, type FluxbaseResponse, FluxbaseSettings, FluxbaseStorage, type FunctionInvokeOptions, type GetImpersonationResponse, type HttpMethod, type ImpersonateAnonRequest, type ImpersonateServiceRequest, type ImpersonateUserRequest, ImpersonationManager, type ImpersonationSession, type ImpersonationTargetUser, type ImpersonationType, type Invitation, InvitationsManager, type InviteUserRequest, type InviteUserResponse, type ListAPIKeysResponse, type ListEmailTemplatesResponse, type ListImpersonationSessionsOptions, type ListImpersonationSessionsResponse, type ListInvitationsOptions, type ListInvitationsResponse, type ListOAuthProvidersResponse, type ListOptions, type ListSchemasResponse, type ListSystemSettingsResponse, type ListTablesResponse, type ListUsersOptions, type ListUsersResponse, type ListWebhookDeliveriesResponse, type ListWebhooksResponse, type MailgunSettings, type OAuthProvider, OAuthProviderManager, type OrderBy, type OrderDirection, type PostgresChangesConfig, type PostgrestError, type PostgrestResponse, type PresenceCallback, type PresenceState, QueryBuilder, type QueryFilter, type RealtimeBroadcastPayload, type RealtimeCallback, type RealtimeChangePayload, RealtimeChannel, type RealtimeChannelConfig, type RealtimeMessage, type RealtimePostgresChangesPayload, type RealtimePresencePayload, type RequestOptions, type ResetUserPasswordResponse, type RevokeAPIKeyResponse, type RevokeInvitationResponse, type SESSettings, type SMTPSettings, type Schema, type SecuritySettings, type SendGridSettings, type SessionResponse, SettingsClient, type SignInCredentials, type SignInWith2FAResponse, type SignUpCredentials, type SignedUrlOptions, type StartImpersonationResponse, type StopImpersonationResponse, StorageBucket, type StorageObject, type SupabaseAuthResponse, type SupabaseResponse, type SystemSetting, SystemSettingsManager, type Table, type TestEmailTemplateRequest, type TestWebhookResponse, type TwoFactorEnableResponse, type TwoFactorSetupResponse, type TwoFactorStatusResponse, type TwoFactorVerifyRequest, type UpdateAPIKeyRequest, type UpdateAppSettingsRequest, type UpdateAuthSettingsRequest, type UpdateAuthSettingsResponse, type UpdateEmailTemplateRequest, type UpdateFunctionRequest, type UpdateOAuthProviderRequest, type UpdateOAuthProviderResponse, type UpdateSystemSettingRequest, type UpdateUserAttributes, type UpdateUserRoleRequest, type UpdateWebhookRequest, type UploadOptions, type UploadProgress, type UpsertOptions, type User, type UserResponse, type ValidateInvitationResponse, type VoidResponse, type WeakPassword, type Webhook, type WebhookDelivery, WebhooksManager, createClient };
+export { type APIKey, APIKeysManager, type AcceptInvitationRequest, type AcceptInvitationResponse, type AdminAuthResponse, type AdminLoginRequest, type AdminMeResponse, type AdminRefreshRequest, type AdminRefreshResponse, type AdminSetupRequest, type AdminSetupStatusResponse, type AdminUser, type AppSettings, AppSettingsManager, type ApplyMigrationRequest, type ApplyPendingRequest, type AuthResponse, type AuthResponseData, type AuthSession, type AuthSettings, AuthSettingsManager, type AuthenticationSettings, type BroadcastCallback, type BroadcastMessage, type BundleOptions, type BundleResult, type Column, type CreateAPIKeyRequest, type CreateAPIKeyResponse, type CreateColumnRequest, type CreateFunctionRequest, type CreateInvitationRequest, type CreateInvitationResponse, type CreateMigrationRequest, type CreateOAuthProviderRequest, type CreateOAuthProviderResponse, type CreateSchemaRequest, type CreateSchemaResponse, type CreateTableRequest, type CreateTableResponse, type CreateWebhookRequest, DDLManager, type DataResponse, type DeleteAPIKeyResponse, type DeleteOAuthProviderResponse, type DeleteTableResponse, type DeleteUserResponse, type DeleteWebhookResponse, type EdgeFunction, type EdgeFunctionExecution, type EmailSettings, type EmailTemplate, EmailTemplateManager, type EmailTemplateType, type EnrichedUser, type FeatureSettings, type FileObject, type FilterOperator, FluxbaseAdmin, FluxbaseAdminFunctions, FluxbaseAdminJobs, FluxbaseAdminMigrations, FluxbaseAuth, type FluxbaseAuthResponse, FluxbaseClient, type FluxbaseClientOptions, type FluxbaseError, FluxbaseFetch, FluxbaseFunctions, FluxbaseJobs, FluxbaseManagement, FluxbaseOAuth, FluxbaseRealtime, type FluxbaseResponse, FluxbaseSettings, FluxbaseStorage, type FunctionInvokeOptions, type FunctionSpec, type GetImpersonationResponse, type HttpMethod, type ImpersonateAnonRequest, type ImpersonateServiceRequest, type ImpersonateUserRequest, ImpersonationManager, type ImpersonationSession, type ImpersonationTargetUser, type ImpersonationType, type Invitation, InvitationsManager, type InviteUserRequest, type InviteUserResponse, type ListAPIKeysResponse, type ListEmailTemplatesResponse, type ListImpersonationSessionsOptions, type ListImpersonationSessionsResponse, type ListInvitationsOptions, type ListInvitationsResponse, type ListOAuthProvidersResponse, type ListOptions, type ListSchemasResponse, type ListSystemSettingsResponse, type ListTablesResponse, type ListUsersOptions, type ListUsersResponse, type ListWebhookDeliveriesResponse, type ListWebhooksResponse, type MailgunSettings, type Migration, type MigrationExecution, type OAuthProvider, OAuthProviderManager, type OrderBy, type OrderDirection, type PostgresChangesConfig, type PostgrestError, type PostgrestResponse, type PresenceCallback, type PresenceState, QueryBuilder, type QueryFilter, type RealtimeBroadcastPayload, type RealtimeCallback, type RealtimeChangePayload, RealtimeChannel, type RealtimeChannelConfig, type RealtimeMessage, type RealtimePostgresChangesPayload, type RealtimePresencePayload, type RequestOptions, type ResetUserPasswordResponse, type RevokeAPIKeyResponse, type RevokeInvitationResponse, type RollbackMigrationRequest, type SESSettings, type SMTPSettings, type Schema, type SecuritySettings, type SendGridSettings, type SessionResponse, SettingsClient, type SignInCredentials, type SignInWith2FAResponse, type SignUpCredentials, type SignedUrlOptions, type StartImpersonationResponse, type StopImpersonationResponse, StorageBucket, type StorageObject, type SupabaseAuthResponse, type SupabaseResponse, type SyncError, type SyncFunctionsOptions, type SyncFunctionsResult, type SyncMigrationsOptions, type SyncMigrationsResult, type SystemSetting, SystemSettingsManager, type Table, type TestEmailTemplateRequest, type TestWebhookResponse, type TwoFactorEnableResponse, type TwoFactorSetupResponse, type TwoFactorStatusResponse, type TwoFactorVerifyRequest, type UpdateAPIKeyRequest, type UpdateAppSettingsRequest, type UpdateAuthSettingsRequest, type UpdateAuthSettingsResponse, type UpdateEmailTemplateRequest, type UpdateFunctionRequest, type UpdateMigrationRequest, type UpdateOAuthProviderRequest, type UpdateOAuthProviderResponse, type UpdateSystemSettingRequest, type UpdateUserAttributes, type UpdateUserRoleRequest, type UpdateWebhookRequest, type UploadOptions, type UploadProgress, type UpsertOptions, type User, type UserResponse, type ValidateInvitationResponse, type VoidResponse, type WeakPassword, type Webhook, type WebhookDelivery, WebhooksManager, createClient };