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

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' | 'between' | 'not.between';
+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' | 'vec_l2' | 'vec_cos' | 'vec_ip';
 interface QueryFilter {
     column: string;
     operator: FilterOperator;
@@ -212,6 +212,10 @@ interface OrderBy {
     column: string;
     direction: OrderDirection;
     nulls?: 'first' | 'last';
+    /** Vector operator for similarity ordering (vec_l2, vec_cos, vec_ip) */
+    vectorOp?: 'vec_l2' | 'vec_cos' | 'vec_ip';
+    /** Vector value for similarity ordering */
+    vectorValue?: number[];
 }
 /**
  * Options for upsert operations (Supabase-compatible)
@@ -476,6 +480,81 @@ interface ResumableDownloadData {
     /** File size in bytes from HEAD request, or null if unknown */
     size: number | null;
 }
+/** Options for resumable chunked uploads */
+interface ResumableUploadOptions {
+    /**
+     * Chunk size in bytes for each upload request.
+     * @default 5242880 (5MB)
+     */
+    chunkSize?: number;
+    /**
+     * Number of retry attempts per chunk on failure.
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Base delay in milliseconds for exponential backoff.
+     * @default 1000
+     */
+    retryDelayMs?: number;
+    /**
+     * Timeout in milliseconds per chunk request.
+     * @default 60000 (1 minute)
+     */
+    chunkTimeout?: number;
+    /** AbortSignal to cancel the upload */
+    signal?: AbortSignal;
+    /** Callback for upload progress */
+    onProgress?: (progress: ResumableUploadProgress) => void;
+    /** MIME type of the file */
+    contentType?: string;
+    /** Custom metadata to attach to the file */
+    metadata?: Record<string, string>;
+    /** Cache-Control header value */
+    cacheControl?: string;
+    /** Existing upload session ID to resume (optional) */
+    resumeSessionId?: string;
+}
+/** Upload progress information for resumable uploads */
+interface ResumableUploadProgress {
+    /** Number of bytes uploaded so far */
+    loaded: number;
+    /** Total file size in bytes */
+    total: number;
+    /** Upload percentage (0-100) */
+    percentage: number;
+    /** Current chunk being uploaded (1-indexed) */
+    currentChunk: number;
+    /** Total number of chunks */
+    totalChunks: number;
+    /** Transfer rate in bytes per second */
+    bytesPerSecond: number;
+    /** Upload session ID (for resume capability) */
+    sessionId: string;
+}
+/** Chunked upload session information */
+interface ChunkedUploadSession {
+    /** Unique session identifier for resume */
+    sessionId: string;
+    /** Target bucket */
+    bucket: string;
+    /** Target file path */
+    path: string;
+    /** Total file size */
+    totalSize: number;
+    /** Chunk size used */
+    chunkSize: number;
+    /** Total number of chunks */
+    totalChunks: number;
+    /** Array of completed chunk indices (0-indexed) */
+    completedChunks: number[];
+    /** Session status */
+    status: 'active' | 'completing' | 'completed' | 'aborted' | 'expired';
+    /** Session expiration time */
+    expiresAt: string;
+    /** Session creation time */
+    createdAt: string;
+}
 interface ShareFileOptions {
     userId: string;
     permission: 'read' | 'write';
@@ -831,6 +910,13 @@ interface ListInvitationsResponse {
 interface RevokeInvitationResponse {
     message: string;
 }
+/**
+ * Override information for a setting controlled by environment variable
+ */
+interface SettingOverride {
+    is_overridden: boolean;
+    env_var: string;
+}
 /**
  * System setting with key-value storage
  */
@@ -839,6 +925,10 @@ interface SystemSetting {
     key: string;
     value: Record<string, unknown>;
     description?: string;
+    /** True if this setting is overridden by an environment variable */
+    is_overridden?: boolean;
+    /** The environment variable name if overridden */
+    override_source?: string;
     created_at: string;
     updated_at: string;
 }
@@ -949,6 +1039,15 @@ interface EmailSettings {
 interface SecuritySettings {
     enable_global_rate_limit: boolean;
 }
+/**
+ * Indicates which settings are overridden by environment variables (read-only)
+ */
+interface SettingOverrides {
+    authentication?: Record<string, boolean>;
+    features?: Record<string, boolean>;
+    email?: Record<string, boolean>;
+    security?: Record<string, boolean>;
+}
 /**
  * Complete application settings structure
  */
@@ -957,6 +1056,8 @@ interface AppSettings {
     features: FeatureSettings;
     email: EmailSettings;
     security: SecuritySettings;
+    /** Settings overridden by environment variables (read-only, cannot be modified via API) */
+    overrides?: SettingOverrides;
 }
 /**
  * Request to update application settings
@@ -1105,6 +1206,8 @@ interface AuthSettings {
     password_require_special: boolean;
     session_timeout_minutes: number;
     max_sessions_per_user: number;
+    /** Settings overridden by environment variables (read-only, cannot be modified via API) */
+    _overrides?: Record<string, SettingOverride>;
 }
 /**
  * Request to update authentication settings
@@ -1818,7 +1921,11 @@ interface AIProvider {
     provider_type: AIProviderType;
     is_default: boolean;
     enabled: boolean;
-    config?: Record<string, string>;
+    config: Record<string, string>;
+    /** True if provider was configured via environment variables or fluxbase.yaml */
+    from_config?: boolean;
+    /** @deprecated Use from_config instead */
+    read_only?: boolean;
     created_at: string;
     updated_at: string;
 }
@@ -2094,6 +2201,229 @@ interface UpdateConversationOptions {
     /** New title for the conversation */
     title: string;
 }
+/**
+ * Knowledge base summary
+ */
+interface KnowledgeBaseSummary {
+    id: string;
+    name: string;
+    namespace: string;
+    description: string;
+    enabled: boolean;
+    document_count: number;
+    total_chunks: number;
+    embedding_model: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Knowledge base full details
+ */
+interface KnowledgeBase extends KnowledgeBaseSummary {
+    embedding_dimensions: number;
+    chunk_size: number;
+    chunk_overlap: number;
+    chunk_strategy: string;
+    source: string;
+    created_by?: string;
+}
+/**
+ * Request to create a knowledge base
+ */
+interface CreateKnowledgeBaseRequest {
+    name: string;
+    namespace?: string;
+    description?: string;
+    embedding_model?: string;
+    embedding_dimensions?: number;
+    chunk_size?: number;
+    chunk_overlap?: number;
+    chunk_strategy?: string;
+}
+/**
+ * Request to update a knowledge base
+ */
+interface UpdateKnowledgeBaseRequest {
+    name?: string;
+    description?: string;
+    embedding_model?: string;
+    embedding_dimensions?: number;
+    chunk_size?: number;
+    chunk_overlap?: number;
+    chunk_strategy?: string;
+    enabled?: boolean;
+}
+/**
+ * Document status
+ */
+type DocumentStatus = 'pending' | 'processing' | 'indexed' | 'failed';
+/**
+ * Document in a knowledge base
+ */
+interface KnowledgeBaseDocument {
+    id: string;
+    knowledge_base_id: string;
+    title: string;
+    source_url?: string;
+    source_type?: string;
+    mime_type: string;
+    content_hash: string;
+    chunk_count: number;
+    status: DocumentStatus;
+    error_message?: string;
+    metadata?: Record<string, string>;
+    tags?: string[];
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Request to add a document
+ */
+interface AddDocumentRequest {
+    title?: string;
+    content: string;
+    source?: string;
+    mime_type?: string;
+    metadata?: Record<string, string>;
+}
+/**
+ * Response after adding a document
+ */
+interface AddDocumentResponse {
+    document_id: string;
+    status: string;
+    message: string;
+}
+/**
+ * Response after uploading a document file
+ */
+interface UploadDocumentResponse {
+    document_id: string;
+    status: string;
+    message: string;
+    filename: string;
+    extracted_length: number;
+    mime_type: string;
+}
+/**
+ * Chatbot-knowledge base link
+ */
+interface ChatbotKnowledgeBaseLink {
+    id: string;
+    chatbot_id: string;
+    knowledge_base_id: string;
+    enabled: boolean;
+    max_chunks: number;
+    similarity_threshold: number;
+    priority: number;
+    created_at: string;
+}
+/**
+ * Request to link a knowledge base to a chatbot
+ */
+interface LinkKnowledgeBaseRequest {
+    knowledge_base_id: string;
+    priority?: number;
+    max_chunks?: number;
+    similarity_threshold?: number;
+}
+/**
+ * Request to update a chatbot-knowledge base link
+ */
+interface UpdateChatbotKnowledgeBaseRequest {
+    priority?: number;
+    max_chunks?: number;
+    similarity_threshold?: number;
+    enabled?: boolean;
+}
+/**
+ * Search result from knowledge base
+ */
+interface KnowledgeBaseSearchResult {
+    chunk_id: string;
+    document_id: string;
+    document_title: string;
+    knowledge_base_name?: string;
+    content: string;
+    similarity: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Response from knowledge base search
+ */
+interface SearchKnowledgeBaseResponse {
+    results: KnowledgeBaseSearchResult[];
+    count: number;
+    query: string;
+}
+/**
+ * System health status response
+ */
+interface HealthResponse {
+    status: string;
+    services: {
+        database: boolean;
+        realtime: boolean;
+    };
+    timestamp: string;
+}
+/**
+ * Storage bucket information (admin API)
+ */
+interface AdminBucket {
+    id: string;
+    name: string;
+    public: boolean;
+    allowed_mime_types: string[] | null;
+    max_file_size: number | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Response from listing buckets (admin API)
+ */
+interface AdminListBucketsResponse {
+    buckets: AdminBucket[];
+}
+/**
+ * Storage object information (admin API)
+ */
+interface AdminStorageObject {
+    id: string;
+    bucket: string;
+    path: string;
+    mime_type: string;
+    size: number;
+    metadata: Record<string, unknown> | null;
+    owner_id: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Response from listing objects (admin API)
+ */
+interface AdminListObjectsResponse {
+    bucket: string;
+    objects: AdminStorageObject[] | null;
+    prefixes: string[];
+    truncated: boolean;
+}
+/**
+ * Response from generating a signed URL
+ */
+interface SignedUrlResponse {
+    url: string;
+    expires_in: number;
+}
+/**
+ * Request to send an email
+ */
+interface SendEmailRequest {
+    to: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+}
 /**
  * Base Fluxbase response type (Supabase-compatible)
  * Returns either `{ data, error: null }` on success or `{ data: null, error }` on failure
@@ -2212,16 +2542,29 @@ interface RPCInvokeResponse<T = unknown> {
     error?: string;
 }
 /**
- * RPC execution log entry
+ * Execution log entry (shared by jobs, RPC, and functions)
  */
-interface RPCExecutionLog {
+interface ExecutionLog {
+    /** Unique log entry ID */
     id: number;
+    /** ID of the execution (job ID, RPC execution ID, or function execution ID) */
     execution_id: string;
+    /** Line number within the execution log */
     line_number: number;
+    /** Log level (debug, info, warn, error) */
     level: string;
+    /** Log message content */
     message: string;
-    created_at: string;
+    /** Timestamp of the log entry */
+    timestamp: string;
+    /** Additional structured fields */
+    fields?: Record<string, unknown>;
 }
+/**
+ * RPC execution log entry
+ * @deprecated Use ExecutionLog instead
+ */
+type RPCExecutionLog = ExecutionLog;
 /**
  * RPC procedure specification for sync operations
  */
@@ -2290,6 +2633,123 @@ interface RPCExecutionFilters {
     limit?: number;
     offset?: number;
 }
+/**
+ * Vector distance metric for similarity search
+ * - l2: Euclidean distance (L2 norm) - lower is more similar
+ * - cosine: Cosine distance - lower is more similar (1 - cosine similarity)
+ * - inner_product: Negative inner product - lower is more similar
+ */
+type VectorMetric = 'l2' | 'cosine' | 'inner_product';
+/**
+ * Options for vector similarity ordering
+ */
+interface VectorOrderOptions {
+    /** The vector to compare against */
+    vector: number[];
+    /** Distance metric to use */
+    metric?: VectorMetric;
+}
+/**
+ * Request for vector embedding generation
+ */
+interface EmbedRequest {
+    /** Text to embed (single) */
+    text?: string;
+    /** Multiple texts to embed */
+    texts?: string[];
+    /** Embedding model to use (defaults to configured model) */
+    model?: string;
+}
+/**
+ * Response from vector embedding generation
+ */
+interface EmbedResponse {
+    /** Generated embeddings (one per input text) */
+    embeddings: number[][];
+    /** Model used for embedding */
+    model: string;
+    /** Dimensions of the embeddings */
+    dimensions: number;
+    /** Token usage information */
+    usage?: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+}
+/**
+ * Options for vector search via the convenience endpoint
+ */
+interface VectorSearchOptions {
+    /** Table to search in */
+    table: string;
+    /** Vector column to search */
+    column: string;
+    /** Text query to search for (will be auto-embedded) */
+    query?: string;
+    /** Direct vector input (alternative to text query) */
+    vector?: number[];
+    /** Distance metric to use */
+    metric?: VectorMetric;
+    /** Minimum similarity threshold (0-1 for cosine, varies for others) */
+    match_threshold?: number;
+    /** Maximum number of results */
+    match_count?: number;
+    /** Columns to select (default: all) */
+    select?: string;
+    /** Additional filters to apply */
+    filters?: QueryFilter[];
+}
+/**
+ * Result from vector search
+ */
+interface VectorSearchResult<T = Record<string, unknown>> {
+    /** Matched records */
+    data: T[];
+    /** Distance scores for each result */
+    distances: number[];
+    /** Embedding model used (if query text was embedded) */
+    model?: string;
+}
+/**
+ * Log level for execution logs
+ */
+type ExecutionLogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Execution type for log subscriptions
+ */
+type ExecutionType = 'function' | 'job' | 'rpc';
+/**
+ * Execution log event received from realtime subscription
+ */
+interface ExecutionLogEvent {
+    /** Unique execution ID */
+    execution_id: string;
+    /** Type of execution */
+    execution_type: ExecutionType;
+    /** Line number in the execution log */
+    line_number: number;
+    /** Log level */
+    level: ExecutionLogLevel;
+    /** Log message content */
+    message: string;
+    /** Timestamp of the log entry */
+    timestamp: string;
+    /** Additional fields */
+    fields?: Record<string, unknown>;
+}
+/**
+ * Callback for execution log events
+ */
+type ExecutionLogCallback = (log: ExecutionLogEvent) => void;
+/**
+ * Configuration for execution log subscription
+ */
+interface ExecutionLogConfig {
+    /** Execution ID to subscribe to */
+    execution_id: string;
+    /** Type of execution (function, job, rpc) */
+    type?: ExecutionType;
+}
 /**
  * @deprecated Use FluxbaseResponse instead
  */
@@ -2311,8 +2771,10 @@ declare class RealtimeChannel {
     private callbacks;
     private presenceCallbacks;
     private broadcastCallbacks;
+    private executionLogCallbacks;
     private subscriptionConfig;
     private subscriptionId;
+    private executionLogConfig;
     private _presenceState;
     private myPresenceKey;
     private config;
@@ -2403,6 +2865,25 @@ declare class RealtimeChannel {
     on(event: "presence", config: {
         event: "sync" | "join" | "leave";
     }, callback: PresenceCallback): this;
+    /**
+     * Listen to execution log events
+     *
+     * @param event - 'execution_log'
+     * @param config - Configuration with execution_id and optional type
+     * @param callback - Function to call when log entries are received
+     * @returns This channel for chaining
+     *
+     * @example
+     * ```typescript
+     * channel.on('execution_log', { execution_id: 'abc123', type: 'function' }, (log) => {
+     *   console.log(`[${log.level}] ${log.message}`)
+     * })
+     * ```
+     */
+    on(event: "execution_log", config: {
+        execution_id: string;
+        type?: ExecutionType;
+    }, callback: ExecutionLogCallback): this;
     /**
      * Remove a callback
      */
@@ -2497,6 +2978,10 @@ declare class RealtimeChannel {
      * Internal: Handle incoming message
      */
     private handleMessage;
+    /**
+     * Internal: Handle execution log message
+     */
+    private handleExecutionLog;
     /**
      * Internal: Handle broadcast message
      */
@@ -2584,6 +3069,74 @@ declare class FluxbaseRealtime {
      * @param token - The new auth token
      */
     setAuth(token: string | null): void;
+    /**
+     * Create an execution log subscription channel
+     *
+     * This provides a cleaner API for subscribing to execution logs
+     * (functions, jobs, or RPC procedures).
+     *
+     * @param executionId - The execution ID to subscribe to
+     * @param type - The type of execution ('function', 'job', 'rpc')
+     * @returns ExecutionLogsChannel instance with fluent API
+     *
+     * @example
+     * ```typescript
+     * const channel = client.realtime.executionLogs('exec-123', 'function')
+     *   .onLog((log) => {
+     *     console.log(`[${log.level}] ${log.message}`)
+     *   })
+     *   .subscribe()
+     * ```
+     */
+    executionLogs(executionId: string, type?: ExecutionType): ExecutionLogsChannel;
+}
+/**
+ * Specialized channel for execution log subscriptions
+ * Provides a cleaner API than the generic RealtimeChannel
+ */
+declare class ExecutionLogsChannel {
+    private channel;
+    private executionId;
+    private executionType;
+    private logCallbacks;
+    constructor(url: string, executionId: string, type: ExecutionType, token: string | null, tokenRefreshCallback: (() => Promise<string | null>) | null);
+    /**
+     * Register a callback for log events
+     *
+     * @param callback - Function to call when log entries are received
+     * @returns This channel for chaining
+     *
+     * @example
+     * ```typescript
+     * channel.onLog((log) => {
+     *   console.log(`[${log.level}] Line ${log.line_number}: ${log.message}`)
+     * })
+     * ```
+     */
+    onLog(callback: ExecutionLogCallback): this;
+    /**
+     * Subscribe to execution logs
+     *
+     * @param callback - Optional status callback
+     * @returns Promise that resolves when subscribed
+     *
+     * @example
+     * ```typescript
+     * await channel.subscribe()
+     * ```
+     */
+    subscribe(callback?: (status: "SUBSCRIBED" | "CHANNEL_ERROR" | "TIMED_OUT" | "CLOSED", err?: Error) => void): this;
+    /**
+     * Unsubscribe from execution logs
+     *
+     * @returns Promise resolving to status
+     *
+     * @example
+     * ```typescript
+     * await channel.unsubscribe()
+     * ```
+     */
+    unsubscribe(): Promise<"ok" | "timed out" | "error">;
 }
 
 /**
@@ -2663,6 +3216,10 @@ declare class FluxbaseFetch {
      * GET request that returns response with headers (for count queries)
      */
     getWithHeaders<T = unknown>(path: string, options?: Omit<FetchOptions, 'method'>): Promise<FetchResponseWithHeaders<T>>;
+    /**
+     * POST request that returns response with headers (for POST-based queries with count)
+     */
+    postWithHeaders<T = unknown>(path: string, body?: unknown, options?: Omit<FetchOptions, 'method' | 'body'>): Promise<FetchResponseWithHeaders<T>>;
     /**
      * Make an HTTP request and return response with headers
      */
@@ -2691,6 +3248,10 @@ declare class FluxbaseFetch {
      * HEAD request
      */
     head(path: string, options?: Omit<FetchOptions, 'method'>): Promise<Headers>;
+    /**
+     * GET request that returns response as Blob (for file downloads)
+     */
+    getBlob(path: string, options?: Omit<FetchOptions, 'method'>): Promise<Blob>;
 }
 
 /**
@@ -3161,13 +3722,66 @@ declare class StorageBucket {
         error: Error | null;
     }>;
     /**
-     * List files in the bucket
-     * Supports both Supabase-style list(path, options) and Fluxbase-style list(options)
-     * @param pathOrOptions - The folder path or list options
-     * @param maybeOptions - List options when first param is a path
-     */
-    list(pathOrOptions?: string | ListOptions, maybeOptions?: ListOptions): Promise<{
-        data: FileObject[] | null;
+     * Upload a large file with resumable chunked uploads.
+     *
+     * Features:
+     * - Uploads file in chunks for reliability
+     * - Automatically retries failed chunks with exponential backoff
+     * - Reports progress via callback with chunk-level granularity
+     * - Can resume interrupted uploads using session ID
+     *
+     * @param path - The file path within the bucket
+     * @param file - The File or Blob to upload
+     * @param options - Upload options including chunk size, retries, and progress callback
+     * @returns Upload result with file info
+     *
+     * @example
+     * const { data, error } = await storage.from('uploads').uploadResumable('large.zip', file, {
+     *   chunkSize: 5 * 1024 * 1024, // 5MB chunks
+     *   maxRetries: 3,
+     *   onProgress: (p) => {
+     *     console.log(`${p.percentage}% (chunk ${p.currentChunk}/${p.totalChunks})`);
+     *     console.log(`Speed: ${(p.bytesPerSecond / 1024 / 1024).toFixed(2)} MB/s`);
+     *     console.log(`Session ID (for resume): ${p.sessionId}`);
+     *   }
+     * });
+     *
+     * // To resume an interrupted upload:
+     * const { data, error } = await storage.from('uploads').uploadResumable('large.zip', file, {
+     *   resumeSessionId: 'previous-session-id',
+     * });
+     */
+    uploadResumable(path: string, file: File | Blob, options?: ResumableUploadOptions): Promise<{
+        data: {
+            id: string;
+            path: string;
+            fullPath: string;
+        } | null;
+        error: Error | null;
+    }>;
+    /**
+     * Abort an in-progress resumable upload
+     * @param sessionId - The upload session ID to abort
+     */
+    abortResumableUpload(sessionId: string): Promise<{
+        error: Error | null;
+    }>;
+    /**
+     * Get the status of a resumable upload session
+     * @param sessionId - The upload session ID to check
+     */
+    getResumableUploadStatus(sessionId: string): Promise<{
+        data: ChunkedUploadSession | null;
+        error: Error | null;
+    }>;
+    /**
+     * List files in the bucket
+     * Supports both Supabase-style list(path, options) and Fluxbase-style list(options)
+     * @param pathOrOptions - The folder path or list options
+     * @param maybeOptions - List options when first param is a path
+     */
+    list(pathOrOptions?: string | ListOptions, maybeOptions?: ListOptions): Promise<{
+        data: FileObject[] | null;
         error: Error | null;
     }>;
     /**
@@ -3602,6 +4216,198 @@ declare class FluxbaseJobs {
         data: Job | null;
         error: Error | null;
     }>;
+    /**
+     * Get execution logs for a job
+     *
+     * Returns logs for the specified job. Only returns logs for jobs
+     * owned by the authenticated user (unless using service_role).
+     *
+     * @param jobId - Job ID
+     * @param afterLine - Optional line number to get logs after (for polling/streaming)
+     * @returns Promise resolving to { data, error } tuple with execution logs
+     *
+     * @example
+     * ```typescript
+     * // Get all logs for a job
+     * const { data: logs, error } = await client.jobs.getLogs('550e8400-e29b-41d4-a716-446655440000')
+     *
+     * if (logs) {
+     *   for (const log of logs) {
+     *     console.log(`[${log.level}] ${log.message}`)
+     *   }
+     * }
+     *
+     * // Backfill + stream pattern
+     * const { data: logs } = await client.jobs.getLogs(jobId)
+     * let lastLine = Math.max(...(logs?.map(l => l.line_number) ?? []), 0)
+     *
+     * const channel = client.realtime
+     *   .executionLogs(jobId, 'job')
+     *   .onLog((log) => {
+     *     if (log.line_number > lastLine) {
+     *       displayLog(log)
+     *       lastLine = log.line_number
+     *     }
+     *   })
+     *   .subscribe()
+     * ```
+     */
+    getLogs(jobId: string, afterLine?: number): Promise<{
+        data: ExecutionLog[] | null;
+        error: Error | null;
+    }>;
+}
+
+/**
+ * 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;
+    }>;
 }
 
 /**
@@ -5854,17 +6660,12 @@ declare class FluxbaseAdminMigrations {
         error: Error | null;
     };
     /**
-     * Trigger schema refresh which will restart the server
-     * Handles the restart gracefully by waiting for the server to come back online
+     * Trigger schema refresh to update the REST API cache
+     * Note: Server no longer restarts - cache is invalidated instantly
      *
      * @private
      */
-    private triggerSchemaRefreshWithRestart;
-    /**
-     * Helper function to sleep for a given duration
-     * @private
-     */
-    private sleep;
+    private triggerSchemaRefresh;
     /**
      * Smart sync all registered migrations
      *
@@ -5939,7 +6740,7 @@ declare class FluxbaseAdminMigrations {
      * const { data, error } = await client.admin.migrations.list('myapp', 'pending')
      * ```
      */
-    list(namespace?: string, status?: 'pending' | 'applied' | 'failed' | 'rolled_back'): Promise<{
+    list(namespace?: string, status?: "pending" | "applied" | "failed" | "rolled_back"): Promise<{
         data: Migration[] | null;
         error: Error | null;
     }>;
@@ -6446,8 +7247,8 @@ declare class FluxbaseAdminJobs {
 }
 
 /**
- * Admin AI module for managing AI chatbots and providers
- * Provides administrative operations for chatbot lifecycle management
+ * Admin AI module for managing AI chatbots, providers, and knowledge bases
+ * Provides administrative operations for chatbot lifecycle management and RAG
  */
 
 /**
@@ -6677,54 +7478,355 @@ declare class FluxbaseAdminAI {
         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.
+     * List all knowledge bases
      *
-     * @param options - Sync options including namespace and optional procedures array
-     * @returns Promise resolving to { data, error } tuple with sync results
+     * @returns Promise resolving to { data, error } tuple with array of knowledge base summaries
      *
      * @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
-     *   }
-     * })
-     *
+     * const { data, error } = await client.admin.ai.listKnowledgeBases()
      * if (data) {
-     *   console.log(`Synced: ${data.summary.created} created, ${data.summary.updated} updated`)
+     *   console.log('Knowledge bases:', data.map(kb => kb.name))
+     * }
+     * ```
+     */
+    listKnowledgeBases(): Promise<{
+        data: KnowledgeBaseSummary[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get a specific knowledge base
+     *
+     * @param id - Knowledge base ID
+     * @returns Promise resolving to { data, error } tuple with knowledge base details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.getKnowledgeBase('uuid')
+     * if (data) {
+     *   console.log('Knowledge base:', data.name)
+     * }
+     * ```
+     */
+    getKnowledgeBase(id: string): Promise<{
+        data: KnowledgeBase | null;
+        error: Error | null;
+    }>;
+    /**
+     * Create a new knowledge base
+     *
+     * @param request - Knowledge base configuration
+     * @returns Promise resolving to { data, error } tuple with created knowledge base
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.createKnowledgeBase({
+     *   name: 'product-docs',
+     *   description: 'Product documentation',
+     *   chunk_size: 512,
+     *   chunk_overlap: 50,
+     * })
+     * ```
+     */
+    createKnowledgeBase(request: CreateKnowledgeBaseRequest): Promise<{
+        data: KnowledgeBase | null;
+        error: Error | null;
+    }>;
+    /**
+     * Update an existing knowledge base
+     *
+     * @param id - Knowledge base ID
+     * @param updates - Fields to update
+     * @returns Promise resolving to { data, error } tuple with updated knowledge base
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.updateKnowledgeBase('uuid', {
+     *   description: 'Updated description',
+     *   enabled: true,
+     * })
+     * ```
+     */
+    updateKnowledgeBase(id: string, updates: UpdateKnowledgeBaseRequest): Promise<{
+        data: KnowledgeBase | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a knowledge base
+     *
+     * @param id - Knowledge base ID
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.deleteKnowledgeBase('uuid')
+     * ```
+     */
+    deleteKnowledgeBase(id: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * List documents in a knowledge base
+     *
+     * @param knowledgeBaseId - Knowledge base ID
+     * @returns Promise resolving to { data, error } tuple with array of documents
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.listDocuments('kb-uuid')
+     * if (data) {
+     *   console.log('Documents:', data.map(d => d.title))
+     * }
+     * ```
+     */
+    listDocuments(knowledgeBaseId: string): Promise<{
+        data: KnowledgeBaseDocument[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Get a specific document
+     *
+     * @param knowledgeBaseId - Knowledge base ID
+     * @param documentId - Document ID
+     * @returns Promise resolving to { data, error } tuple with document details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.getDocument('kb-uuid', 'doc-uuid')
+     * ```
+     */
+    getDocument(knowledgeBaseId: string, documentId: string): Promise<{
+        data: KnowledgeBaseDocument | null;
+        error: Error | null;
+    }>;
+    /**
+     * Add a document to a knowledge base
+     *
+     * Document will be chunked and embedded asynchronously.
+     *
+     * @param knowledgeBaseId - Knowledge base ID
+     * @param request - Document content and metadata
+     * @returns Promise resolving to { data, error } tuple with document ID
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.addDocument('kb-uuid', {
+     *   title: 'Getting Started Guide',
+     *   content: 'This is the content of the document...',
+     *   metadata: { category: 'guides' },
+     * })
+     * if (data) {
+     *   console.log('Document ID:', data.document_id)
+     * }
+     * ```
+     */
+    addDocument(knowledgeBaseId: string, request: AddDocumentRequest): Promise<{
+        data: AddDocumentResponse | null;
+        error: Error | null;
+    }>;
+    /**
+     * Upload a document file to a knowledge base
+     *
+     * Supported file types: PDF, TXT, MD, HTML, CSV, DOCX, XLSX, RTF, EPUB, JSON
+     * Maximum file size: 50MB
+     *
+     * @param knowledgeBaseId - Knowledge base ID
+     * @param file - File to upload (File or Blob)
+     * @param title - Optional document title (defaults to filename without extension)
+     * @returns Promise resolving to { data, error } tuple with upload result
+     *
+     * @example
+     * ```typescript
+     * // Browser
+     * const fileInput = document.getElementById('file') as HTMLInputElement
+     * const file = fileInput.files?.[0]
+     * if (file) {
+     *   const { data, error } = await client.admin.ai.uploadDocument('kb-uuid', file)
+     *   if (data) {
+     *     console.log('Document ID:', data.document_id)
+     *     console.log('Extracted length:', data.extracted_length)
+     *   }
+     * }
+     *
+     * // Node.js (with node-fetch or similar)
+     * import { Blob } from 'buffer'
+     * const content = await fs.readFile('document.pdf')
+     * const blob = new Blob([content], { type: 'application/pdf' })
+     * const { data, error } = await client.admin.ai.uploadDocument('kb-uuid', blob, 'My Document')
+     * ```
+     */
+    uploadDocument(knowledgeBaseId: string, file: File | Blob, title?: string): Promise<{
+        data: UploadDocumentResponse | null;
+        error: Error | null;
+    }>;
+    /**
+     * Delete a document from a knowledge base
+     *
+     * @param knowledgeBaseId - Knowledge base ID
+     * @param documentId - Document ID
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.deleteDocument('kb-uuid', 'doc-uuid')
+     * ```
+     */
+    deleteDocument(knowledgeBaseId: string, documentId: string): Promise<{
+        data: null;
+        error: Error | null;
+    }>;
+    /**
+     * Search a knowledge base
+     *
+     * @param knowledgeBaseId - Knowledge base ID
+     * @param query - Search query
+     * @param options - Search options
+     * @returns Promise resolving to { data, error } tuple with search results
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.searchKnowledgeBase('kb-uuid', 'how to reset password', {
+     *   max_chunks: 5,
+     *   threshold: 0.7,
+     * })
+     * if (data) {
+     *   console.log('Results:', data.results.map(r => r.content))
+     * }
+     * ```
+     */
+    searchKnowledgeBase(knowledgeBaseId: string, query: string, options?: {
+        max_chunks?: number;
+        threshold?: number;
+    }): Promise<{
+        data: SearchKnowledgeBaseResponse | null;
+        error: Error | null;
+    }>;
+    /**
+     * List knowledge bases linked to a chatbot
+     *
+     * @param chatbotId - Chatbot ID
+     * @returns Promise resolving to { data, error } tuple with linked knowledge bases
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.listChatbotKnowledgeBases('chatbot-uuid')
+     * if (data) {
+     *   console.log('Linked KBs:', data.map(l => l.knowledge_base_id))
+     * }
+     * ```
+     */
+    listChatbotKnowledgeBases(chatbotId: string): Promise<{
+        data: ChatbotKnowledgeBaseLink[] | null;
+        error: Error | null;
+    }>;
+    /**
+     * Link a knowledge base to a chatbot
+     *
+     * @param chatbotId - Chatbot ID
+     * @param request - Link configuration
+     * @returns Promise resolving to { data, error } tuple with link details
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.linkKnowledgeBase('chatbot-uuid', {
+     *   knowledge_base_id: 'kb-uuid',
+     *   priority: 1,
+     *   max_chunks: 5,
+     *   similarity_threshold: 0.7,
+     * })
+     * ```
+     */
+    linkKnowledgeBase(chatbotId: string, request: LinkKnowledgeBaseRequest): Promise<{
+        data: ChatbotKnowledgeBaseLink | null;
+        error: Error | null;
+    }>;
+    /**
+     * Update a chatbot-knowledge base link
+     *
+     * @param chatbotId - Chatbot ID
+     * @param knowledgeBaseId - Knowledge base ID
+     * @param updates - Fields to update
+     * @returns Promise resolving to { data, error } tuple with updated link
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.updateChatbotKnowledgeBase(
+     *   'chatbot-uuid',
+     *   'kb-uuid',
+     *   { max_chunks: 10, enabled: true }
+     * )
+     * ```
+     */
+    updateChatbotKnowledgeBase(chatbotId: string, knowledgeBaseId: string, updates: UpdateChatbotKnowledgeBaseRequest): Promise<{
+        data: ChatbotKnowledgeBaseLink | null;
+        error: Error | null;
+    }>;
+    /**
+     * Unlink a knowledge base from a chatbot
+     *
+     * @param chatbotId - Chatbot ID
+     * @param knowledgeBaseId - Knowledge base ID
+     * @returns Promise resolving to { data, error } tuple
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.admin.ai.unlinkKnowledgeBase('chatbot-uuid', 'kb-uuid')
+     * ```
+     */
+    unlinkKnowledgeBase(chatbotId: string, knowledgeBaseId: 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`)
      * }
      * ```
      */
@@ -6920,6 +8022,158 @@ declare class FluxbaseAdminRPC {
     }>;
 }
 
+/**
+ * Admin storage manager for bucket and object management
+ */
+declare class FluxbaseAdminStorage {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * List all storage buckets
+     *
+     * @returns List of buckets
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await admin.storage.listBuckets();
+     * if (data) {
+     *   console.log(`Found ${data.buckets.length} buckets`);
+     * }
+     * ```
+     */
+    listBuckets(): Promise<DataResponse<AdminListBucketsResponse>>;
+    /**
+     * Create a new storage bucket
+     *
+     * @param name - Bucket name
+     * @returns Success message
+     *
+     * @example
+     * ```typescript
+     * const { error } = await admin.storage.createBucket('my-bucket');
+     * if (!error) {
+     *   console.log('Bucket created');
+     * }
+     * ```
+     */
+    createBucket(name: string): Promise<DataResponse<{
+        message: string;
+    }>>;
+    /**
+     * Delete a storage bucket
+     *
+     * @param name - Bucket name
+     * @returns Success message
+     *
+     * @example
+     * ```typescript
+     * const { error } = await admin.storage.deleteBucket('my-bucket');
+     * if (!error) {
+     *   console.log('Bucket deleted');
+     * }
+     * ```
+     */
+    deleteBucket(name: string): Promise<DataResponse<{
+        message: string;
+    }>>;
+    /**
+     * List objects in a bucket
+     *
+     * @param bucket - Bucket name
+     * @param prefix - Optional path prefix to filter results
+     * @param delimiter - Optional delimiter for hierarchical listing (usually '/')
+     * @returns List of objects and prefixes (folders)
+     *
+     * @example
+     * ```typescript
+     * // List all objects in bucket
+     * const { data } = await admin.storage.listObjects('my-bucket');
+     *
+     * // List objects in a folder
+     * const { data } = await admin.storage.listObjects('my-bucket', 'folder/', '/');
+     * ```
+     */
+    listObjects(bucket: string, prefix?: string, delimiter?: string): Promise<DataResponse<AdminListObjectsResponse>>;
+    /**
+     * Get object metadata
+     *
+     * @param bucket - Bucket name
+     * @param key - Object key (path)
+     * @returns Object metadata
+     *
+     * @example
+     * ```typescript
+     * const { data } = await admin.storage.getObjectMetadata('my-bucket', 'path/to/file.txt');
+     * if (data) {
+     *   console.log(`File size: ${data.size} bytes`);
+     * }
+     * ```
+     */
+    getObjectMetadata(bucket: string, key: string): Promise<DataResponse<AdminStorageObject>>;
+    /**
+     * Download an object as a Blob
+     *
+     * @param bucket - Bucket name
+     * @param key - Object key (path)
+     * @returns Object data as Blob
+     *
+     * @example
+     * ```typescript
+     * const { data: blob } = await admin.storage.downloadObject('my-bucket', 'file.pdf');
+     * if (blob) {
+     *   // Use the blob
+     *   const url = URL.createObjectURL(blob);
+     * }
+     * ```
+     */
+    downloadObject(bucket: string, key: string): Promise<DataResponse<Blob>>;
+    /**
+     * Delete an object
+     *
+     * @param bucket - Bucket name
+     * @param key - Object key (path)
+     *
+     * @example
+     * ```typescript
+     * const { error } = await admin.storage.deleteObject('my-bucket', 'path/to/file.txt');
+     * if (!error) {
+     *   console.log('Object deleted');
+     * }
+     * ```
+     */
+    deleteObject(bucket: string, key: string): Promise<VoidResponse>;
+    /**
+     * Create a folder (empty object with directory content type)
+     *
+     * @param bucket - Bucket name
+     * @param folderPath - Folder path (should end with /)
+     *
+     * @example
+     * ```typescript
+     * const { error } = await admin.storage.createFolder('my-bucket', 'new-folder/');
+     * ```
+     */
+    createFolder(bucket: string, folderPath: string): Promise<VoidResponse>;
+    /**
+     * Generate a signed URL for temporary access
+     *
+     * @param bucket - Bucket name
+     * @param key - Object key (path)
+     * @param expiresIn - Expiration time in seconds
+     * @returns Signed URL and expiration info
+     *
+     * @example
+     * ```typescript
+     * const { data } = await admin.storage.generateSignedUrl('my-bucket', 'file.pdf', 3600);
+     * if (data) {
+     *   console.log(`Download at: ${data.url}`);
+     *   console.log(`Expires in: ${data.expires_in} seconds`);
+     * }
+     * ```
+     */
+    generateSignedUrl(bucket: string, key: string, expiresIn: number): Promise<DataResponse<SignedUrlResponse>>;
+}
+
 /**
  * Admin client for managing Fluxbase instance
  */
@@ -6970,6 +8224,10 @@ declare class FluxbaseAdmin {
      * RPC manager for procedure management (create, update, delete, sync, execution monitoring)
      */
     rpc: FluxbaseAdminRPC;
+    /**
+     * Storage manager for bucket and object management (list, create, delete, signed URLs)
+     */
+    storage: FluxbaseAdminStorage;
     constructor(fetch: FluxbaseFetch);
     /**
      * Set admin authentication token
@@ -6982,7 +8240,41 @@ declare class FluxbaseAdmin {
     /**
      * Clear admin token
      */
-    clearToken(): void;
+    clearToken(): void;
+    /**
+     * Get system health status
+     *
+     * @returns Health status including database and realtime service status
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await admin.getHealth();
+     * if (data) {
+     *   console.log('Status:', data.status);
+     *   console.log('Database:', data.services.database);
+     *   console.log('Realtime:', data.services.realtime);
+     * }
+     * ```
+     */
+    getHealth(): Promise<DataResponse<HealthResponse>>;
+    /**
+     * Send an email
+     *
+     * @param request - Email details (to, subject, html/text)
+     *
+     * @example
+     * ```typescript
+     * const { error } = await admin.sendEmail({
+     *   to: 'user@example.com',
+     *   subject: 'Hello',
+     *   html: '<p>Your message here</p>'
+     * });
+     * if (!error) {
+     *   console.log('Email sent');
+     * }
+     * ```
+     */
+    sendEmail(request: SendEmailRequest): Promise<VoidResponse>;
     /**
      * Check if initial admin setup is needed
      *
@@ -7470,6 +8762,93 @@ declare class FluxbaseAI {
     }>;
 }
 
+/**
+ * Vector search module for Fluxbase SDK
+ * Provides convenience methods for vector similarity search using pgvector
+ */
+
+/**
+ * FluxbaseVector provides vector search functionality using pgvector
+ *
+ * @example
+ * ```typescript
+ * // Embed text and search
+ * const { data: results } = await client.vector.search({
+ *   table: 'documents',
+ *   column: 'embedding',
+ *   query: 'How to use TypeScript?',
+ *   match_count: 10
+ * })
+ *
+ * // Embed text directly
+ * const { data: embedding } = await client.vector.embed({ text: 'Hello world' })
+ * ```
+ */
+declare class FluxbaseVector {
+    private fetch;
+    constructor(fetch: FluxbaseFetch);
+    /**
+     * Generate embeddings for text
+     *
+     * @example
+     * ```typescript
+     * // Single text
+     * const { data } = await client.vector.embed({
+     *   text: 'Hello world'
+     * })
+     * console.log(data.embeddings[0]) // [0.1, 0.2, ...]
+     *
+     * // Multiple texts
+     * const { data } = await client.vector.embed({
+     *   texts: ['Hello', 'World'],
+     *   model: 'text-embedding-3-small'
+     * })
+     * ```
+     */
+    embed(request: EmbedRequest): Promise<FluxbaseResponse<EmbedResponse>>;
+    /**
+     * Search for similar vectors with automatic text embedding
+     *
+     * This is a convenience method that:
+     * 1. Embeds the query text automatically (if `query` is provided)
+     * 2. Performs vector similarity search
+     * 3. Returns results with distance scores
+     *
+     * @example
+     * ```typescript
+     * // Search with text query (auto-embedded)
+     * const { data } = await client.vector.search({
+     *   table: 'documents',
+     *   column: 'embedding',
+     *   query: 'How to use TypeScript?',
+     *   match_count: 10,
+     *   match_threshold: 0.8
+     * })
+     *
+     * // Search with pre-computed vector
+     * const { data } = await client.vector.search({
+     *   table: 'documents',
+     *   column: 'embedding',
+     *   vector: [0.1, 0.2, ...],
+     *   metric: 'cosine',
+     *   match_count: 10
+     * })
+     *
+     * // With additional filters
+     * const { data } = await client.vector.search({
+     *   table: 'documents',
+     *   column: 'embedding',
+     *   query: 'TypeScript tutorial',
+     *   filters: [
+     *     { column: 'status', operator: 'eq', value: 'published' }
+     *   ],
+     *   match_count: 10
+     * })
+     * ```
+     */
+    search<T = Record<string, unknown>>(options: VectorSearchOptions): Promise<FluxbaseResponse<VectorSearchResult<T>>>;
+}
+
 /**
  * PostgreSQL query builder for Fluxbase SDK
  * Inspired by Supabase's PostgREST client
@@ -7493,6 +8872,7 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
     private operationType;
     private countType?;
     private headOnly;
+    private isCountAggregation;
     private insertData?;
     private updateData?;
     constructor(fetch: FluxbaseFetch, table: string, schema?: string);
@@ -7691,6 +9071,56 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
         ascending?: boolean;
         nullsFirst?: boolean;
     }): this;
+    /**
+     * Order results by vector similarity (pgvector)
+     * Results are ordered by distance (ascending = closest first)
+     *
+     * @example
+     * ```typescript
+     * // Order by cosine similarity (closest matches first)
+     * const { data } = await client
+     *   .from('documents')
+     *   .select('id, title, content')
+     *   .orderByVector('embedding', queryVector, 'cosine')
+     *   .limit(10)
+     * ```
+     *
+     * @param column - The vector column to order by
+     * @param vector - The query vector to compare against
+     * @param metric - Distance metric: 'l2' (euclidean), 'cosine', or 'inner_product'
+     * @param options - Optional: { ascending?: boolean } - defaults to true (closest first)
+     */
+    orderByVector(column: string, vector: number[], metric?: VectorMetric, options?: {
+        ascending?: boolean;
+    }): this;
+    /**
+     * Filter by vector similarity (pgvector)
+     * This is a convenience method that adds a vector filter using the specified distance metric.
+     * Typically used with orderByVector() for similarity search.
+     *
+     * @example
+     * ```typescript
+     * // Find the 10 most similar documents
+     * const { data } = await client
+     *   .from('documents')
+     *   .select('id, title, content')
+     *   .vectorSearch('embedding', queryVector, 'cosine')
+     *   .limit(10)
+     *
+     * // Combine with other filters
+     * const { data } = await client
+     *   .from('documents')
+     *   .select('id, title, content')
+     *   .eq('status', 'published')
+     *   .vectorSearch('embedding', queryVector)
+     *   .limit(10)
+     * ```
+     *
+     * @param column - The vector column to search
+     * @param vector - The query vector
+     * @param metric - Distance metric: 'l2' (euclidean), 'cosine', or 'inner_product'
+     */
+    vectorSearch(column: string, vector: number[], metric?: VectorMetric): this;
     /**
      * Limit number of rows returned
      */
@@ -7984,6 +9414,21 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
      * Header format: "0-999/50000" or "* /50000" (when no rows returned)
      */
     private parseContentRangeCount;
+    /**
+     * Check if the query should use POST-based query endpoint
+     * Returns true if the query string would exceed the URL length threshold
+     */
+    private shouldUsePostQuery;
+    /**
+     * Execute a SELECT query using the POST /query endpoint
+     * Used when query parameters would exceed URL length limits
+     */
+    private executePostQuery;
+    /**
+     * Build the request body for POST-based queries
+     * Used when query parameters would exceed URL length limits
+     */
+    private buildQueryBody;
 }
 
 /**
@@ -7991,10 +9436,10 @@ declare class QueryBuilder<T = unknown> implements PromiseLike<PostgrestResponse
  *
  * @example
  * ```typescript
- * // Query the jobs.execution_logs table
+ * // Query the logging.entries table
  * const { data } = await client
- *   .schema('jobs')
- *   .from('execution_logs')
+ *   .schema('logging')
+ *   .from('entries')
  *   .select('*')
  *   .execute();
  * ```
@@ -8013,6 +9458,29 @@ declare class SchemaQueryBuilder {
     from<T = any>(table: string): QueryBuilder<T>;
 }
 
+/**
+ * Callable RPC type - can be called directly (Supabase-compatible) or access methods
+ * @category RPC
+ */
+type CallableRPC = {
+    /**
+     * Call a PostgreSQL function (RPC) - Supabase compatible
+     * Uses 'default' namespace
+     *
+     * @param fn - Function name
+     * @param params - Function parameters
+     * @returns Promise with data or error
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await client.rpc('get_user_orders', { user_id: '123' })
+     * ```
+     */
+    <T = any>(fn: string, params?: Record<string, unknown>): Promise<{
+        data: T | null;
+        error: Error | null;
+    }>;
+} & FluxbaseRPC;
 /**
  * Main Fluxbase client class
  * @category Client
@@ -8040,6 +9508,57 @@ declare class FluxbaseClient<Database = any, _SchemaName extends string & keyof
     settings: SettingsClient;
     /** AI module for chatbots and conversation history */
     ai: FluxbaseAI;
+    /**
+     * Vector search module for pgvector similarity search
+     *
+     * Provides convenience methods for vector similarity search:
+     * - `embed()` - Generate embeddings from text
+     * - `search()` - Search for similar vectors with auto-embedding
+     *
+     * @example
+     * ```typescript
+     * // Search with automatic embedding
+     * const { data } = await client.vector.search({
+     *   table: 'documents',
+     *   column: 'embedding',
+     *   query: 'How to use TypeScript?',
+     *   match_count: 10
+     * })
+     *
+     * // Generate embeddings
+     * const { data } = await client.vector.embed({ text: 'Hello world' })
+     * ```
+     *
+     * Note: For more control, use the QueryBuilder methods:
+     * - `vectorSearch()` - Filter and order by vector similarity
+     * - `orderByVector()` - Order results by vector distance
+     *
+     * @category Vector Search
+     */
+    vector: FluxbaseVector;
+    /**
+     * RPC module for calling PostgreSQL functions - Supabase compatible
+     *
+     * Can be called directly (Supabase-style) or access methods like invoke(), list(), getStatus()
+     *
+     * @example
+     * ```typescript
+     * // Supabase-style direct call (uses 'default' namespace)
+     * const { data, error } = await client.rpc('get_user_orders', { user_id: '123' })
+     *
+     * // With full options
+     * const { data, error } = await client.rpc.invoke('get_user_orders', { user_id: '123' }, {
+     *   namespace: 'custom',
+     *   async: true
+     * })
+     *
+     * // List available procedures
+     * const { data: procedures } = await client.rpc.list()
+     * ```
+     *
+     * @category RPC
+     */
+    rpc: CallableRPC;
     /**
      * Create a new Fluxbase client instance
      *
@@ -8092,12 +9611,12 @@ declare class FluxbaseClient<Database = any, _SchemaName extends string & keyof
      *
      * @example
      * ```typescript
-     * // Query the jobs.execution_logs table
+     * // Query the logging.entries table
      * const { data } = await client
-     *   .schema('jobs')
-     *   .from('execution_logs')
+     *   .schema('logging')
+     *   .from('entries')
      *   .select('*')
-     *   .eq('job_id', jobId)
+     *   .eq('execution_id', executionId)
      *   .execute()
      *
      * // Insert into a custom schema table
@@ -8239,156 +9758,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>;
 
-/**
- * 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 };
+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 AdminBucket, type AdminListBucketsResponse, type AdminListObjectsResponse, type AdminLoginRequest, type AdminMeResponse, type AdminRefreshRequest, type AdminRefreshResponse, type AdminSetupRequest, type AdminSetupStatusResponse, type AdminStorageObject, 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 ChunkedUploadSession, 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 EmbedRequest, type EmbedResponse, type EnrichedUser, type ExecutionLog, type ExecutionLogCallback, type ExecutionLogConfig, type ExecutionLogEvent, type ExecutionLogLevel, ExecutionLogsChannel, type ExecutionType, type FeatureSettings, type FileObject, type FilterOperator, FluxbaseAI, FluxbaseAIChat, FluxbaseAdmin, FluxbaseAdminAI, FluxbaseAdminFunctions, FluxbaseAdminJobs, FluxbaseAdminMigrations, FluxbaseAdminRPC, FluxbaseAdminStorage, FluxbaseAuth, type FluxbaseAuthResponse, FluxbaseClient, type FluxbaseClientOptions, type FluxbaseError, FluxbaseFetch, FluxbaseFunctions, FluxbaseJobs, FluxbaseManagement, FluxbaseOAuth, FluxbaseRPC, FluxbaseRealtime, type FluxbaseResponse, FluxbaseSettings, FluxbaseStorage, FluxbaseVector, type FunctionInvokeOptions, type FunctionSpec, type GetImpersonationResponse, type HealthResponse, 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 ResumableUploadOptions, type ResumableUploadProgress, type RevokeAPIKeyResponse, type RevokeInvitationResponse, type RollbackMigrationRequest, type SESSettings, type SMTPSettings, type Schema, SchemaQueryBuilder, type SecuritySettings, type SendEmailRequest, type SendGridSettings, type SessionResponse, SettingsClient, type SignInCredentials, type SignInWith2FAResponse, type SignUpCredentials, type SignedUrlOptions, type SignedUrlResponse, 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 VectorMetric, type VectorOrderOptions, type VectorSearchOptions, type VectorSearchResult, type VoidResponse, type WeakPassword, type Webhook, type WebhookDelivery, WebhooksManager, bundleCode, createClient, denoExternalPlugin, loadImportMap };