@fluxbase/sdk 0.0.1-rc.46 → 0.0.1-rc.48

package/dist/index.d.cts

@@ -201,7 +201,7 @@ interface SelectOptions {
      */
     head?: boolean;
 }
-type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd' | 'ov' | 'sl' | 'sr' | 'nxr' | 'nxl' | 'adj' | 'not' | 'fts' | 'plfts' | 'wfts' | 'st_intersects' | 'st_contains' | 'st_within' | 'st_dwithin' | 'st_distance' | 'st_touches' | 'st_crosses' | 'st_overlaps';
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'cs' | 'cd' | 'ov' | 'sl' | 'sr' | 'nxr' | 'nxl' | 'adj' | 'not' | 'fts' | 'plfts' | 'wfts' | 'st_intersects' | 'st_contains' | 'st_within' | 'st_dwithin' | 'st_distance' | 'st_touches' | 'st_crosses' | 'st_overlaps' | 'between' | 'not.between';
 interface QueryFilter {
     column: string;
     operator: FilterOperator;
@@ -382,6 +382,23 @@ interface UploadOptions {
     /** Optional callback to track upload progress */
     onUploadProgress?: (progress: UploadProgress) => void;
 }
+/**
+ * Options for streaming uploads (memory-efficient for large files)
+ */
+interface StreamUploadOptions {
+    /** MIME type of the file */
+    contentType?: string;
+    /** Custom metadata to attach to the file */
+    metadata?: Record<string, string>;
+    /** Cache-Control header value */
+    cacheControl?: string;
+    /** If true, overwrite existing file at this path */
+    upsert?: boolean;
+    /** AbortSignal to cancel the upload */
+    signal?: AbortSignal;
+    /** Optional callback to track upload progress */
+    onUploadProgress?: (progress: UploadProgress) => void;
+}
 interface ListOptions {
     prefix?: string;
     limit?: number;
@@ -876,6 +893,9 @@ interface FeatureSettings {
     enable_realtime: boolean;
     enable_storage: boolean;
     enable_functions: boolean;
+    enable_ai: boolean;
+    enable_jobs: boolean;
+    enable_rpc: boolean;
 }
 /**
  * SMTP email provider configuration
@@ -1398,6 +1418,14 @@ interface FunctionSpec {
     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;
+    /** Source directory for resolving relative imports during bundling (used by syncWithBundling) */
+    sourceDir?: string;
+    /** Additional paths to search for node_modules during bundling (used by syncWithBundling) */
+    nodePaths?: string[];
     enabled?: boolean;
     timeout_seconds?: number;
     memory_limit_mb?: number;
@@ -1569,6 +1597,18 @@ interface Job {
     /** Estimated seconds remaining (computed, only for running jobs with progress > 0) */
     estimated_seconds_left?: number;
 }
+/**
+ * User context for submitting jobs on behalf of another user.
+ * Only available when using service_role authentication.
+ */
+interface OnBehalfOf {
+    /** User ID (UUID) to submit the job as */
+    user_id: string;
+    /** Optional email address of the user */
+    user_email?: string;
+    /** Optional role of the user (defaults to "authenticated") */
+    user_role?: string;
+}
 /**
  * Job statistics
  */
@@ -1764,6 +1804,296 @@ interface SyncMigrationsResult {
     /** Warning messages */
     warnings?: string[];
 }
+/**
+ * AI provider type
+ */
+type AIProviderType = 'openai' | 'azure' | 'ollama';
+/**
+ * AI provider configuration
+ */
+interface AIProvider {
+    id: string;
+    name: string;
+    display_name: string;
+    provider_type: AIProviderType;
+    is_default: boolean;
+    enabled: boolean;
+    config?: Record<string, string>;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Request to create an AI provider
+ */
+interface CreateAIProviderRequest {
+    name: string;
+    display_name: string;
+    provider_type: AIProviderType;
+    is_default?: boolean;
+    enabled?: boolean;
+    config: Record<string, string>;
+}
+/**
+ * Request to update an AI provider
+ */
+interface UpdateAIProviderRequest {
+    display_name?: string;
+    config?: Record<string, string>;
+    enabled?: boolean;
+}
+/**
+ * AI chatbot summary (list view)
+ */
+interface AIChatbotSummary {
+    id: string;
+    name: string;
+    namespace: string;
+    description?: string;
+    enabled: boolean;
+    is_public: boolean;
+    allowed_tables: string[];
+    allowed_operations: string[];
+    allowed_schemas: string[];
+    version: number;
+    source: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * AI chatbot full details
+ */
+interface AIChatbot extends AIChatbotSummary {
+    code: string;
+    original_code?: string;
+    max_tokens: number;
+    temperature: number;
+    provider_id?: string;
+    persist_conversations: boolean;
+    conversation_ttl_hours: number;
+    max_conversation_turns: number;
+    rate_limit_per_minute: number;
+    daily_request_limit: number;
+    daily_token_budget: number;
+    allow_unauthenticated: boolean;
+}
+/**
+ * Chatbot specification for sync operations
+ */
+interface ChatbotSpec {
+    name: string;
+    description?: string;
+    code: string;
+    original_code?: string;
+    is_pre_bundled?: boolean;
+    enabled?: boolean;
+    allowed_tables?: string[];
+    allowed_operations?: string[];
+    allowed_schemas?: string[];
+    max_tokens?: number;
+    temperature?: number;
+    persist_conversations?: boolean;
+    conversation_ttl_hours?: number;
+    max_conversation_turns?: number;
+    rate_limit_per_minute?: number;
+    daily_request_limit?: number;
+    daily_token_budget?: number;
+    allow_unauthenticated?: boolean;
+    is_public?: boolean;
+}
+/**
+ * Options for syncing chatbots
+ */
+interface SyncChatbotsOptions {
+    namespace?: string;
+    chatbots?: ChatbotSpec[];
+    options?: {
+        delete_missing?: boolean;
+        dry_run?: boolean;
+    };
+}
+/**
+ * Result of a chatbot sync operation
+ */
+interface SyncChatbotsResult {
+    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;
+}
+/**
+ * AI chat message role
+ */
+type AIChatMessageRole = 'user' | 'assistant' | 'system' | 'tool';
+/**
+ * AI chat message for WebSocket
+ */
+interface AIChatClientMessage {
+    type: 'start_chat' | 'message' | 'cancel';
+    chatbot?: string;
+    namespace?: string;
+    conversation_id?: string;
+    content?: string;
+    impersonate_user_id?: string;
+}
+/**
+ * AI chat server message
+ */
+interface AIChatServerMessage {
+    type: 'chat_started' | 'progress' | 'content' | 'query_result' | 'done' | 'error' | 'cancelled';
+    conversation_id?: string;
+    message_id?: string;
+    chatbot?: string;
+    step?: string;
+    message?: string;
+    delta?: string;
+    query?: string;
+    summary?: string;
+    row_count?: number;
+    data?: Record<string, any>[];
+    usage?: AIUsageStats;
+    error?: string;
+    code?: string;
+}
+/**
+ * AI token usage statistics
+ */
+interface AIUsageStats {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens?: number;
+}
+/**
+ * AI conversation summary
+ */
+interface AIConversation {
+    id: string;
+    chatbot_id: string;
+    user_id?: string;
+    session_id?: string;
+    title?: string;
+    status: 'active' | 'archived';
+    turn_count: number;
+    total_prompt_tokens: number;
+    total_completion_tokens: number;
+    created_at: string;
+    updated_at: string;
+    last_message_at: string;
+    expires_at?: string;
+}
+/**
+ * AI conversation message
+ */
+interface AIConversationMessage {
+    id: string;
+    conversation_id: string;
+    role: AIChatMessageRole;
+    content: string;
+    tool_call_id?: string;
+    tool_name?: string;
+    executed_sql?: string;
+    sql_result_summary?: string;
+    sql_row_count?: number;
+    sql_error?: string;
+    sql_duration_ms?: number;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    created_at: string;
+    sequence_number: number;
+}
+/**
+ * User's conversation summary (list view)
+ */
+interface AIUserConversationSummary {
+    id: string;
+    chatbot: string;
+    namespace: string;
+    title?: string;
+    preview: string;
+    message_count: number;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Query result data in a user message
+ */
+interface AIUserQueryResult {
+    query?: string;
+    summary: string;
+    row_count: number;
+    data?: Record<string, unknown>[];
+}
+/**
+ * Token usage stats in a user message
+ */
+interface AIUserUsageStats {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens?: number;
+}
+/**
+ * User's message in conversation detail view
+ */
+interface AIUserMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp: string;
+    query_results?: AIUserQueryResult[];
+    usage?: AIUserUsageStats;
+}
+/**
+ * User's conversation detail with messages
+ */
+interface AIUserConversationDetail {
+    id: string;
+    chatbot: string;
+    namespace: string;
+    title?: string;
+    created_at: string;
+    updated_at: string;
+    messages: AIUserMessage[];
+}
+/**
+ * Options for listing user conversations
+ */
+interface ListConversationsOptions {
+    /** Filter by chatbot name */
+    chatbot?: string;
+    /** Filter by namespace */
+    namespace?: string;
+    /** Number of conversations to return (default: 50, max: 100) */
+    limit?: number;
+    /** Offset for pagination */
+    offset?: number;
+}
+/**
+ * Result of listing user conversations
+ */
+interface ListConversationsResult {
+    conversations: AIUserConversationSummary[];
+    total: number;
+    has_more: boolean;
+}
+/**
+ * Options for updating a conversation
+ */
+interface UpdateConversationOptions {
+    /** New title for the conversation */
+    title: string;
+}
 /**
  * Base Fluxbase response type (Supabase-compatible)
  * Returns either `{ data, error: null }` on success or `{ data: null, error }` on failure
@@ -1815,6 +2145,151 @@ type SessionResponse = FluxbaseResponse<{
  * Generic data response
  */
 type DataResponse<T> = FluxbaseResponse<T>;
+/**
+ * RPC procedure summary for listings
+ */
+interface RPCProcedureSummary {
+    id: string;
+    name: string;
+    namespace: string;
+    description?: string;
+    allowed_tables: string[];
+    allowed_schemas: string[];
+    max_execution_time_seconds: number;
+    require_role?: string;
+    is_public: boolean;
+    enabled: boolean;
+    version: number;
+    source: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Full RPC procedure details
+ */
+interface RPCProcedure extends RPCProcedureSummary {
+    sql_query: string;
+    original_code?: string;
+    input_schema?: Record<string, string>;
+    output_schema?: Record<string, string>;
+    created_by?: string;
+}
+/**
+ * RPC execution status
+ */
+type RPCExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timeout';
+/**
+ * RPC execution record
+ */
+interface RPCExecution {
+    id: string;
+    procedure_id?: string;
+    procedure_name: string;
+    namespace: string;
+    status: RPCExecutionStatus;
+    input_params?: Record<string, unknown>;
+    result?: unknown;
+    error_message?: string;
+    rows_returned?: number;
+    duration_ms?: number;
+    user_id?: string;
+    user_role?: string;
+    user_email?: string;
+    is_async: boolean;
+    created_at: string;
+    started_at?: string;
+    completed_at?: string;
+}
+/**
+ * RPC invocation response
+ */
+interface RPCInvokeResponse<T = unknown> {
+    execution_id: string;
+    status: RPCExecutionStatus;
+    result?: T;
+    rows_returned?: number;
+    duration_ms?: number;
+    error?: string;
+}
+/**
+ * RPC execution log entry
+ */
+interface RPCExecutionLog {
+    id: number;
+    execution_id: string;
+    line_number: number;
+    level: string;
+    message: string;
+    created_at: string;
+}
+/**
+ * RPC procedure specification for sync operations
+ */
+interface RPCProcedureSpec {
+    name: string;
+    code: string;
+    description?: string;
+    enabled?: boolean;
+}
+/**
+ * Options for syncing RPC procedures
+ */
+interface SyncRPCOptions {
+    namespace?: string;
+    procedures?: RPCProcedureSpec[];
+    options?: {
+        delete_missing?: boolean;
+        dry_run?: boolean;
+    };
+}
+/**
+ * Result of RPC sync operation
+ */
+interface SyncRPCResult {
+    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: Array<{
+        procedure: string;
+        error: string;
+    }>;
+    dry_run: boolean;
+}
+/**
+ * Options for updating an RPC procedure
+ */
+interface UpdateRPCProcedureRequest {
+    description?: string;
+    enabled?: boolean;
+    is_public?: boolean;
+    require_role?: string;
+    max_execution_time_seconds?: number;
+    allowed_tables?: string[];
+    allowed_schemas?: string[];
+}
+/**
+ * Filters for listing RPC executions
+ */
+interface RPCExecutionFilters {
+    namespace?: string;
+    procedure?: string;
+    status?: RPCExecutionStatus;
+    user_id?: string;
+    limit?: number;
+    offset?: number;
+}
 /**
  * @deprecated Use FluxbaseResponse instead
  */
@@ -2555,8 +3030,73 @@ declare class StorageBucket {
      */
     private uploadWithProgress;
     /**
-     * Download a file from the bucket
-     * @param path - The path/key of the file
+     * Upload a file using streaming for reduced memory usage.
+     * This method bypasses FormData buffering and streams data directly to the server.
+     * Ideal for large files where memory efficiency is important.
+     *
+     * @param path - The path/key for the file
+     * @param stream - ReadableStream of the file data
+     * @param size - The size of the file in bytes (required for Content-Length header)
+     * @param options - Upload options
+     *
+     * @example
+     * ```typescript
+     * // Upload from a File's stream
+     * const file = new File([...], 'large-video.mp4');
+     * const { data, error } = await storage
+     *   .from('videos')
+     *   .uploadStream('video.mp4', file.stream(), file.size, {
+     *     contentType: 'video/mp4',
+     *   });
+     *
+     * // Upload from a fetch response stream
+     * const response = await fetch('https://example.com/data.zip');
+     * const size = parseInt(response.headers.get('content-length') || '0');
+     * const { data, error } = await storage
+     *   .from('files')
+     *   .uploadStream('data.zip', response.body!, size, {
+     *     contentType: 'application/zip',
+     *   });
+     * ```
+     */
+    uploadStream(path: string, stream: ReadableStream<Uint8Array>, size: number, options?: StreamUploadOptions): Promise<{
+        data: {
+            id: string;
+            path: string;
+            fullPath: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Upload a large file using streaming for reduced memory usage.
+     * This is a convenience method that converts a File or Blob to a stream.
+     *
+     * @param path - The path/key for the file
+     * @param file - The File or Blob to upload
+     * @param options - Upload options
+     *
+     * @example
+     * ```typescript
+     * const file = new File([...], 'large-video.mp4');
+     * const { data, error } = await storage
+     *   .from('videos')
+     *   .uploadLargeFile('video.mp4', file, {
+     *     contentType: 'video/mp4',
+     *     onUploadProgress: (p) => console.log(`${p.percentage}% complete`),
+     *   });
+     * ```
+     */
+    uploadLargeFile(path: string, file: File | Blob, options?: StreamUploadOptions): Promise<{
+        data: {
+            id: string;
+            path: string;
+            fullPath: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Download a file from the bucket
+     * @param path - The path/key of the file
      *
      * @example
      * ```typescript
@@ -2917,7 +3457,7 @@ declare class FluxbaseJobs {
      *
      * @param jobName - Name of the job function to execute
      * @param payload - Job input data
-     * @param options - Additional options (priority, namespace, scheduled time)
+     * @param options - Additional options (priority, namespace, scheduled time, onBehalfOf)
      * @returns Promise resolving to { data, error } tuple with submitted job details
      *
      * @example
@@ -2943,12 +3483,26 @@ declare class FluxbaseJobs {
      * const { data } = await client.jobs.submit('scheduled-task', payload, {
      *   scheduled: '2025-01-01T00:00:00Z'
      * })
+     *
+     * // Submit on behalf of a user (service_role only)
+     * const { data } = await serviceClient.jobs.submit('user-task', payload, {
+     *   onBehalfOf: {
+     *     user_id: 'user-uuid',
+     *     user_email: 'user@example.com'
+     *   }
+     * })
      * ```
      */
     submit(jobName: string, payload?: any, options?: {
         priority?: number;
         namespace?: string;
         scheduled?: string;
+        /**
+         * Submit job on behalf of another user (service_role only).
+         * The job will be created with the specified user's identity,
+         * allowing them to see the job and its logs via RLS.
+         */
+        onBehalfOf?: OnBehalfOf;
     }): Promise<{
         data: Job | null;
         error: Error | null;
@@ -4875,6 +5429,121 @@ declare class FluxbaseManagement {
     constructor(fetch: FluxbaseFetch);
 }
 
+/**
+ * esbuild plugin that marks Deno-specific imports as external
+ * Use this when bundling functions/jobs with esbuild to handle npm:, https://, and jsr: imports
+ *
+ * @example
+ * ```typescript
+ * import { denoExternalPlugin } from '@fluxbase/sdk'
+ * import * as esbuild from 'esbuild'
+ *
+ * const result = await esbuild.build({
+ *   entryPoints: ['./my-function.ts'],
+ *   bundle: true,
+ *   plugins: [denoExternalPlugin],
+ *   // ... other options
+ * })
+ * ```
+ */
+declare const denoExternalPlugin: {
+    name: string;
+    setup(build: {
+        onResolve: (opts: {
+            filter: RegExp;
+        }, cb: (args: {
+            path: string;
+        }) => {
+            path: string;
+            external: boolean;
+        }) => void;
+    }): void;
+};
+/**
+ * Load import map from a deno.json file
+ *
+ * @param denoJsonPath - Path to deno.json file
+ * @returns Import map object or null if not found
+ *
+ * @example
+ * ```typescript
+ * const importMap = await loadImportMap('./deno.json')
+ * const bundled = await bundleCode({
+ *   code: myCode,
+ *   importMap,
+ * })
+ * ```
+ */
+declare function loadImportMap(denoJsonPath: string): Promise<Record<string, string> | null>;
+/**
+ * Options for bundling 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;
+    /** Import map from deno.json (maps aliases to npm: or file paths) */
+    importMap?: Record<string, string>;
+    /** Base directory for resolving relative imports (resolveDir in esbuild) */
+    baseDir?: string;
+    /** Additional paths to search for node_modules (useful when importing from parent directories) */
+    nodePaths?: string[];
+    /** Custom define values for esbuild (e.g., { 'process.env.NODE_ENV': '"production"' }) */
+    define?: Record<string, string>;
+}
+/**
+ * Result of bundling code
+ */
+interface BundleResult {
+    /** Bundled code */
+    code: string;
+    /** Source map (if enabled) */
+    sourceMap?: string;
+}
+/**
+ * Bundle code using esbuild (client-side)
+ *
+ * Transforms and bundles TypeScript/JavaScript code into a single file
+ * that can be executed by the Fluxbase Deno 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
+ * import { bundleCode } from '@fluxbase/sdk'
+ *
+ * const bundled = await bundleCode({
+ *   code: `
+ *     import { helper } from './utils'
+ *     export default async function handler(req) {
+ *       return helper(req.payload)
+ *     }
+ *   `,
+ *   minify: true,
+ * })
+ *
+ * // Use bundled code in sync
+ * await client.admin.functions.sync({
+ *   namespace: 'default',
+ *   functions: [{
+ *     name: 'my-function',
+ *     code: bundled.code,
+ *     is_pre_bundled: true,
+ *   }]
+ * })
+ * ```
+ */
+declare function bundleCode(options: BundleOptions): Promise<BundleResult>;
+
 /**
  * Admin Functions module for managing edge functions
  * Provides administrative operations for function lifecycle management
@@ -5071,6 +5740,68 @@ declare class FluxbaseAdminFunctions {
         data: SyncFunctionsResult | null;
         error: Error | null;
     }>;
+    /**
+     * Sync edge functions with automatic client-side bundling
+     *
+     * This is a convenience method that bundles all function code using esbuild
+     * before sending to the server. Requires esbuild as a peer dependency.
+     *
+     * @param options - Sync options including namespace and functions array
+     * @param bundleOptions - Optional bundling configuration
+     * @returns Promise resolving to { data, error } tuple with sync results
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.functions.syncWithBundling({
+     *   namespace: 'default',
+     *   functions: [
+     *     { name: 'hello', code: helloCode },
+     *     { name: 'goodbye', code: goodbyeCode },
+     *   ],
+     *   options: { delete_missing: true }
+     * })
+     * ```
+     */
+    syncWithBundling(options: SyncFunctionsOptions, bundleOptions?: Partial<BundleOptions>): Promise<{
+        data: SyncFunctionsResult | null;
+        error: Error | null;
+    }>;
+    /**
+     * Bundle function code using esbuild (client-side)
+     *
+     * Transforms and bundles TypeScript/JavaScript code into a single file
+     * that can be executed by the Fluxbase edge functions 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 FluxbaseAdminFunctions.bundleCode({
+     *   code: `
+     *     import { helper } from './utils'
+     *     export default async function handler(req) {
+     *       return helper(req.body)
+     *     }
+     *   `,
+     *   minify: true,
+     * })
+     *
+     * // Use bundled code in sync
+     * await client.admin.functions.sync({
+     *   namespace: 'default',
+     *   functions: [{
+     *     name: 'my-function',
+     *     code: bundled.code,
+     *     is_pre_bundled: true,
+     *   }]
+     * })
+     * ```
+     */
+    static bundleCode(options: BundleOptions): Promise<BundleResult>;
 }
 
 /**
@@ -5359,36 +6090,6 @@ declare class FluxbaseAdminMigrations {
  * 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;
-    /** Import map from deno.json (maps aliases to npm: or file paths) */
-    importMap?: Record<string, string>;
-    /** Base directory for resolving relative imports (resolveDir in esbuild) */
-    baseDir?: string;
-    /** Additional paths to search for node_modules (useful when importing from parent directories) */
-    nodePaths?: string[];
-    /** Custom define values for esbuild (e.g., { 'process.env.NODE_ENV': '"production"' }) */
-    define?: Record<string, string>;
-}
-/**
- * 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
@@ -5745,90 +6446,573 @@ declare class FluxbaseAdminJobs {
 }
 
 /**
- * Admin client for managing Fluxbase instance
+ * Admin AI module for managing AI chatbots and providers
+ * Provides administrative operations for chatbot lifecycle management
  */
-declare class FluxbaseAdmin {
+
+/**
+ * Admin AI manager for managing AI chatbots and providers
+ * Provides create, update, delete, sync, and monitoring operations
+ *
+ * @category Admin
+ */
+declare class FluxbaseAdminAI {
     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
-     */
-    setToken(token: string): void;
-    /**
-     * Get current admin token
-     */
-    getToken(): string | null;
-    /**
-     * Clear admin token
-     */
-    clearToken(): void;
-    /**
-     * Check if initial admin setup is needed
+     * List all chatbots (admin view)
      *
-     * @returns Setup status indicating if initial setup is required
+     * @param namespace - Optional namespace filter
+     * @returns Promise resolving to { data, error } tuple with array of chatbot summaries
      *
      * @example
      * ```typescript
-     * const status = await admin.getSetupStatus();
-     * if (status.needs_setup) {
-     *   console.log('Initial setup required');
+     * const { data, error } = await client.admin.ai.listChatbots()
+     * if (data) {
+     *   console.log('Chatbots:', data.map(c => c.name))
      * }
      * ```
      */
-    getSetupStatus(): Promise<DataResponse<AdminSetupStatusResponse>>;
+    listChatbots(namespace?: string): Promise<{
+        data: AIChatbotSummary[] | null;
+        error: Error | null;
+    }>;
     /**
-     * Perform initial admin setup
-     *
-     * Creates the first admin user and completes initial setup.
-     * This endpoint can only be called once.
+     * Get details of a specific chatbot
      *
-     * @param request - Setup request containing email, password, and name
-     * @returns Authentication response with tokens
+     * @param id - Chatbot ID
+     * @returns Promise resolving to { data, error } tuple with chatbot details
      *
      * @example
      * ```typescript
-     * const response = await admin.setup({
-     *   email: 'admin@example.com',
-     *   password: 'SecurePassword123!',
-     *   name: 'Admin User'
-     * });
+     * const { data, error } = await client.admin.ai.getChatbot('uuid')
+     * if (data) {
+     *   console.log('Chatbot:', data.name)
+     * }
+     * ```
+     */
+    getChatbot(id: string): Promise<{
+        data: AIChatbot | null;
+        error: Error | null;
+    }>;
+    /**
+     * Enable or disable a chatbot
+     *
+     * @param id - Chatbot ID
+     * @param enabled - Whether to enable or disable
+     * @returns Promise resolving to { data, error } tuple with updated chatbot
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.toggleChatbot('uuid', true)
+     * ```
+     */
+    toggleChatbot(id: string, enabled: boolean): Promise<{
+        data: AIChatbot | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a chatbot
+     *
+     * @param id - Chatbot ID
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.deleteChatbot('uuid')
+     * ```
+     */
+    deleteChatbot(id: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Sync chatbots from filesystem or API payload
+     *
+     * Can sync from:
+     * 1. Filesystem (if no chatbots provided) - loads from configured chatbots directory
+     * 2. API payload (if chatbots array provided) - syncs provided chatbot specifications
+     *
+     * Requires service_role or admin authentication.
+     *
+     * @param options - Sync options including namespace and optional chatbots array
+     * @returns Promise resolving to { data, error } tuple with sync results
+     *
+     * @example
+     * ```typescript
+     * // Sync from filesystem
+     * const { data, error } = await client.admin.ai.sync()
+     *
+     * // Sync with provided chatbot code
+     * const { data, error } = await client.admin.ai.sync({
+     *   namespace: 'default',
+     *   chatbots: [{
+     *     name: 'sql-assistant',
+     *     code: myChatbotCode,
+     *   }],
+     *   options: {
+     *     delete_missing: false, // Don't remove chatbots 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?: SyncChatbotsOptions): Promise<{
+        data: SyncChatbotsResult | null;
+        error: Error | null;
+    }>;
+    /**
+     * List all AI providers
+     *
+     * @returns Promise resolving to { data, error } tuple with array of providers
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.listProviders()
+     * if (data) {
+     *   console.log('Providers:', data.map(p => p.name))
+     * }
+     * ```
+     */
+    listProviders(): Promise<{
+        data: AIProvider[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get details of a specific provider
+     *
+     * @param id - Provider ID
+     * @returns Promise resolving to { data, error } tuple with provider details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.getProvider('uuid')
+     * if (data) {
+     *   console.log('Provider:', data.display_name)
+     * }
+     * ```
+     */
+    getProvider(id: string): Promise<{
+        data: AIProvider | null;
+        error: Error | null;
+    }>;
+    /**
+     * Create a new AI provider
+     *
+     * @param request - Provider configuration
+     * @returns Promise resolving to { data, error } tuple with created provider
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.createProvider({
+     *   name: 'openai-main',
+     *   display_name: 'OpenAI (Main)',
+     *   provider_type: 'openai',
+     *   is_default: true,
+     *   config: {
+     *     api_key: 'sk-...',
+     *     model: 'gpt-4-turbo',
+     *   }
+     * })
+     * ```
+     */
+    createProvider(request: CreateAIProviderRequest): Promise<{
+        data: AIProvider | null;
+        error: Error | null;
+    }>;
+    /**
+     * Update an existing AI provider
+     *
+     * @param id - Provider ID
+     * @param updates - Fields to update
+     * @returns Promise resolving to { data, error } tuple with updated provider
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.updateProvider('uuid', {
+     *   display_name: 'Updated Name',
+     *   config: {
+     *     api_key: 'new-key',
+     *     model: 'gpt-4-turbo',
+     *   },
+     *   enabled: true,
+     * })
+     * ```
+     */
+    updateProvider(id: string, updates: UpdateAIProviderRequest): Promise<{
+        data: AIProvider | null;
+        error: Error | null;
+    }>;
+    /**
+     * Set a provider as the default
+     *
+     * @param id - Provider ID
+     * @returns Promise resolving to { data, error } tuple with updated provider
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.setDefaultProvider('uuid')
+     * ```
+     */
+    setDefaultProvider(id: string): Promise<{
+        data: AIProvider | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a provider
+     *
+     * @param id - Provider ID
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.deleteProvider('uuid')
+     * ```
+     */
+    deleteProvider(id: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+}
+
+/**
+ * Admin RPC module for managing RPC procedures
+ * Provides administrative operations for RPC procedure lifecycle management
+ */
+
+/**
+ * Admin RPC manager for managing RPC procedures
+ * Provides sync, CRUD, and execution monitoring operations
+ *
+ * @category Admin
+ */
+declare class FluxbaseAdminRPC {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Sync RPC procedures from filesystem or API payload
+     *
+     * Can sync from:
+     * 1. Filesystem (if no procedures provided) - loads from configured procedures directory
+     * 2. API payload (if procedures array provided) - syncs provided procedure specifications
+     *
+     * Requires service_role or admin authentication.
+     *
+     * @param options - Sync options including namespace and optional procedures array
+     * @returns Promise resolving to { data, error } tuple with sync results
+     *
+     * @example
+     * ```typescript
+     * // Sync from filesystem
+     * const { data, error } = await client.admin.rpc.sync()
+     *
+     * // Sync with provided procedure code
+     * const { data, error } = await client.admin.rpc.sync({
+     *   namespace: 'default',
+     *   procedures: [{
+     *     name: 'get-user-orders',
+     *     code: myProcedureSQL,
+     *   }],
+     *   options: {
+     *     delete_missing: false, // Don't remove procedures 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?: SyncRPCOptions): Promise<{
+        data: SyncRPCResult | null;
+        error: Error | null;
+    }>;
+    /**
+     * List all RPC procedures (admin view)
+     *
+     * @param namespace - Optional namespace filter
+     * @returns Promise resolving to { data, error } tuple with array of procedure summaries
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.list()
+     * if (data) {
+     *   console.log('Procedures:', data.map(p => p.name))
+     * }
+     * ```
+     */
+    list(namespace?: string): Promise<{
+        data: RPCProcedureSummary[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * List all namespaces
+     *
+     * @returns Promise resolving to { data, error } tuple with array of namespace names
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.listNamespaces()
+     * if (data) {
+     *   console.log('Namespaces:', data)
+     * }
+     * ```
+     */
+    listNamespaces(): Promise<{
+        data: string[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get details of a specific RPC procedure
+     *
+     * @param namespace - Procedure namespace
+     * @param name - Procedure name
+     * @returns Promise resolving to { data, error } tuple with procedure details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.get('default', 'get-user-orders')
+     * if (data) {
+     *   console.log('Procedure:', data.name)
+     *   console.log('SQL:', data.sql_query)
+     * }
+     * ```
+     */
+    get(namespace: string, name: string): Promise<{
+        data: RPCProcedure | null;
+        error: Error | null;
+    }>;
+    /**
+     * Update an RPC procedure
+     *
+     * @param namespace - Procedure namespace
+     * @param name - Procedure name
+     * @param updates - Fields to update
+     * @returns Promise resolving to { data, error } tuple with updated procedure
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.update('default', 'get-user-orders', {
+     *   enabled: false,
+     *   max_execution_time_seconds: 60,
+     * })
+     * ```
+     */
+    update(namespace: string, name: string, updates: UpdateRPCProcedureRequest): Promise<{
+        data: RPCProcedure | null;
+        error: Error | null;
+    }>;
+    /**
+     * Enable or disable an RPC procedure
+     *
+     * @param namespace - Procedure namespace
+     * @param name - Procedure name
+     * @param enabled - Whether to enable or disable
+     * @returns Promise resolving to { data, error } tuple with updated procedure
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.toggle('default', 'get-user-orders', true)
+     * ```
+     */
+    toggle(namespace: string, name: string, enabled: boolean): Promise<{
+        data: RPCProcedure | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete an RPC procedure
+     *
+     * @param namespace - Procedure namespace
+     * @param name - Procedure name
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.delete('default', 'get-user-orders')
+     * ```
+     */
+    delete(namespace: string, name: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * List RPC executions with optional filters
+     *
+     * @param filters - Optional filters for namespace, procedure, status, user
+     * @returns Promise resolving to { data, error } tuple with array of executions
+     *
+     * @example
+     * ```typescript
+     * // List all executions
+     * const { data, error } = await client.admin.rpc.listExecutions()
+     *
+     * // List failed executions for a specific procedure
+     * const { data, error } = await client.admin.rpc.listExecutions({
+     *   namespace: 'default',
+     *   procedure: 'get-user-orders',
+     *   status: 'failed',
+     * })
+     * ```
+     */
+    listExecutions(filters?: RPCExecutionFilters): Promise<{
+        data: RPCExecution[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get details of a specific execution
+     *
+     * @param executionId - Execution ID
+     * @returns Promise resolving to { data, error } tuple with execution details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.getExecution('execution-uuid')
+     * if (data) {
+     *   console.log('Status:', data.status)
+     *   console.log('Duration:', data.duration_ms, 'ms')
+     * }
+     * ```
+     */
+    getExecution(executionId: string): Promise<{
+        data: RPCExecution | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get execution logs for a specific execution
+     *
+     * @param executionId - Execution ID
+     * @param afterLine - Optional line number to get logs after (for polling)
+     * @returns Promise resolving to { data, error } tuple with execution logs
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.getExecutionLogs('execution-uuid')
+     * if (data) {
+     *   for (const log of data) {
+     *     console.log(`[${log.level}] ${log.message}`)
+     *   }
+     * }
+     * ```
+     */
+    getExecutionLogs(executionId: string, afterLine?: number): Promise<{
+        data: RPCExecutionLog[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Cancel a running execution
+     *
+     * @param executionId - Execution ID
+     * @returns Promise resolving to { data, error } tuple with updated execution
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.rpc.cancelExecution('execution-uuid')
+     * ```
+     */
+    cancelExecution(executionId: string): Promise<{
+        data: RPCExecution | null;
+        error: Error | null;
+    }>;
+}
+
+/**
+ * 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;
+    /**
+     * AI manager for chatbot and provider management (create, update, delete, sync)
+     */
+    ai: FluxbaseAdminAI;
+    /**
+     * RPC manager for procedure management (create, update, delete, sync, execution monitoring)
+     */
+    rpc: FluxbaseAdminRPC;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Set admin authentication token
+     */
+    setToken(token: string): void;
+    /**
+     * Get current admin token
+     */
+    getToken(): string | null;
+    /**
+     * Clear admin token
+     */
+    clearToken(): void;
+    /**
+     * Check if initial admin setup is needed
+     *
+     * @returns Setup status indicating if initial setup is required
+     *
+     * @example
+     * ```typescript
+     * const status = await admin.getSetupStatus();
+     * if (status.needs_setup) {
+     *   console.log('Initial setup required');
+     * }
+     * ```
+     */
+    getSetupStatus(): Promise<DataResponse<AdminSetupStatusResponse>>;
+    /**
+     * Perform initial admin setup
+     *
+     * Creates the first admin user and completes initial setup.
+     * This endpoint can only be called once.
+     *
+     * @param request - Setup request containing email, password, and name
+     * @returns Authentication response with tokens
+     *
+     * @example
+     * ```typescript
+     * const response = await admin.setup({
+     *   email: 'admin@example.com',
+     *   password: 'SecurePassword123!',
+     *   name: 'Admin User'
+     * });
      *
      * // Store tokens
      * localStorage.setItem('admin_token', response.access_token);
@@ -6012,6 +7196,280 @@ declare class FluxbaseAdmin {
     resetUserPassword(userId: string, type?: "app" | "dashboard"): Promise<DataResponse<ResetUserPasswordResponse>>;
 }
 
+/**
+ * AI Chat module for interacting with AI chatbots
+ * Provides WebSocket-based chat functionality with streaming support
+ */
+
+/**
+ * Event types for chat callbacks
+ */
+type AIChatEventType = "connected" | "chat_started" | "progress" | "content" | "query_result" | "done" | "error" | "cancelled" | "disconnected";
+/**
+ * Chat event data
+ */
+interface AIChatEvent {
+    type: AIChatEventType;
+    conversationId?: string;
+    chatbot?: string;
+    step?: string;
+    message?: string;
+    delta?: string;
+    query?: string;
+    summary?: string;
+    rowCount?: number;
+    data?: Record<string, any>[];
+    usage?: AIUsageStats;
+    error?: string;
+    code?: string;
+}
+/**
+ * Chat connection options
+ */
+interface AIChatOptions {
+    /** WebSocket URL (defaults to ws://host/ai/ws) */
+    wsUrl?: string;
+    /** JWT token for authentication */
+    token?: string;
+    /** Callback for all events */
+    onEvent?: (event: AIChatEvent) => void;
+    /** Callback for content chunks (streaming) */
+    onContent?: (delta: string, conversationId: string) => void;
+    /** Callback for progress updates */
+    onProgress?: (step: string, message: string, conversationId: string) => void;
+    /** Callback for query results */
+    onQueryResult?: (query: string, summary: string, rowCount: number, data: Record<string, any>[], conversationId: string) => void;
+    /** Callback when message is complete */
+    onDone?: (usage: AIUsageStats | undefined, conversationId: string) => void;
+    /** Callback for errors */
+    onError?: (error: string, code: string | undefined, conversationId: string | undefined) => void;
+    /** Reconnect attempts (0 = no reconnect) */
+    reconnectAttempts?: number;
+    /** Reconnect delay in ms */
+    reconnectDelay?: number;
+}
+/**
+ * AI Chat client for WebSocket-based chat with AI chatbots
+ *
+ * @example
+ * ```typescript
+ * const chat = new FluxbaseAIChat({
+ *   wsUrl: 'ws://localhost:8080/ai/ws',
+ *   token: 'my-jwt-token',
+ *   onContent: (delta, convId) => {
+ *     process.stdout.write(delta)
+ *   },
+ *   onProgress: (step, message) => {
+ *     console.log(`[${step}] ${message}`)
+ *   },
+ *   onQueryResult: (query, summary, rowCount, data) => {
+ *     console.log(`Query: ${query}`)
+ *     console.log(`Result: ${summary} (${rowCount} rows)`)
+ *   },
+ *   onDone: (usage) => {
+ *     console.log(`\nTokens: ${usage?.total_tokens}`)
+ *   },
+ *   onError: (error, code) => {
+ *     console.error(`Error: ${error} (${code})`)
+ *   },
+ * })
+ *
+ * await chat.connect()
+ * const convId = await chat.startChat('sql-assistant')
+ * await chat.sendMessage(convId, 'Show me the top 10 users by order count')
+ * ```
+ */
+declare class FluxbaseAIChat {
+    private ws;
+    private options;
+    private reconnectCount;
+    private pendingStartResolve;
+    private pendingStartReject;
+    private accumulatedContent;
+    constructor(options: AIChatOptions);
+    /**
+     * Connect to the AI chat WebSocket
+     *
+     * @returns Promise that resolves when connected
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the AI chat WebSocket
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Start a new chat session with a chatbot
+     *
+     * @param chatbot - Chatbot name
+     * @param namespace - Optional namespace (defaults to 'default')
+     * @param conversationId - Optional conversation ID to resume
+     * @param impersonateUserId - Optional user ID to impersonate (admin only)
+     * @returns Promise resolving to conversation ID
+     */
+    startChat(chatbot: string, namespace?: string, conversationId?: string, impersonateUserId?: string): Promise<string>;
+    /**
+     * Send a message in a conversation
+     *
+     * @param conversationId - Conversation ID
+     * @param content - Message content
+     */
+    sendMessage(conversationId: string, content: string): void;
+    /**
+     * Cancel an ongoing message generation
+     *
+     * @param conversationId - Conversation ID
+     */
+    cancel(conversationId: string): void;
+    /**
+     * Get the full accumulated response content for a conversation
+     *
+     * @param conversationId - Conversation ID
+     * @returns Accumulated content string
+     */
+    getAccumulatedContent(conversationId: string): string;
+    private buildWsUrl;
+    private handleMessage;
+    private serverMessageToEvent;
+    private emitEvent;
+    private handleClose;
+}
+/**
+ * Fluxbase AI client for listing chatbots and managing conversations
+ *
+ * @example
+ * ```typescript
+ * const ai = new FluxbaseAI(fetchClient, 'ws://localhost:8080')
+ *
+ * // List available chatbots
+ * const { data, error } = await ai.listChatbots()
+ *
+ * // Create a chat connection
+ * const chat = ai.createChat({
+ *   token: 'my-jwt-token',
+ *   onContent: (delta) => process.stdout.write(delta),
+ * })
+ *
+ * await chat.connect()
+ * const convId = await chat.startChat('sql-assistant')
+ * chat.sendMessage(convId, 'Show me recent orders')
+ * ```
+ */
+declare class FluxbaseAI {
+    private fetch;
+    private wsBaseUrl;
+    constructor(fetch: {
+        get: <T>(path: string) => Promise<T>;
+        patch: <T>(path: string, body?: unknown) => Promise<T>;
+        delete: (path: string) => Promise<void>;
+    }, wsBaseUrl: string);
+    /**
+     * List available chatbots (public, enabled)
+     *
+     * @returns Promise resolving to { data, error } tuple with array of chatbot summaries
+     */
+    listChatbots(): Promise<{
+        data: AIChatbotSummary[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get details of a specific chatbot
+     *
+     * @param id - Chatbot ID
+     * @returns Promise resolving to { data, error } tuple with chatbot details
+     */
+    getChatbot(id: string): Promise<{
+        data: AIChatbotSummary | null;
+        error: Error | null;
+    }>;
+    /**
+     * Create a new AI chat connection
+     *
+     * @param options - Chat connection options
+     * @returns FluxbaseAIChat instance
+     */
+    createChat(options: Omit<AIChatOptions, "wsUrl">): FluxbaseAIChat;
+    /**
+     * List the authenticated user's conversations
+     *
+     * @param options - Optional filters and pagination
+     * @returns Promise resolving to { data, error } tuple with conversations
+     *
+     * @example
+     * ```typescript
+     * // List all conversations
+     * const { data, error } = await ai.listConversations()
+     *
+     * // Filter by chatbot
+     * const { data, error } = await ai.listConversations({ chatbot: 'sql-assistant' })
+     *
+     * // With pagination
+     * const { data, error } = await ai.listConversations({ limit: 20, offset: 0 })
+     * ```
+     */
+    listConversations(options?: ListConversationsOptions): Promise<{
+        data: ListConversationsResult | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get a single conversation with all messages
+     *
+     * @param id - Conversation ID
+     * @returns Promise resolving to { data, error } tuple with conversation detail
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await ai.getConversation('conv-uuid-123')
+     * if (data) {
+     *   console.log(`Title: ${data.title}`)
+     *   console.log(`Messages: ${data.messages.length}`)
+     * }
+     * ```
+     */
+    getConversation(id: string): Promise<{
+        data: AIUserConversationDetail | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a conversation
+     *
+     * @param id - Conversation ID
+     * @returns Promise resolving to { error } (null on success)
+     *
+     * @example
+     * ```typescript
+     * const { error } = await ai.deleteConversation('conv-uuid-123')
+     * if (!error) {
+     *   console.log('Conversation deleted')
+     * }
+     * ```
+     */
+    deleteConversation(id: string): Promise<{
+        error: Error | null;
+    }>;
+    /**
+     * Update a conversation (currently supports title update only)
+     *
+     * @param id - Conversation ID
+     * @param updates - Fields to update
+     * @returns Promise resolving to { data, error } tuple with updated conversation
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await ai.updateConversation('conv-uuid-123', {
+     *   title: 'My custom conversation title'
+     * })
+     * ```
+     */
+    updateConversation(id: string, updates: UpdateConversationOptions): Promise<{
+        data: AIUserConversationDetail | null;
+        error: Error | null;
+    }>;
+}
+
 /**
  * PostgreSQL query builder for Fluxbase SDK
  * Inspired by Supabase's PostgREST client
@@ -6025,6 +7483,7 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
     private filters;
     private orFilters;
     private andFilters;
+    private betweenFilters;
     private orderBys;
     private limitValue?;
     private offsetValue?;
@@ -6145,6 +7604,8 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
      * Generic filter method using PostgREST syntax (Supabase-compatible)
      * @example filter('name', 'in', '("Han","Yoda")')
      * @example filter('age', 'gte', '18')
+     * @example filter('recorded_at', 'between', ['2024-01-01', '2024-01-10'])
+     * @example filter('recorded_at', 'not.between', ['2024-01-01', '2024-01-10'])
      */
     filter(column: string, operator: FilterOperator, value: unknown): this;
     /**
@@ -6158,6 +7619,29 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
      * @example overlaps('tags', '["news","sports"]')
      */
     overlaps(column: string, value: unknown): this;
+    /**
+     * Filter column value within an inclusive range (BETWEEN)
+     * Generates: AND (column >= min AND column <= max)
+     *
+     * @param column - Column name to filter
+     * @param min - Minimum value (inclusive)
+     * @param max - Maximum value (inclusive)
+     * @example between('recorded_at', '2024-01-01', '2024-01-10')
+     * @example between('price', 10, 100)
+     */
+    between(column: string, min: unknown, max: unknown): this;
+    /**
+     * Filter column value outside an inclusive range (NOT BETWEEN)
+     * Generates: OR (column < min OR column > max)
+     * Multiple notBetween calls on the same column AND together
+     *
+     * @param column - Column name to filter
+     * @param min - Minimum value of excluded range
+     * @param max - Maximum value of excluded range
+     * @example notBetween('recorded_at', '2024-01-01', '2024-01-10')
+     * @example notBetween('price', 0, 10) // Excludes items priced 0-10
+     */
+    notBetween(column: string, min: unknown, max: unknown): this;
     /**
      * Check if geometries intersect (PostGIS ST_Intersects)
      * @param column - Column containing geometry/geography data
@@ -6490,6 +7974,11 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
      * Format a value for the query string
      */
     private formatValue;
+    /**
+     * Validate between filter value - must be array of exactly 2 elements
+     * @throws Error if value is invalid
+     */
+    private validateBetweenValue;
     /**
      * Parse the Content-Range header to extract the total count
      * Header format: "0-999/50000" or "* /50000" (when no rows returned)
@@ -6549,6 +8038,8 @@ declare class FluxbaseClient<Database = any, _SchemaName extends string & keyof
     management: FluxbaseManagement;
     /** Settings module for reading public application settings (respects RLS policies) */
     settings: SettingsClient;
+    /** AI module for chatbots and conversation history */
+    ai: FluxbaseAI;
     /**
      * Create a new Fluxbase client instance
      *
@@ -6620,31 +8111,6 @@ declare class FluxbaseClient<Database = any, _SchemaName extends string & keyof
      * @category Database
      */
     schema(schemaName: string): SchemaQueryBuilder;
-    /**
-     * Call a PostgreSQL function (Remote Procedure Call)
-     *
-     * @param functionName - The name of the PostgreSQL function to call
-     * @param params - Optional parameters to pass to the function
-     * @returns Promise containing the function result or error
-     *
-     * @example
-     * ```typescript
-     * // Call a function without parameters
-     * const { data, error } = await client.rpc('get_total_users')
-     *
-     * // Call a function with parameters
-     * const { data, error } = await client.rpc('calculate_discount', {
-     *   product_id: 123,
-     *   coupon_code: 'SAVE20'
-     * })
-     * ```
-     *
-     * @category Database
-     */
-    rpc<T = any>(functionName: string, params?: Record<string, unknown>): Promise<{
-        data: T | null;
-        error: Error | null;
-    }>;
     /**
      * Sync auth state with realtime connections
      * @internal
@@ -6773,4 +8239,156 @@ 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 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 DownloadOptions, type DownloadProgress, 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 ResumableDownloadData, type ResumableDownloadOptions, type RevokeAPIKeyResponse, type RevokeInvitationResponse, type RollbackMigrationRequest, type SESSettings, type SMTPSettings, type Schema, SchemaQueryBuilder, type SecuritySettings, type SendGridSettings, type SessionResponse, SettingsClient, type SignInCredentials, type SignInWith2FAResponse, type SignUpCredentials, type SignedUrlOptions, type StartImpersonationResponse, type StopImpersonationResponse, StorageBucket, type StorageObject, type StreamDownloadData, 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 };
+/**
+ * RPC (Remote Procedure Call) module for invoking SQL-based procedures
+ */
+
+/**
+ * Options for invoking an RPC procedure
+ */
+interface RPCInvokeOptions {
+    /** Namespace of the procedure (defaults to 'default') */
+    namespace?: string;
+    /** Execute asynchronously (returns execution ID immediately) */
+    async?: boolean;
+}
+/**
+ * Fetch interface for RPC operations
+ */
+interface RPCFetch {
+    get: <T>(path: string) => Promise<T>;
+    post: <T>(path: string, body?: unknown) => Promise<T>;
+}
+/**
+ * FluxbaseRPC provides methods for invoking RPC procedures
+ *
+ * @example
+ * ```typescript
+ * // Invoke a procedure synchronously
+ * const { data, error } = await fluxbase.rpc.invoke('get-user-orders', {
+ *   user_id: '123',
+ *   limit: 10
+ * });
+ *
+ * // Invoke asynchronously
+ * const { data: asyncResult } = await fluxbase.rpc.invoke('long-running-report', {
+ *   start_date: '2024-01-01'
+ * }, { async: true });
+ *
+ * // Poll for status
+ * const { data: status } = await fluxbase.rpc.getStatus(asyncResult.execution_id);
+ * ```
+ */
+declare class FluxbaseRPC {
+    private fetch;
+    constructor(fetch: RPCFetch);
+    /**
+     * List available RPC procedures (public, enabled)
+     *
+     * @param namespace - Optional namespace filter
+     * @returns Promise resolving to { data, error } tuple with array of procedure summaries
+     */
+    list(namespace?: string): Promise<{
+        data: RPCProcedureSummary[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Invoke an RPC procedure
+     *
+     * @param name - Procedure name
+     * @param params - Optional parameters to pass to the procedure
+     * @param options - Optional invocation options
+     * @returns Promise resolving to { data, error } tuple with invocation response
+     *
+     * @example
+     * ```typescript
+     * // Synchronous invocation
+     * const { data, error } = await fluxbase.rpc.invoke('get-user-orders', {
+     *   user_id: '123',
+     *   limit: 10
+     * });
+     * console.log(data.result); // Query results
+     *
+     * // Asynchronous invocation
+     * const { data: asyncData } = await fluxbase.rpc.invoke('generate-report', {
+     *   year: 2024
+     * }, { async: true });
+     * console.log(asyncData.execution_id); // Use to poll status
+     * ```
+     */
+    invoke<T = unknown>(name: string, params?: Record<string, unknown>, options?: RPCInvokeOptions): Promise<{
+        data: RPCInvokeResponse<T> | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get execution status (for async invocations or checking history)
+     *
+     * @param executionId - The execution ID returned from async invoke
+     * @returns Promise resolving to { data, error } tuple with execution details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await fluxbase.rpc.getStatus('execution-uuid');
+     * if (data.status === 'completed') {
+     *   console.log('Result:', data.result);
+     * } else if (data.status === 'running') {
+     *   console.log('Still running...');
+     * }
+     * ```
+     */
+    getStatus(executionId: string): Promise<{
+        data: RPCExecution | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get execution logs (for debugging and monitoring)
+     *
+     * @param executionId - The execution ID
+     * @param afterLine - Optional line number to get logs after (for polling)
+     * @returns Promise resolving to { data, error } tuple with execution logs
+     *
+     * @example
+     * ```typescript
+     * const { data: logs } = await fluxbase.rpc.getLogs('execution-uuid');
+     * for (const log of logs) {
+     *   console.log(`[${log.level}] ${log.message}`);
+     * }
+     * ```
+     */
+    getLogs(executionId: string, afterLine?: number): Promise<{
+        data: RPCExecutionLog[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Poll for execution completion with exponential backoff
+     *
+     * @param executionId - The execution ID to poll
+     * @param options - Polling options
+     * @returns Promise resolving to final execution state
+     *
+     * @example
+     * ```typescript
+     * const { data: result } = await fluxbase.rpc.invoke('long-task', {}, { async: true });
+     * const { data: final } = await fluxbase.rpc.waitForCompletion(result.execution_id, {
+     *   maxWaitMs: 60000, // Wait up to 1 minute
+     *   onProgress: (exec) => console.log(`Status: ${exec.status}`)
+     * });
+     * console.log('Final result:', final.result);
+     * ```
+     */
+    waitForCompletion(executionId: string, options?: {
+        /** Maximum time to wait in milliseconds (default: 30000) */
+        maxWaitMs?: number;
+        /** Initial polling interval in milliseconds (default: 500) */
+        initialIntervalMs?: number;
+        /** Maximum polling interval in milliseconds (default: 5000) */
+        maxIntervalMs?: number;
+        /** Callback for progress updates */
+        onProgress?: (execution: RPCExecution) => void;
+    }): Promise<{
+        data: RPCExecution | null;
+        error: Error | null;
+    }>;
+}
+
+export { type AIChatClientMessage, type AIChatEvent, type AIChatEventType, type AIChatMessageRole, type AIChatOptions, type AIChatServerMessage, type AIChatbot, type AIChatbotSummary, type AIConversation, type AIConversationMessage, type AIProvider, type AIProviderType, type AIUsageStats, type AIUserConversationDetail, type AIUserConversationSummary, type AIUserMessage, type AIUserQueryResult, type AIUserUsageStats, 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 ChatbotSpec, type Column, type CreateAIProviderRequest, 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 DownloadOptions, type DownloadProgress, type EdgeFunction, type EdgeFunctionExecution, type EmailSettings, type EmailTemplate, EmailTemplateManager, type EmailTemplateType, type EnrichedUser, type FeatureSettings, type FileObject, type FilterOperator, FluxbaseAI, FluxbaseAIChat, FluxbaseAdmin, FluxbaseAdminAI, FluxbaseAdminFunctions, FluxbaseAdminJobs, FluxbaseAdminMigrations, FluxbaseAdminRPC, FluxbaseAuth, type FluxbaseAuthResponse, FluxbaseClient, type FluxbaseClientOptions, type FluxbaseError, FluxbaseFetch, FluxbaseFunctions, FluxbaseJobs, FluxbaseManagement, FluxbaseOAuth, FluxbaseRPC, 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 ListConversationsOptions, type ListConversationsResult, 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 RPCExecution, type RPCExecutionFilters, type RPCExecutionLog, type RPCExecutionStatus, type RPCInvokeResponse, type RPCProcedure, type RPCProcedureSpec, type RPCProcedureSummary, type RealtimeBroadcastPayload, type RealtimeCallback, type RealtimeChangePayload, RealtimeChannel, type RealtimeChannelConfig, type RealtimeMessage, type RealtimePostgresChangesPayload, type RealtimePresencePayload, type RequestOptions, type ResetUserPasswordResponse, type ResumableDownloadData, type ResumableDownloadOptions, type RevokeAPIKeyResponse, type RevokeInvitationResponse, type RollbackMigrationRequest, type SESSettings, type SMTPSettings, type Schema, SchemaQueryBuilder, type SecuritySettings, type SendGridSettings, type SessionResponse, SettingsClient, type SignInCredentials, type SignInWith2FAResponse, type SignUpCredentials, type SignedUrlOptions, type StartImpersonationResponse, type StopImpersonationResponse, StorageBucket, type StorageObject, type StreamDownloadData, type StreamUploadOptions, type SupabaseAuthResponse, type SupabaseResponse, type SyncChatbotsOptions, type SyncChatbotsResult, type SyncError, type SyncFunctionsOptions, type SyncFunctionsResult, type SyncMigrationsOptions, type SyncMigrationsResult, type SyncRPCOptions, type SyncRPCResult, type SystemSetting, SystemSettingsManager, type Table, type TestEmailTemplateRequest, type TestWebhookResponse, type TwoFactorEnableResponse, type TwoFactorSetupResponse, type TwoFactorStatusResponse, type TwoFactorVerifyRequest, type UpdateAIProviderRequest, type UpdateAPIKeyRequest, type UpdateAppSettingsRequest, type UpdateAuthSettingsRequest, type UpdateAuthSettingsResponse, type UpdateConversationOptions, type UpdateEmailTemplateRequest, type UpdateFunctionRequest, type UpdateMigrationRequest, type UpdateOAuthProviderRequest, type UpdateOAuthProviderResponse, type UpdateRPCProcedureRequest, 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, bundleCode, createClient, denoExternalPlugin, loadImportMap };