@vaiftechnologies/vaif-client 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,2508 @@
+/**
+ * Configuration options for creating a VAIF client
+ */
+interface VaifClientOptions {
+    /**
+     * Your VAIF Studio project ID
+     */
+    projectId: string;
+    /**
+     * API key for authentication (use anon key for client-side)
+     */
+    apiKey: string;
+    /**
+     * Custom API endpoint (defaults to https://api.vaif.studio)
+     */
+    apiUrl?: string;
+    /**
+     * Custom realtime endpoint (defaults to wss://realtime.vaif.studio)
+     */
+    realtimeUrl?: string;
+    /**
+     * Request timeout in milliseconds (default: 30000)
+     */
+    timeout?: number;
+    /**
+     * Custom headers to include with every request
+     */
+    headers?: Record<string, string>;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Auto-refresh authentication tokens
+     */
+    autoRefreshToken?: boolean;
+    /**
+     * Persist session to storage (localStorage in browser, memory in Node)
+     */
+    persistSession?: boolean;
+    /**
+     * Custom storage implementation for session persistence
+     */
+    storage?: StorageAdapter;
+}
+/**
+ * Internal configuration after processing options
+ */
+interface VaifConfig {
+    projectId: string;
+    apiKey: string;
+    apiUrl: string;
+    realtimeUrl: string;
+    timeout: number;
+    headers: Record<string, string>;
+    debug: boolean;
+    autoRefreshToken: boolean;
+    persistSession: boolean;
+    storage: StorageAdapter;
+}
+/**
+ * Storage adapter interface for session persistence
+ */
+interface StorageAdapter {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+/**
+ * Options for individual API requests
+ */
+interface RequestOptions {
+    /**
+     * HTTP method
+     */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /**
+     * Request headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request body
+     */
+    body?: unknown;
+    /**
+     * Query parameters
+     */
+    params?: Record<string, string | number | boolean | undefined>;
+    /**
+     * Request timeout override
+     */
+    timeout?: number;
+    /**
+     * AbortSignal for request cancellation
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Standard API response wrapper
+ */
+interface ApiResponse<T = unknown> {
+    /**
+     * Response data
+     */
+    data: T | null;
+    /**
+     * Error information if request failed
+     */
+    error: ApiError | null;
+    /**
+     * HTTP status code
+     */
+    status: number;
+    /**
+     * Response headers
+     */
+    headers: Record<string, string>;
+}
+/**
+ * API error structure
+ */
+interface ApiError {
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error code for programmatic handling
+     */
+    code?: string;
+    /**
+     * HTTP status code
+     */
+    status?: number;
+    /**
+     * Additional error details
+     */
+    details?: Record<string, unknown>;
+    /**
+     * Request ID for support
+     */
+    requestId?: string;
+}
+
+/**
+ * Database query types for VAIF Studio
+ */
+/**
+ * Filter operators for query conditions
+ */
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'like' | 'ilike' | 'is' | 'in' | 'contains' | 'containedBy' | 'overlaps' | 'match' | 'not';
+/**
+ * Order direction for sorting
+ */
+type OrderDirection = 'asc' | 'desc';
+/**
+ * Base query builder interface
+ */
+interface QueryBuilder$1<T = Record<string, unknown>> {
+    /**
+     * Filter by equality
+     */
+    eq(column: keyof T | string, value: unknown): this;
+    /**
+     * Filter by inequality
+     */
+    neq(column: keyof T | string, value: unknown): this;
+    /**
+     * Filter by greater than
+     */
+    gt(column: keyof T | string, value: unknown): this;
+    /**
+     * Filter by greater than or equal
+     */
+    gte(column: keyof T | string, value: unknown): this;
+    /**
+     * Filter by less than
+     */
+    lt(column: keyof T | string, value: unknown): this;
+    /**
+     * Filter by less than or equal
+     */
+    lte(column: keyof T | string, value: unknown): this;
+    /**
+     * Filter by pattern (case-sensitive)
+     */
+    like(column: keyof T | string, pattern: string): this;
+    /**
+     * Filter by pattern (case-insensitive)
+     */
+    ilike(column: keyof T | string, pattern: string): this;
+    /**
+     * Filter by null/not null
+     */
+    is(column: keyof T | string, value: null | boolean): this;
+    /**
+     * Filter by array of values
+     */
+    in(column: keyof T | string, values: unknown[]): this;
+    /**
+     * Filter by array containment
+     */
+    contains(column: keyof T | string, value: unknown[]): this;
+    /**
+     * Filter by array being contained
+     */
+    containedBy(column: keyof T | string, value: unknown[]): this;
+    /**
+     * Filter by array overlap
+     */
+    overlaps(column: keyof T | string, value: unknown[]): this;
+    /**
+     * Full-text search
+     */
+    textSearch(column: keyof T | string, query: string, options?: TextSearchOptions): this;
+    /**
+     * Negate the next filter
+     */
+    not: this;
+    /**
+     * Combine filters with OR
+     */
+    or(filters: string): this;
+    /**
+     * Order results
+     */
+    order(column: keyof T | string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): this;
+    /**
+     * Limit number of results
+     */
+    limit(count: number): this;
+    /**
+     * Offset results
+     */
+    offset(count: number): this;
+    /**
+     * Paginate results
+     */
+    range(from: number, to: number): this;
+    /**
+     * Return single result
+     */
+    single(): Promise<QueryResult<T>>;
+    /**
+     * Return first result or null
+     */
+    maybeSingle(): Promise<QueryResult<T | null>>;
+    /**
+     * Execute query and return results
+     */
+    execute(): Promise<QueryResult<T[]>>;
+}
+/**
+ * Text search options
+ */
+interface TextSearchOptions {
+    /**
+     * Search configuration (language)
+     */
+    config?: string;
+    /**
+     * Search type
+     */
+    type?: 'plain' | 'phrase' | 'websearch';
+}
+/**
+ * Select query builder
+ */
+interface SelectQuery<T = Record<string, unknown>> extends QueryBuilder$1<T> {
+    /**
+     * Select specific columns
+     */
+    select(columns?: string | string[]): this;
+    /**
+     * Include count of total rows
+     */
+    count(options?: {
+        exact?: boolean;
+        head?: boolean;
+    }): this;
+}
+/**
+ * Insert query builder
+ */
+interface InsertQuery<T = Record<string, unknown>> {
+    /**
+     * Insert single row
+     */
+    insert(data: Partial<T>): InsertBuilder<T>;
+    /**
+     * Insert multiple rows
+     */
+    insert(data: Partial<T>[]): InsertBuilder<T>;
+}
+/**
+ * Insert builder for chaining
+ */
+interface InsertBuilder<T = Record<string, unknown>> {
+    /**
+     * Return inserted rows
+     */
+    select(columns?: string | string[]): Promise<QueryResult<T[]>>;
+    /**
+     * Execute without returning
+     */
+    execute(): Promise<QueryResult<null>>;
+    /**
+     * Handle conflicts (upsert)
+     */
+    onConflict(columns: string | string[]): ConflictBuilder<T>;
+}
+/**
+ * Conflict handling builder
+ */
+interface ConflictBuilder<T = Record<string, unknown>> {
+    /**
+     * Do nothing on conflict
+     */
+    doNothing(): InsertBuilder<T>;
+    /**
+     * Update on conflict
+     */
+    doUpdate(data: Partial<T>): InsertBuilder<T>;
+}
+/**
+ * Update query builder
+ */
+interface UpdateQuery<T = Record<string, unknown>> extends Omit<QueryBuilder$1<T>, 'execute'> {
+    /**
+     * Update with data
+     */
+    update(data: Partial<T>): this;
+    /**
+     * Return updated rows
+     */
+    select(columns?: string | string[]): Promise<QueryResult<T[]>>;
+    /**
+     * Execute without returning
+     */
+    execute(): Promise<QueryResult<{
+        count: number;
+    }>>;
+}
+/**
+ * Delete query builder
+ */
+interface DeleteQuery<T = Record<string, unknown>> extends Omit<QueryBuilder$1<T>, 'execute'> {
+    /**
+     * Return deleted rows
+     */
+    select(columns?: string | string[]): Promise<QueryResult<T[]>>;
+    /**
+     * Execute without returning
+     */
+    execute(): Promise<QueryResult<{
+        count: number;
+    }>>;
+}
+/**
+ * Query result
+ */
+interface QueryResult<T> {
+    /**
+     * Query data
+     */
+    data: T;
+    /**
+     * Error if query failed
+     */
+    error: QueryError | null;
+    /**
+     * Total count (if requested)
+     */
+    count?: number;
+    /**
+     * HTTP status code
+     */
+    status: number;
+}
+/**
+ * Query error
+ */
+interface QueryError {
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error code
+     */
+    code: string;
+    /**
+     * Additional details
+     */
+    details?: string;
+    /**
+     * Hint for fixing the error
+     */
+    hint?: string;
+}
+
+/**
+ * VAIF Database Client
+ *
+ * Provides type-safe database operations with a fluent query builder
+ */
+
+/**
+ * Database client for VAIF Studio
+ */
+declare class VaifDatabase {
+    private client;
+    constructor(client: VaifClient);
+    /**
+     * Start a query on a table
+     *
+     * @example
+     * ```typescript
+     * const users = await vaif.db.from('users').select('*').execute();
+     * ```
+     */
+    from<T = Record<string, unknown>>(table: string): QueryBuilder<T>;
+    /**
+     * Execute raw SQL query (admin only)
+     *
+     * @example
+     * ```typescript
+     * const result = await vaif.db.raw('SELECT * FROM users WHERE id = $1', [userId]);
+     * ```
+     */
+    raw<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T[]>>;
+    /**
+     * Execute a function (stored procedure)
+     */
+    rpc<T = unknown>(functionName: string, params?: Record<string, unknown>): Promise<QueryResult<T>>;
+}
+/**
+ * Query builder for constructing database queries
+ */
+declare class QueryBuilder<T = Record<string, unknown>> {
+    private table;
+    private client;
+    private queryType;
+    private selectColumns;
+    private insertData;
+    private updateData;
+    private filters;
+    private orderSpecs;
+    private limitCount;
+    private offsetCount;
+    private returning;
+    private countOption;
+    private negateNext;
+    private onConflictColumns;
+    private onConflictAction;
+    private onConflictUpdate;
+    constructor(client: VaifClient, table: string);
+    /**
+     * Select columns
+     */
+    select(columns?: string | string[]): this;
+    /**
+     * Insert data
+     */
+    insert(data: Partial<T> | Partial<T>[]): this;
+    /**
+     * Update data
+     */
+    update(data: Partial<T>): this;
+    /**
+     * Delete rows
+     */
+    delete(): this;
+    /**
+     * Handle insert conflicts (upsert)
+     */
+    onConflict(columns: string | string[]): this;
+    /**
+     * Do nothing on conflict
+     */
+    doNothing(): this;
+    /**
+     * Update on conflict
+     */
+    doUpdate(data: Partial<T>): this;
+    eq(column: keyof T | string, value: unknown): this;
+    neq(column: keyof T | string, value: unknown): this;
+    gt(column: keyof T | string, value: unknown): this;
+    gte(column: keyof T | string, value: unknown): this;
+    lt(column: keyof T | string, value: unknown): this;
+    lte(column: keyof T | string, value: unknown): this;
+    like(column: keyof T | string, pattern: string): this;
+    ilike(column: keyof T | string, pattern: string): this;
+    is(column: keyof T | string, value: null | boolean): this;
+    in(column: keyof T | string, values: unknown[]): this;
+    contains(column: keyof T | string, value: unknown[]): this;
+    containedBy(column: keyof T | string, value: unknown[]): this;
+    overlaps(column: keyof T | string, value: unknown[]): this;
+    textSearch(column: keyof T | string, query: string, options?: {
+        config?: string;
+    }): this;
+    /**
+     * Negate the next filter
+     */
+    get not(): this;
+    /**
+     * Combine filters with OR
+     */
+    or(filters: string): this;
+    /**
+     * Order results
+     */
+    order(column: keyof T | string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): this;
+    /**
+     * Limit results
+     */
+    limit(count: number): this;
+    /**
+     * Offset results
+     */
+    offset(count: number): this;
+    /**
+     * Range of results
+     */
+    range(from: number, to: number): this;
+    /**
+     * Include count
+     */
+    count(type?: 'exact' | 'planned' | 'estimated'): this;
+    /**
+     * Return single result
+     */
+    single(): Promise<QueryResult<T>>;
+    /**
+     * Return first result or null
+     */
+    maybeSingle(): Promise<QueryResult<T | null>>;
+    /**
+     * Execute the query
+     */
+    execute(): Promise<QueryResult<T[]>>;
+    private addFilter;
+    private getHttpMethod;
+    private buildQuery;
+}
+
+/**
+ * Realtime types for VAIF Studio
+ */
+/**
+ * Realtime connection options
+ */
+interface RealtimeOptions {
+    /**
+     * Enable heartbeat
+     */
+    heartbeat?: boolean;
+    /**
+     * Heartbeat interval in milliseconds
+     */
+    heartbeatInterval?: number;
+    /**
+     * Reconnect on disconnect
+     */
+    autoReconnect?: boolean;
+    /**
+     * Maximum reconnect attempts
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Reconnect interval in milliseconds
+     */
+    reconnectInterval?: number;
+    /**
+     * Connection timeout in milliseconds
+     */
+    timeout?: number;
+}
+/**
+ * Realtime event types
+ */
+type RealtimeEvent = 'INSERT' | 'UPDATE' | 'DELETE' | '*' | 'postgres_changes' | 'broadcast' | 'presence';
+/**
+ * Database change event
+ */
+interface PostgresChangeEvent<T = Record<string, unknown>> {
+    /**
+     * Event type
+     */
+    eventType: 'INSERT' | 'UPDATE' | 'DELETE';
+    /**
+     * Schema name
+     */
+    schema: string;
+    /**
+     * Table name
+     */
+    table: string;
+    /**
+     * Commit timestamp
+     */
+    commitTimestamp: string;
+    /**
+     * New row data (for INSERT/UPDATE)
+     */
+    new: T | null;
+    /**
+     * Old row data (for UPDATE/DELETE)
+     */
+    old: Partial<T> | null;
+    /**
+     * Errors if any
+     */
+    errors: string[] | null;
+}
+/**
+ * Broadcast message
+ */
+interface BroadcastMessage<T = unknown> {
+    /**
+     * Event name
+     */
+    event: string;
+    /**
+     * Message payload
+     */
+    payload: T;
+    /**
+     * Message type
+     */
+    type: 'broadcast';
+}
+/**
+ * Presence state
+ */
+interface PresenceState<T = Record<string, unknown>> {
+    /**
+     * Presence key (user identifier)
+     */
+    key: string;
+    /**
+     * Presence payload
+     */
+    payload: T;
+    /**
+     * Join timestamp
+     */
+    joinedAt: string;
+}
+/**
+ * Presence sync event
+ */
+interface PresenceSyncEvent<T = Record<string, unknown>> {
+    /**
+     * Current presence state
+     */
+    state: Record<string, PresenceState<T>[]>;
+    /**
+     * Users who joined
+     */
+    joins: Record<string, PresenceState<T>[]>;
+    /**
+     * Users who left
+     */
+    leaves: Record<string, PresenceState<T>[]>;
+}
+/**
+ * Generic realtime message
+ */
+interface RealtimeMessage<T = unknown> {
+    /**
+     * Message topic
+     */
+    topic: string;
+    /**
+     * Event type
+     */
+    event: string;
+    /**
+     * Message payload
+     */
+    payload: T;
+    /**
+     * Reference ID
+     */
+    ref?: string;
+}
+/**
+ * Subscription callback type
+ */
+type SubscriptionCallback<T = unknown> = (payload: T) => void;
+/**
+ * Realtime channel status
+ */
+type ChannelStatus = 'SUBSCRIBED' | 'TIMED_OUT' | 'CLOSED' | 'CHANNEL_ERROR';
+/**
+ * Postgres changes filter
+ */
+interface PostgresChangesFilter {
+    /**
+     * Event type to listen for
+     */
+    event: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+    /**
+     * Schema name (defaults to 'public')
+     */
+    schema?: string;
+    /**
+     * Table name
+     */
+    table: string;
+    /**
+     * Filter expression (e.g., 'id=eq.123')
+     */
+    filter?: string;
+}
+
+/**
+ * VAIF Realtime Client
+ *
+ * WebSocket-based realtime subscriptions for database changes, broadcasts, and presence
+ */
+
+/**
+ * Realtime client for VAIF Studio
+ */
+declare class VaifRealtime {
+    private client;
+    private socket;
+    private channels;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectInterval;
+    private heartbeatInterval;
+    constructor(client: VaifClient);
+    /**
+     * Connect to realtime server
+     */
+    connect(options?: RealtimeOptions): void;
+    /**
+     * Disconnect from realtime server
+     */
+    disconnect(): void;
+    /**
+     * Create or get a channel
+     */
+    channel(name: string): RealtimeChannel;
+    /**
+     * Remove a channel
+     */
+    removeChannel(name: string): void;
+    /**
+     * Send message to server
+     */
+    send(message: unknown): void;
+    /**
+     * Get WebSocket instance
+     */
+    getSocket(): WebSocket | null;
+    private handleMessage;
+    private startHeartbeat;
+    private stopHeartbeat;
+}
+/**
+ * Realtime channel for subscriptions
+ */
+declare class RealtimeChannel {
+    private realtime;
+    private name;
+    private subscriptions;
+    private status;
+    private presenceState;
+    constructor(realtime: VaifRealtime, name: string);
+    /**
+     * Subscribe to postgres changes
+     */
+    on<T = Record<string, unknown>>(event: 'postgres_changes', filter: PostgresChangesFilter, callback: SubscriptionCallback<PostgresChangeEvent<T>>): this;
+    on<T = unknown>(event: 'broadcast', filter: {
+        event: string;
+    }, callback: SubscriptionCallback<BroadcastMessage<T>>): this;
+    on<T = Record<string, unknown>>(event: 'presence', filter: {
+        event: 'sync' | 'join' | 'leave';
+    }, callback: SubscriptionCallback<PresenceSyncEvent<T>>): this;
+    /**
+     * Subscribe to channel
+     */
+    subscribe(callback?: (status: ChannelStatus, error?: Error) => void): this;
+    /**
+     * Unsubscribe from channel
+     */
+    unsubscribe(): void;
+    /**
+     * Broadcast message to channel
+     */
+    broadcast<T = unknown>(event: string, payload: T): void;
+    /**
+     * Track presence
+     */
+    track<T = Record<string, unknown>>(payload: T): void;
+    /**
+     * Untrack presence
+     */
+    untrack(): void;
+    /**
+     * Get current presence state
+     */
+    getPresenceState<T = Record<string, unknown>>(): Map<string, PresenceState<T>[]>;
+    /**
+     * Handle incoming message
+     */
+    handleMessage(message: {
+        event: string;
+        payload: unknown;
+    }): void;
+    /**
+     * Resubscribe after reconnect
+     */
+    resubscribe(): void;
+}
+
+/**
+ * Storage types for VAIF Studio
+ */
+/**
+ * Storage client options
+ */
+interface StorageOptions {
+    /**
+     * Default bucket to use
+     */
+    defaultBucket?: string;
+}
+/**
+ * File upload options
+ */
+interface UploadOptions {
+    /**
+     * Content type (MIME type)
+     */
+    contentType?: string;
+    /**
+     * Cache control header
+     */
+    cacheControl?: string;
+    /**
+     * Upsert if file exists
+     */
+    upsert?: boolean;
+    /**
+     * Custom metadata
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Upload progress callback
+     */
+    onUploadProgress?: (progress: UploadProgress) => void;
+}
+/**
+ * Upload progress information
+ */
+interface UploadProgress {
+    /**
+     * Bytes uploaded
+     */
+    loaded: number;
+    /**
+     * Total bytes
+     */
+    total: number;
+    /**
+     * Progress percentage (0-100)
+     */
+    progress: number;
+}
+/**
+ * File download options
+ */
+interface DownloadOptions {
+    /**
+     * Transform image on download
+     */
+    transform?: ImageTransformOptions;
+}
+/**
+ * Image transformation options
+ */
+interface ImageTransformOptions {
+    /**
+     * Resize width
+     */
+    width?: number;
+    /**
+     * Resize height
+     */
+    height?: number;
+    /**
+     * Resize mode
+     */
+    resize?: 'cover' | 'contain' | 'fill';
+    /**
+     * Output format
+     */
+    format?: 'origin' | 'webp' | 'avif' | 'jpeg' | 'png';
+    /**
+     * Quality (1-100)
+     */
+    quality?: number;
+}
+/**
+ * Signed URL options
+ */
+interface SignedUrlOptions {
+    /**
+     * URL expiration in seconds
+     */
+    expiresIn: number;
+    /**
+     * Image transformations
+     */
+    transform?: ImageTransformOptions;
+    /**
+     * Download instead of inline
+     */
+    download?: boolean | string;
+}
+/**
+ * File object metadata
+ */
+interface FileObject {
+    /**
+     * File ID
+     */
+    id: string;
+    /**
+     * File name
+     */
+    name: string;
+    /**
+     * Bucket ID
+     */
+    bucketId: string;
+    /**
+     * File path within bucket
+     */
+    path: string;
+    /**
+     * File size in bytes
+     */
+    size: number;
+    /**
+     * Content type (MIME type)
+     */
+    contentType: string;
+    /**
+     * ETag for caching
+     */
+    etag: string;
+    /**
+     * Cache control header
+     */
+    cacheControl: string;
+    /**
+     * Custom metadata
+     */
+    metadata: Record<string, string>;
+    /**
+     * Created timestamp
+     */
+    createdAt: string;
+    /**
+     * Last modified timestamp
+     */
+    updatedAt: string;
+}
+/**
+ * Bucket metadata
+ */
+interface Bucket {
+    /**
+     * Bucket ID
+     */
+    id: string;
+    /**
+     * Bucket name
+     */
+    name: string;
+    /**
+     * Owner ID
+     */
+    ownerId: string;
+    /**
+     * Public access enabled
+     */
+    public: boolean;
+    /**
+     * File size limit in bytes
+     */
+    fileSizeLimit: number | null;
+    /**
+     * Allowed MIME types
+     */
+    allowedMimeTypes: string[] | null;
+    /**
+     * Created timestamp
+     */
+    createdAt: string;
+    /**
+     * Last updated timestamp
+     */
+    updatedAt: string;
+}
+/**
+ * List files options
+ */
+interface ListFilesOptions {
+    /**
+     * Number of files to return
+     */
+    limit?: number;
+    /**
+     * Offset for pagination
+     */
+    offset?: number;
+    /**
+     * Search query
+     */
+    search?: string;
+    /**
+     * Sort by column
+     */
+    sortBy?: {
+        column: 'name' | 'createdAt' | 'updatedAt' | 'size';
+        order: 'asc' | 'desc';
+    };
+}
+/**
+ * Upload result
+ */
+interface UploadResult {
+    /**
+     * Uploaded file path
+     */
+    path: string;
+    /**
+     * File ID
+     */
+    id: string;
+    /**
+     * Full URL (if public)
+     */
+    fullPath: string;
+}
+/**
+ * Storage error
+ */
+interface StorageError {
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error code
+     */
+    statusCode: string;
+    /**
+     * Error name
+     */
+    error: string;
+}
+
+/**
+ * VAIF Storage Client
+ *
+ * File storage operations with CDN and image transformations
+ */
+
+/**
+ * Storage client for VAIF Studio
+ */
+declare class VaifStorage {
+    private client;
+    constructor(client: VaifClient);
+    /**
+     * Get a storage bucket
+     */
+    from(bucket: string): StorageBucket;
+    /**
+     * List all buckets
+     */
+    listBuckets(): Promise<{
+        data: Bucket[] | null;
+        error: StorageError | null;
+    }>;
+    /**
+     * Create a bucket
+     */
+    createBucket(name: string, options?: {
+        public?: boolean;
+        fileSizeLimit?: number;
+        allowedMimeTypes?: string[];
+    }): Promise<{
+        data: Bucket | null;
+        error: StorageError | null;
+    }>;
+    /**
+     * Delete a bucket
+     */
+    deleteBucket(name: string): Promise<{
+        error: StorageError | null;
+    }>;
+}
+/**
+ * Storage bucket operations
+ */
+declare class StorageBucket {
+    private client;
+    private bucket;
+    constructor(client: VaifClient, bucket: string);
+    /**
+     * Upload a file
+     */
+    upload(path: string, file: File | Blob | ArrayBuffer | string, options?: UploadOptions): Promise<{
+        data: UploadResult | null;
+        error: StorageError | null;
+    }>;
+    /**
+     * Download a file
+     */
+    download(path: string, options?: DownloadOptions): Promise<{
+        data: Blob | null;
+        error: StorageError | null;
+    }>;
+    /**
+     * Get public URL for a file
+     */
+    getPublicUrl(path: string): {
+        data: {
+            publicUrl: string;
+        };
+    };
+    /**
+     * Create signed URL
+     */
+    createSignedUrl(path: string, options: SignedUrlOptions): Promise<{
+        data: {
+            signedUrl: string;
+        } | null;
+        error: StorageError | null;
+    }>;
+    /**
+     * List files in a path
+     */
+    list(path?: string, options?: ListFilesOptions): Promise<{
+        data: FileObject[] | null;
+        error: StorageError | null;
+    }>;
+    /**
+     * Move/rename a file
+     */
+    move(fromPath: string, toPath: string): Promise<{
+        error: StorageError | null;
+    }>;
+    /**
+     * Copy a file
+     */
+    copy(fromPath: string, toPath: string): Promise<{
+        error: StorageError | null;
+    }>;
+    /**
+     * Delete a file
+     */
+    remove(paths: string | string[]): Promise<{
+        error: StorageError | null;
+    }>;
+}
+
+/**
+ * Functions types for VAIF Studio
+ */
+/**
+ * Function invocation options
+ */
+interface FunctionInvokeOptions<T = unknown> {
+    /**
+     * Request body
+     */
+    body?: T;
+    /**
+     * HTTP method (defaults to POST)
+     */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /**
+     * Custom headers
+     */
+    headers?: Record<string, string>;
+    /**
+     * Request timeout in milliseconds
+     */
+    timeout?: number;
+    /**
+     * Region to invoke function in
+     */
+    region?: string;
+}
+/**
+ * Function response
+ */
+interface FunctionResponse<T = unknown> {
+    /**
+     * Response data
+     */
+    data: T | null;
+    /**
+     * Error if invocation failed
+     */
+    error: FunctionError | null;
+}
+/**
+ * Function error
+ */
+interface FunctionError {
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * HTTP status code
+     */
+    status?: number;
+    /**
+     * Error name/type
+     */
+    name?: string;
+    /**
+     * Stack trace (development only)
+     */
+    stack?: string;
+}
+
+/**
+ * VAIF Functions Client
+ *
+ * Invoke edge functions deployed on VAIF Studio
+ */
+
+/**
+ * Functions client for VAIF Studio
+ */
+declare class VaifFunctions {
+    private client;
+    constructor(client: VaifClient);
+    /**
+     * Invoke an edge function
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await vaif.functions.invoke('send-email', {
+     *   body: { to: 'user@example.com', subject: 'Hello' }
+     * });
+     * ```
+     */
+    invoke<T = unknown>(functionName: string, options?: FunctionInvokeOptions): Promise<FunctionResponse<T>>;
+    /**
+     * Create a function URL for direct invocation
+     */
+    createUrl(functionName: string): string;
+    /**
+     * Get list of deployed functions
+     */
+    list(): Promise<{
+        data: Array<{
+            name: string;
+            slug: string;
+            version: string;
+            status: 'active' | 'inactive' | 'deploying';
+            createdAt: string;
+            updatedAt: string;
+        }> | null;
+        error: FunctionError | null;
+    }>;
+    /**
+     * Get function details
+     */
+    get(functionName: string): Promise<{
+        data: {
+            name: string;
+            slug: string;
+            version: string;
+            status: 'active' | 'inactive' | 'deploying';
+            runtime: string;
+            memoryMb: number;
+            timeoutMs: number;
+            envVars: string[];
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+        error: FunctionError | null;
+    }>;
+    private serializeBody;
+}
+
+/**
+ * Authentication types for VAIF Studio
+ */
+/**
+ * Auth client options
+ */
+interface AuthOptions {
+    /**
+     * Auto-refresh token before expiry
+     */
+    autoRefreshToken?: boolean;
+    /**
+     * Persist session to storage
+     */
+    persistSession?: boolean;
+    /**
+     * Detect session from URL (for OAuth)
+     */
+    detectSessionInUrl?: boolean;
+    /**
+     * Flow type for OAuth
+     */
+    flowType?: 'implicit' | 'pkce';
+}
+/**
+ * User object
+ */
+interface User {
+    /**
+     * User ID
+     */
+    id: string;
+    /**
+     * Email address
+     */
+    email?: string;
+    /**
+     * Phone number
+     */
+    phone?: string;
+    /**
+     * Email confirmed timestamp
+     */
+    emailConfirmedAt?: string;
+    /**
+     * Phone confirmed timestamp
+     */
+    phoneConfirmedAt?: string;
+    /**
+     * Last sign in timestamp
+     */
+    lastSignInAt?: string;
+    /**
+     * Auth provider
+     */
+    appMetadata: {
+        provider?: string;
+        providers?: string[];
+        [key: string]: unknown;
+    };
+    /**
+     * User metadata
+     */
+    userMetadata: Record<string, unknown>;
+    /**
+     * Created timestamp
+     */
+    createdAt: string;
+    /**
+     * Updated timestamp
+     */
+    updatedAt: string;
+    /**
+     * User role
+     */
+    role?: string;
+}
+/**
+ * Session object
+ */
+interface Session {
+    /**
+     * Access token (JWT)
+     */
+    accessToken: string;
+    /**
+     * Refresh token
+     */
+    refreshToken: string;
+    /**
+     * Token type (usually 'bearer')
+     */
+    tokenType: string;
+    /**
+     * Expires in (seconds)
+     */
+    expiresIn: number;
+    /**
+     * Expiry timestamp
+     */
+    expiresAt: number;
+    /**
+     * User object
+     */
+    user: User;
+}
+/**
+ * Auth response
+ */
+interface AuthResponse {
+    /**
+     * Session data
+     */
+    data: {
+        user: User | null;
+        session: Session | null;
+    };
+    /**
+     * Error if auth failed
+     */
+    error: AuthError | null;
+}
+/**
+ * Auth error
+ */
+interface AuthError {
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error status code
+     */
+    status?: number;
+    /**
+     * Error code
+     */
+    code?: string;
+}
+/**
+ * Sign up credentials
+ */
+interface SignUpCredentials {
+    /**
+     * Email address
+     */
+    email?: string;
+    /**
+     * Phone number
+     */
+    phone?: string;
+    /**
+     * Password
+     */
+    password: string;
+    /**
+     * Additional user data
+     */
+    data?: Record<string, unknown>;
+    /**
+     * Redirect URL after confirmation
+     */
+    redirectTo?: string;
+    /**
+     * Captcha token
+     */
+    captchaToken?: string;
+}
+/**
+ * Sign in credentials
+ */
+interface SignInCredentials {
+    /**
+     * Email address
+     */
+    email?: string;
+    /**
+     * Phone number
+     */
+    phone?: string;
+    /**
+     * Password
+     */
+    password?: string;
+    /**
+     * Refresh token (for token refresh)
+     */
+    refreshToken?: string;
+    /**
+     * Redirect URL for OAuth
+     */
+    redirectTo?: string;
+    /**
+     * OAuth scopes
+     */
+    scopes?: string;
+    /**
+     * Captcha token
+     */
+    captchaToken?: string;
+}
+/**
+ * OAuth provider
+ */
+type OAuthProvider = 'google' | 'github' | 'gitlab' | 'bitbucket' | 'azure' | 'facebook' | 'twitter' | 'discord' | 'slack' | 'spotify' | 'twitch' | 'apple' | 'linkedin';
+/**
+ * OAuth sign in options
+ */
+interface OAuthSignInOptions {
+    /**
+     * OAuth provider
+     */
+    provider: OAuthProvider;
+    /**
+     * Redirect URL after auth
+     */
+    redirectTo?: string;
+    /**
+     * OAuth scopes
+     */
+    scopes?: string;
+    /**
+     * Additional query params
+     */
+    queryParams?: Record<string, string>;
+    /**
+     * Skip browser redirect (return URL only)
+     */
+    skipBrowserRedirect?: boolean;
+}
+/**
+ * Password reset options
+ */
+interface ResetPasswordOptions {
+    /**
+     * Email address
+     */
+    email: string;
+    /**
+     * Redirect URL after reset
+     */
+    redirectTo?: string;
+    /**
+     * Captcha token
+     */
+    captchaToken?: string;
+}
+/**
+ * Update user options
+ */
+interface UpdateUserOptions {
+    /**
+     * New email
+     */
+    email?: string;
+    /**
+     * New phone
+     */
+    phone?: string;
+    /**
+     * New password
+     */
+    password?: string;
+    /**
+     * User metadata
+     */
+    data?: Record<string, unknown>;
+    /**
+     * Email change nonce
+     */
+    nonce?: string;
+}
+/**
+ * Auth state change event
+ */
+type AuthChangeEvent = 'INITIAL_SESSION' | 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED' | 'PASSWORD_RECOVERY' | 'MFA_CHALLENGE_VERIFIED';
+/**
+ * Auth state change callback
+ */
+type AuthStateChangeCallback = (event: AuthChangeEvent, session: Session | null) => void;
+/**
+ * Sign up options (alias for SignUpCredentials)
+ */
+type SignUpOptions = SignUpCredentials;
+/**
+ * Sign in options (alias for SignInCredentials)
+ */
+type SignInOptions = SignInCredentials;
+/**
+ * OAuth sign in response
+ */
+interface OAuthResponse {
+    /**
+     * OAuth provider
+     */
+    provider: OAuthProvider;
+    /**
+     * Auth URL to redirect to
+     */
+    url: string;
+}
+
+/**
+ * VAIF Auth Client
+ *
+ * Authentication and user management for VAIF Studio projects
+ */
+
+/**
+ * Auth client for VAIF Studio
+ */
+declare class VaifAuth {
+    private client;
+    private currentSession;
+    private currentUser;
+    private stateChangeCallbacks;
+    private refreshTimeout;
+    constructor(client: VaifClient);
+    /**
+     * Get current session
+     */
+    getSession(): Promise<{
+        data: {
+            session: Session | null;
+        };
+        error: AuthError | null;
+    }>;
+    /**
+     * Get current user synchronously from cache
+     */
+    get user(): User | null;
+    /**
+     * Get current user (fetches fresh data)
+     */
+    getUser(): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: AuthError | null;
+    }>;
+    /**
+     * Sign up with email and password
+     */
+    signUp(options: SignUpOptions): Promise<AuthResponse>;
+    /**
+     * Sign in with email and password
+     */
+    signInWithPassword(options: SignInOptions): Promise<AuthResponse>;
+    /**
+     * Sign in with OAuth provider
+     */
+    signInWithOAuth(options: OAuthSignInOptions): Promise<{
+        data: OAuthResponse;
+        error: null;
+    }>;
+    /**
+     * Sign in with magic link (passwordless)
+     */
+    signInWithOtp(options: {
+        email?: string;
+        phone?: string;
+        createUser?: boolean;
+        redirectTo?: string;
+    }): Promise<{
+        data: {
+            messageId?: string;
+        };
+        error: AuthError | null;
+    }>;
+    /**
+     * Verify OTP code
+     */
+    verifyOtp(options: {
+        email?: string;
+        phone?: string;
+        token: string;
+        type: 'sms' | 'email' | 'magiclink';
+    }): Promise<AuthResponse>;
+    /**
+     * Sign out
+     */
+    signOut(options?: {
+        scope?: 'global' | 'local' | 'others';
+    }): Promise<{
+        error: AuthError | null;
+    }>;
+    /**
+     * Reset password
+     */
+    resetPasswordForEmail(options: ResetPasswordOptions): Promise<{
+        error: AuthError | null;
+    }>;
+    /**
+     * Update user
+     */
+    updateUser(options: UpdateUserOptions): Promise<{
+        data: {
+            user: User | null;
+        };
+        error: AuthError | null;
+    }>;
+    /**
+     * Refresh session
+     */
+    refreshSession(): Promise<AuthResponse>;
+    /**
+     * Set session from URL (after OAuth redirect)
+     */
+    setSessionFromUrl(): Promise<AuthResponse>;
+    /**
+     * Subscribe to auth state changes
+     */
+    onAuthStateChange(callback: AuthStateChangeCallback): {
+        data: {
+            subscription: {
+                unsubscribe: () => void;
+            };
+        };
+    };
+    /**
+     * Exchange code for session (PKCE flow)
+     */
+    exchangeCodeForSession(code: string): Promise<AuthResponse>;
+    /**
+     * Resend confirmation email
+     */
+    resend(options: {
+        type: 'signup' | 'email_change';
+        email: string;
+        redirectTo?: string;
+    }): Promise<{
+        error: AuthError | null;
+    }>;
+    private setSession;
+    private clearSession;
+    private restoreSession;
+    private scheduleRefresh;
+    private notifyStateChange;
+}
+
+/**
+ * AI types for VAIF Studio
+ */
+/**
+ * Copilot model tiers
+ */
+type CopilotModel = 'copilot-quick' | 'copilot-balanced' | 'copilot-power' | 'copilot-enterprise';
+/**
+ * AI generation options
+ */
+interface AIGenerateOptions {
+    /**
+     * Copilot model tier to use
+     */
+    model?: CopilotModel;
+    /**
+     * Temperature (0-1)
+     */
+    temperature?: number;
+    /**
+     * Maximum tokens
+     */
+    maxTokens?: number;
+    /**
+     * Stream response
+     */
+    stream?: boolean;
+}
+/**
+ * Schema generation request
+ */
+interface SchemaGenerationRequest {
+    /**
+     * Natural language description
+     */
+    prompt: string;
+    /**
+     * Target schema format
+     */
+    format?: 'drizzle' | 'prisma' | 'sql' | 'json';
+    /**
+     * Include relationships
+     */
+    includeRelations?: boolean;
+    /**
+     * Include indexes
+     */
+    includeIndexes?: boolean;
+    /**
+     * Database type
+     */
+    database?: 'postgresql' | 'mysql' | 'sqlite';
+}
+/**
+ * Schema generation result
+ */
+interface SchemaGenerationResult {
+    /**
+     * Generated schema code
+     */
+    schema: string;
+    /**
+     * Schema format
+     */
+    format: string;
+    /**
+     * Extracted tables
+     */
+    tables: GeneratedTable[];
+    /**
+     * Generated TypeScript types
+     */
+    types?: string;
+    /**
+     * Explanation of the schema
+     */
+    explanation?: string;
+    /**
+     * Credits used
+     */
+    creditsUsed: number;
+}
+/**
+ * Generated table information
+ */
+interface GeneratedTable {
+    /**
+     * Table name
+     */
+    name: string;
+    /**
+     * Table columns
+     */
+    columns: GeneratedColumn[];
+    /**
+     * Table indexes
+     */
+    indexes?: GeneratedIndex[];
+    /**
+     * Foreign key relationships
+     */
+    relations?: GeneratedRelation[];
+}
+/**
+ * Generated column
+ */
+interface GeneratedColumn {
+    /**
+     * Column name
+     */
+    name: string;
+    /**
+     * Column type
+     */
+    type: string;
+    /**
+     * Is nullable
+     */
+    nullable: boolean;
+    /**
+     * Is primary key
+     */
+    primaryKey: boolean;
+    /**
+     * Is unique
+     */
+    unique: boolean;
+    /**
+     * Default value
+     */
+    defaultValue?: string;
+}
+/**
+ * Generated index
+ */
+interface GeneratedIndex {
+    /**
+     * Index name
+     */
+    name: string;
+    /**
+     * Index columns
+     */
+    columns: string[];
+    /**
+     * Is unique index
+     */
+    unique: boolean;
+}
+/**
+ * Generated relation
+ */
+interface GeneratedRelation {
+    /**
+     * Relation name
+     */
+    name: string;
+    /**
+     * Target table
+     */
+    targetTable: string;
+    /**
+     * Source columns
+     */
+    sourceColumns: string[];
+    /**
+     * Target columns
+     */
+    targetColumns: string[];
+    /**
+     * Relation type
+     */
+    type: 'one-to-one' | 'one-to-many' | 'many-to-many';
+}
+/**
+ * Function generation request
+ */
+interface FunctionGenerationRequest {
+    /**
+     * Natural language description
+     */
+    prompt: string;
+    /**
+     * Function name
+     */
+    name?: string;
+    /**
+     * Runtime environment
+     */
+    runtime?: 'edge' | 'node';
+    /**
+     * Include types
+     */
+    includeTypes?: boolean;
+}
+/**
+ * Function generation result
+ */
+interface FunctionGenerationResult {
+    /**
+     * Generated function code
+     */
+    code: string;
+    /**
+     * Function name
+     */
+    name: string;
+    /**
+     * TypeScript types
+     */
+    types?: string;
+    /**
+     * Input schema
+     */
+    inputSchema?: Record<string, unknown>;
+    /**
+     * Output schema
+     */
+    outputSchema?: Record<string, unknown>;
+    /**
+     * Explanation
+     */
+    explanation?: string;
+    /**
+     * Credits used
+     */
+    creditsUsed: number;
+}
+/**
+ * Endpoint generation request
+ */
+interface EndpointGenerationRequest {
+    /**
+     * Natural language description
+     */
+    prompt: string;
+    /**
+     * HTTP method
+     */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /**
+     * Endpoint path
+     */
+    path?: string;
+    /**
+     * Include authentication
+     */
+    requiresAuth?: boolean;
+    /**
+     * Include validation
+     */
+    includeValidation?: boolean;
+}
+/**
+ * Endpoint generation result
+ */
+interface EndpointGenerationResult {
+    /**
+     * Generated endpoint code
+     */
+    code: string;
+    /**
+     * HTTP method
+     */
+    method: string;
+    /**
+     * Endpoint path
+     */
+    path: string;
+    /**
+     * Request schema
+     */
+    requestSchema?: Record<string, unknown>;
+    /**
+     * Response schema
+     */
+    responseSchema?: Record<string, unknown>;
+    /**
+     * OpenAPI spec
+     */
+    openApiSpec?: Record<string, unknown>;
+    /**
+     * Explanation
+     */
+    explanation?: string;
+    /**
+     * Credits used
+     */
+    creditsUsed: number;
+}
+/**
+ * AI chat message
+ */
+interface AIChatMessage {
+    /**
+     * Message role
+     */
+    role: 'user' | 'assistant' | 'system';
+    /**
+     * Message content
+     */
+    content: string;
+}
+/**
+ * AI chat request
+ */
+interface AIChatRequest {
+    /**
+     * Chat messages
+     */
+    messages: AIChatMessage[];
+    /**
+     * Context about the project
+     */
+    context?: {
+        /**
+         * Schema context
+         */
+        schema?: string;
+        /**
+         * Functions context
+         */
+        functions?: string[];
+        /**
+         * Endpoints context
+         */
+        endpoints?: string[];
+    };
+}
+/**
+ * AI chat response
+ */
+interface AIChatResponse {
+    /**
+     * Response message
+     */
+    message: AIChatMessage;
+    /**
+     * Suggested actions
+     */
+    suggestions?: AISuggestion[];
+    /**
+     * Credits used
+     */
+    creditsUsed: number;
+}
+/**
+ * AI suggestion
+ */
+interface AISuggestion {
+    /**
+     * Suggestion type
+     */
+    type: 'schema' | 'function' | 'endpoint' | 'query';
+    /**
+     * Suggestion title
+     */
+    title: string;
+    /**
+     * Suggestion description
+     */
+    description: string;
+    /**
+     * Prompt to execute suggestion
+     */
+    prompt: string;
+}
+/**
+ * AI credits info
+ */
+interface AICreditsInfo {
+    /**
+     * Current credits balance
+     */
+    balance: number;
+    /**
+     * Monthly allocation
+     */
+    monthlyAllocation: number;
+    /**
+     * Credits used this month
+     */
+    usedThisMonth: number;
+    /**
+     * Reset date
+     */
+    resetDate: string;
+}
+
+/**
+ * VAIF AI Client
+ *
+ * AI-powered code generation for schemas, functions, and endpoints
+ */
+
+/**
+ * AI error
+ */
+interface AIError {
+    message: string;
+    code?: string;
+    status?: number;
+}
+/**
+ * AI client for VAIF Studio
+ */
+declare class VaifAI {
+    private client;
+    constructor(client: VaifClient);
+    /**
+     * Generate database schema from natural language
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await vaif.ai.generateSchema({
+     *   prompt: 'Create a blog with posts, authors, and comments',
+     *   format: 'drizzle',
+     *   includeRelations: true
+     * });
+     * ```
+     */
+    generateSchema(request: SchemaGenerationRequest, options?: AIGenerateOptions): Promise<{
+        data: SchemaGenerationResult | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Generate edge function from natural language
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await vaif.ai.generateFunction({
+     *   prompt: 'Create a function that sends welcome emails to new users',
+     *   name: 'send-welcome-email',
+     *   runtime: 'edge'
+     * });
+     * ```
+     */
+    generateFunction(request: FunctionGenerationRequest, options?: AIGenerateOptions): Promise<{
+        data: FunctionGenerationResult | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Generate API endpoint from natural language
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await vaif.ai.generateEndpoint({
+     *   prompt: 'Create an endpoint to get user profile with their recent posts',
+     *   method: 'GET',
+     *   path: '/users/:id/profile',
+     *   requiresAuth: true
+     * });
+     * ```
+     */
+    generateEndpoint(request: EndpointGenerationRequest, options?: AIGenerateOptions): Promise<{
+        data: EndpointGenerationResult | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Chat with AI assistant for project help
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await vaif.ai.chat({
+     *   messages: [
+     *     { role: 'user', content: 'How do I add pagination to my posts query?' }
+     *   ],
+     *   context: {
+     *     schema: mySchemaString
+     *   }
+     * });
+     * ```
+     */
+    chat(request: AIChatRequest, options?: AIGenerateOptions): Promise<{
+        data: AIChatResponse | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Stream chat response
+     *
+     * @example
+     * ```typescript
+     * for await (const chunk of vaif.ai.chatStream({
+     *   messages: [{ role: 'user', content: 'Explain this schema' }]
+     * })) {
+     *   process.stdout.write(chunk);
+     * }
+     * ```
+     */
+    chatStream(request: AIChatRequest, options?: AIGenerateOptions): AsyncGenerator<string, void, unknown>;
+    /**
+     * Get AI credits information
+     *
+     * @example
+     * ```typescript
+     * const { data, error } = await vaif.ai.getCredits();
+     * console.log(`Balance: ${data.balance} credits`);
+     * ```
+     */
+    getCredits(): Promise<{
+        data: AICreditsInfo | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Explain code or schema
+     */
+    explain(code: string, options?: {
+        language?: string;
+        context?: string;
+    } & AIGenerateOptions): Promise<{
+        data: {
+            explanation: string;
+            creditsUsed: number;
+        } | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Review code for issues and improvements
+     */
+    review(code: string, options?: {
+        language?: string;
+        focus?: ('security' | 'performance' | 'style')[];
+    } & AIGenerateOptions): Promise<{
+        data: {
+            issues: Array<{
+                severity: 'error' | 'warning' | 'info';
+                message: string;
+                line?: number;
+                suggestion?: string;
+            }>;
+            summary: string;
+            creditsUsed: number;
+        } | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Generate TypeScript types from schema
+     */
+    generateTypes(schema: string, options?: {
+        format?: 'typescript' | 'zod' | 'io-ts';
+    } & AIGenerateOptions): Promise<{
+        data: {
+            types: string;
+            creditsUsed: number;
+        } | null;
+        error: AIError | null;
+    }>;
+    /**
+     * Generate SQL migration from schema diff
+     */
+    generateMigration(options: {
+        currentSchema: string;
+        targetSchema: string;
+        database?: 'postgresql' | 'mysql' | 'sqlite';
+    } & AIGenerateOptions): Promise<{
+        data: {
+            upMigration: string;
+            downMigration: string;
+            changes: string[];
+            creditsUsed: number;
+        } | null;
+        error: AIError | null;
+    }>;
+}
+
+/**
+ * VAIF Type Generator
+ *
+ * Generate TypeScript types from database schema.
+ */
+
+interface ColumnSchema {
+    name: string;
+    type: string;
+    nullable: boolean;
+    defaultValue?: string;
+    isPrimaryKey: boolean;
+    isForeignKey: boolean;
+    foreignTable?: string;
+    foreignColumn?: string;
+    isUnique: boolean;
+    comment?: string;
+}
+interface TableSchema {
+    name: string;
+    schema: string;
+    columns: ColumnSchema[];
+    primaryKey: string[];
+    foreignKeys: ForeignKeySchema[];
+    indexes: IndexSchema[];
+    comment?: string;
+}
+interface ForeignKeySchema {
+    name: string;
+    columns: string[];
+    foreignTable: string;
+    foreignColumns: string[];
+    onDelete: string;
+    onUpdate: string;
+}
+interface IndexSchema {
+    name: string;
+    columns: string[];
+    unique: boolean;
+    type: string;
+}
+interface DatabaseSchema {
+    tables: TableSchema[];
+    enums: EnumSchema[];
+    views: ViewSchema[];
+}
+interface EnumSchema {
+    name: string;
+    schema: string;
+    values: string[];
+}
+interface ViewSchema {
+    name: string;
+    schema: string;
+    columns: ColumnSchema[];
+}
+interface TypeGenOptions {
+    /** Include Row types (for SELECT) */
+    includeRow?: boolean;
+    /** Include Insert types (for INSERT) */
+    includeInsert?: boolean;
+    /** Include Update types (for UPDATE) */
+    includeUpdate?: boolean;
+    /** Include relationships */
+    includeRelationships?: boolean;
+    /** Schema to generate types for */
+    schema?: string;
+    /** Tables to include (all if empty) */
+    tables?: string[];
+    /** Tables to exclude */
+    excludeTables?: string[];
+    /** Add JSDoc comments */
+    includeComments?: boolean;
+    /** Export format */
+    exportFormat?: 'named' | 'default' | 'namespace';
+    /** Namespace name (if exportFormat is 'namespace') */
+    namespace?: string;
+}
+/**
+ * VAIF Type Generator class
+ */
+declare class VaifTypeGen {
+    private client;
+    constructor(client: VaifClient);
+    /**
+     * Fetch database schema from the API.
+     */
+    fetchSchema(schema?: string): Promise<DatabaseSchema>;
+    /**
+     * Generate TypeScript types from schema.
+     */
+    generate(options?: TypeGenOptions): Promise<string>;
+    /**
+     * Generate TypeScript from schema JSON directly.
+     */
+    generateFromSchema(schema: DatabaseSchema, options?: TypeGenOptions): string;
+    private generateEnum;
+    private generateTableTypes;
+    private generateViewTypes;
+    private pgTypeToTs;
+    private toPascalCase;
+    private indent;
+}
+/**
+ * Create a type generator instance.
+ */
+declare function createTypeGen(client: VaifClient): VaifTypeGen;
+
+/**
+ * VAIF Studio Client
+ *
+ * Main entry point for the VAIF SDK
+ */
+
+/**
+ * Create a VAIF Studio client instance
+ *
+ * @example
+ * ```typescript
+ * const vaif = createClient({
+ *   projectId: 'your-project-id',
+ *   apiKey: 'your-api-key',
+ * });
+ * ```
+ */
+declare function createClient(options: VaifClientOptions): VaifClient;
+/**
+ * VAIF Studio Client
+ *
+ * Provides access to all VAIF services:
+ * - Database (db)
+ * - Realtime subscriptions (realtime)
+ * - Storage (storage)
+ * - Edge Functions (functions)
+ * - Authentication (auth)
+ * - AI Generation (ai)
+ */
+declare class VaifClient {
+    private config;
+    private accessToken;
+    /**
+     * Database client for CRUD operations
+     */
+    readonly db: VaifDatabase;
+    /**
+     * Realtime client for subscriptions
+     */
+    readonly realtime: VaifRealtime;
+    /**
+     * Storage client for file operations
+     */
+    readonly storage: VaifStorage;
+    /**
+     * Functions client for edge function invocation
+     */
+    readonly functions: VaifFunctions;
+    /**
+     * Auth client for authentication
+     */
+    readonly auth: VaifAuth;
+    /**
+     * AI client for generation features
+     */
+    readonly ai: VaifAI;
+    /**
+     * Type generator for generating TypeScript types from database schema
+     */
+    readonly typegen: VaifTypeGen;
+    constructor(options: VaifClientOptions);
+    /**
+     * Get current configuration
+     */
+    getConfig(): VaifConfig;
+    /**
+     * Set access token for authenticated requests
+     */
+    setAccessToken(token: string | null): void;
+    /**
+     * Get current access token
+     */
+    getAccessToken(): string | null;
+    /**
+     * Make an authenticated API request
+     */
+    request<T = unknown>(path: string, options?: RequestOptions): Promise<ApiResponse<T>>;
+    /**
+     * Restore session from storage
+     */
+    private restoreSession;
+    /**
+     * Log debug messages
+     */
+    debug(...args: unknown[]): void;
+}
+
+export { type AIGenerateOptions, type ApiError, type ApiResponse, type AuthOptions, type AuthResponse, type Bucket, type ColumnSchema, type DatabaseSchema, type DeleteQuery, type DownloadOptions, type EndpointGenerationResult, type EnumSchema, type FileObject, type FilterOperator, type ForeignKeySchema, type FunctionGenerationResult, type FunctionInvokeOptions, type FunctionResponse, type IndexSchema, type InsertQuery, type OrderDirection, type QueryBuilder$1 as QueryBuilder, RealtimeChannel, type RealtimeEvent, type RealtimeMessage, type RealtimeOptions, type RequestOptions, type SchemaGenerationResult, type SelectQuery, type Session, type SignInCredentials, type SignUpCredentials, type StorageOptions, type SubscriptionCallback, type TableSchema, type TypeGenOptions, type UpdateQuery, type UploadOptions, type User, VaifAI, VaifAuth, VaifClient, type VaifClientOptions, type VaifConfig, VaifDatabase, VaifFunctions, VaifRealtime, VaifStorage, VaifTypeGen, type ViewSchema, createClient, createTypeGen };