@blinkdotnew/sdk 0.10.4 → 0.10.6

package/dist/index.d.mts

@@ -1,5 +1,740 @@
-import { BlinkClientConfig, BlinkUser, AuthState, HttpClient, TableOperations, CreateOptions, UpsertOptions, QueryOptions, ListResponse, UpdateOptions, FilterCondition, ScrapeResult, FetchRequest, FetchResponse, AsyncFetchResponse, SearchResponse, BlinkStorage, BlinkAI, BlinkRealtime, BlinkNotifications, StorageUploadOptions, StorageUploadResponse, TextGenerationRequest, TextGenerationResponse, ObjectGenerationRequest, ObjectGenerationResponse, ImageGenerationRequest, ImageGenerationResponse, SpeechGenerationRequest, SpeechGenerationResponse, TranscriptionRequest, TranscriptionResponse, RealtimeChannel, RealtimeMessage, RealtimeSubscribeOptions, RealtimePublishOptions, PresenceUser } from '@blink/core';
-export { AuthState, AuthTokens, BlinkAI, BlinkClientConfig, BlinkRealtime, BlinkRealtimeError, BlinkStorage, BlinkUser, CreateOptions, DataExtraction, FileObject, FilterCondition, ImageGenerationRequest, ImageGenerationResponse, ListResponse, Message, ObjectGenerationRequest, ObjectGenerationResponse, PresenceUser, QueryOptions, RealtimeChannel, RealtimeGetMessagesOptions, RealtimeMessage, RealtimePublishOptions, RealtimeSubscribeOptions, SearchRequest, SearchResponse, SpeechGenerationRequest, SpeechGenerationResponse, StorageUploadOptions, StorageUploadResponse, TableOperations, TextGenerationRequest, TextGenerationResponse, TokenUsage, TranscriptionRequest, TranscriptionResponse, UpdateOptions, UpsertOptions } from '@blink/core';
+/**
+ * Core type definitions for Blink SDK
+ */
+interface BlinkClientConfig {
+    projectId: string;
+    authRequired?: boolean;
+}
+interface BlinkUser {
+    id: string;
+    email: string;
+    displayName?: string;
+    photoURL?: string;
+    emailVerified?: boolean;
+    createdAt?: string;
+    lastSignInAt?: string;
+}
+interface AuthTokens {
+    access_token: string;
+    refresh_token?: string;
+    token_type: 'Bearer';
+    expires_in: number;
+    refresh_expires_in?: number;
+    issued_at?: number;
+}
+interface AuthState {
+    user: BlinkUser | null;
+    tokens: AuthTokens | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+}
+interface FilterOperators {
+    eq?: any;
+    neq?: any;
+    gt?: any;
+    gte?: any;
+    lt?: any;
+    lte?: any;
+    in?: any[];
+    not_in?: any[];
+    like?: string;
+    ilike?: string;
+    is?: null | boolean;
+    not?: any;
+}
+interface LogicalOperators {
+    AND?: FilterCondition[];
+    OR?: FilterCondition[];
+}
+type FilterCondition = Record<string, any> | FilterOperators | LogicalOperators;
+interface QueryOptions {
+    where?: FilterCondition;
+    orderBy?: Record<string, 'asc' | 'desc'> | string;
+    limit?: number;
+    offset?: number;
+    cursor?: string;
+    select?: string[];
+}
+interface ListResponse<T = any> {
+    data: T[];
+    count?: number;
+    nextCursor?: string;
+    hasMore?: boolean;
+}
+interface CreateOptions {
+    returning?: boolean;
+}
+interface UpdateOptions {
+    returning?: boolean;
+}
+interface UpsertOptions {
+    onConflict?: string;
+    returning?: boolean;
+}
+interface TableOperations<T = any> {
+    create(data: Partial<T>, options?: CreateOptions): Promise<T>;
+    createMany(data: Partial<T>[], options?: CreateOptions): Promise<T[]>;
+    upsert(data: Partial<T>, options?: UpsertOptions): Promise<T>;
+    upsertMany(data: Partial<T>[], options?: UpsertOptions): Promise<T[]>;
+    get(id: string): Promise<T | null>;
+    list(options?: QueryOptions): Promise<ListResponse<T>>;
+    update(id: string, data: Partial<T>, options?: UpdateOptions): Promise<T>;
+    updateMany(updates: Array<{
+        id: string;
+    } & Partial<T>>, options?: UpdateOptions): Promise<T[]>;
+    delete(id: string): Promise<void>;
+    deleteMany(options: {
+        where: FilterCondition;
+    }): Promise<void>;
+    count(options?: {
+        where?: FilterCondition;
+    }): Promise<number>;
+    exists(options: {
+        where: FilterCondition;
+    }): Promise<boolean>;
+}
+declare class BlinkError extends Error {
+    code?: string | undefined;
+    status?: number | undefined;
+    details?: any;
+    constructor(message: string, code?: string | undefined, status?: number | undefined, details?: any);
+}
+interface StorageUploadOptions {
+    upsert?: boolean;
+    onProgress?: (percent: number) => void;
+}
+interface StorageUploadResponse {
+    publicUrl: string;
+}
+interface FileObject {
+    id: string;
+    name: string;
+    bucket_id: string;
+    owner?: string | null;
+    owner_id?: string | null;
+    version?: string | null;
+    created_at: string;
+    updated_at: string;
+    last_accessed_at: string;
+    metadata: {
+        size: number;
+        mimetype: string;
+        cacheControl?: string;
+    };
+    user_metadata?: Record<string, any>;
+}
+interface BlinkStorage {
+    upload(file: File | Blob | Buffer, path: string, options?: StorageUploadOptions): Promise<StorageUploadResponse>;
+    remove(...paths: string[]): Promise<void>;
+}
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+interface TextContent {
+    type: 'text';
+    text: string;
+}
+interface ImageContent {
+    type: 'image';
+    image: string;
+}
+type MessageContent = TextContent | ImageContent;
+interface Message {
+    role: 'system' | 'user' | 'assistant';
+    content: string | MessageContent[];
+}
+interface TextGenerationRequest {
+    model?: string;
+    prompt?: string;
+    messages?: Message[];
+    stream?: boolean;
+    search?: boolean;
+    maxSteps?: number;
+    experimental_continueSteps?: boolean;
+    maxTokens?: number;
+    temperature?: number;
+    signal?: AbortSignal;
+}
+interface TextGenerationResponse {
+    text: string;
+    finishReason?: 'stop' | 'length' | 'content_filter' | 'tool_calls';
+    usage?: TokenUsage;
+    files?: any[];
+    reasoningDetails?: any[];
+    toolCalls?: any[];
+    toolResults?: any[];
+    warnings?: string[];
+    request?: {
+        body?: string;
+    };
+    response?: any;
+    steps?: Array<{
+        stepType?: string;
+        text?: string;
+        finishReason?: string;
+        usage?: TokenUsage;
+    }>;
+    sources?: any[];
+    providerMetadata?: any;
+    experimental_providerMetadata?: any;
+}
+interface ObjectGenerationRequest {
+    model?: string;
+    prompt: string;
+    output?: 'object' | 'array' | 'enum';
+    schema?: any;
+    enum?: string[];
+    stream?: boolean;
+    signal?: AbortSignal;
+}
+interface ObjectGenerationResponse {
+    object: any;
+    finishReason?: 'stop' | 'length' | 'content_filter';
+    usage?: TokenUsage;
+    warnings?: string[];
+    providerMetadata?: {
+        openai?: {
+            reasoningTokens?: number;
+            acceptedPredictionTokens?: number;
+            rejectedPredictionTokens?: number;
+            cachedPromptTokens?: number;
+        };
+    };
+    experimental_providerMetadata?: any;
+    response?: {
+        id?: string;
+        timestamp?: string;
+        modelId?: string;
+        headers?: any;
+        body?: any;
+    };
+    request?: {
+        body?: string;
+    };
+}
+interface ImageGenerationRequest {
+    model?: string;
+    prompt: string;
+    size?: string;
+    quality?: 'standard' | 'hd';
+    n?: number;
+    response_format?: 'url' | 'b64_json';
+    signal?: AbortSignal;
+}
+interface ImageGenerationResponse {
+    data: Array<{
+        url?: string;
+        b64_json?: string;
+    }>;
+}
+interface SpeechGenerationRequest {
+    model?: string;
+    text: string;
+    voice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+    response_format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+    speed?: number;
+    signal?: AbortSignal;
+}
+interface SpeechGenerationResponse {
+    url: string;
+    voice: string;
+    format: string;
+    mimeType: string;
+}
+interface TranscriptionRequest {
+    model?: string;
+    audio: string | number[];
+    language?: string;
+    response_format?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt';
+    signal?: AbortSignal;
+}
+interface TranscriptionResponse {
+    text: string;
+    transcript?: string;
+    segments?: Array<{
+        id: number;
+        seek: number;
+        start: number;
+        end: number;
+        text: string;
+        tokens: number[];
+        temperature: number;
+        avg_logprob: number;
+        compression_ratio: number;
+        no_speech_prob: number;
+    }>;
+    language?: string;
+    duration?: number;
+    words?: Array<{
+        word: string;
+        start: number;
+        end: number;
+    }>;
+}
+interface BlinkAI {
+    generateText(options: TextGenerationRequest): Promise<TextGenerationResponse>;
+    streamText(options: TextGenerationRequest, onChunk: (chunk: string) => void): Promise<TextGenerationResponse>;
+    generateObject(options: ObjectGenerationRequest): Promise<ObjectGenerationResponse>;
+    streamObject(options: ObjectGenerationRequest, onPartial: (partial: any) => void): Promise<ObjectGenerationResponse>;
+    generateImage(options: ImageGenerationRequest): Promise<ImageGenerationResponse>;
+    generateSpeech(options: SpeechGenerationRequest): Promise<SpeechGenerationResponse>;
+    transcribeAudio(options: TranscriptionRequest): Promise<TranscriptionResponse>;
+}
+interface DataExtraction {
+    chunks: string[];
+}
+interface ExtractFromUrlRequest {
+    url: string;
+    chunking?: boolean;
+    chunkSize?: number;
+}
+interface ExtractFromUrlResponse {
+    chunks?: string[];
+    text?: string;
+}
+interface ExtractFromBlobResponse {
+    chunks?: string[];
+    text?: string;
+}
+interface ScrapeRequest {
+    url: string;
+    formats?: ('markdown' | 'html' | 'rawHtml' | 'links' | 'extract' | 'metadata')[];
+}
+interface ScrapeResponse {
+    markdown?: string;
+    html?: string;
+    rawHtml?: string;
+    links?: Array<{
+        text: string;
+        url: string;
+        type: string;
+    }>;
+    extract?: {
+        title?: string;
+        description?: string;
+        headings?: string[];
+        text?: string;
+    };
+    metadata?: {
+        title?: string;
+        description?: string;
+        url?: string;
+        domain?: string;
+        favicon?: string;
+        image?: string;
+        author?: string;
+        publishedTime?: string;
+        modifiedTime?: string;
+        type?: string;
+        siteName?: string;
+        locale?: string;
+        keywords?: string[];
+    };
+}
+interface ScrapeResult {
+    markdown: string;
+    html: string;
+    metadata: {
+        title: string;
+        description: string;
+        url: string;
+        domain: string;
+        favicon?: string;
+        image?: string;
+        author?: string;
+        publishedTime?: string;
+        modifiedTime?: string;
+        type?: string;
+        siteName?: string;
+        locale?: string;
+        keywords?: string[];
+    };
+    links: Array<{
+        text: string;
+        url: string;
+        type: string;
+    }>;
+    extract: {
+        title: string;
+        description: string;
+        headings: string[];
+        text: string;
+    };
+}
+interface ScreenshotRequest {
+    url: string;
+    fullPage?: boolean;
+    width?: number;
+    height?: number;
+}
+interface ScreenshotResponse {
+    url: string;
+}
+interface FetchRequest {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    query?: Record<string, string>;
+    async?: boolean;
+}
+interface FetchResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: any;
+    durationMs: number;
+}
+interface AsyncFetchResponse {
+    status: 'triggered';
+    message: string;
+}
+interface SearchRequest {
+    q: string;
+    location?: string;
+    hl?: string;
+    tbm?: string;
+    num?: number;
+}
+interface SearchResponse {
+    organic_results: Array<{
+        position: number;
+        title: string;
+        link: string;
+        snippet: string;
+    }>;
+    total_results?: string;
+    related_searches?: string[];
+    people_also_ask?: Array<{
+        question: string;
+        snippet: string;
+        link: string;
+    }>;
+    local_results?: Array<{
+        title: string;
+        address: string;
+        rating: number;
+        reviews: number;
+        phone?: string;
+    }>;
+    ads?: Array<{
+        title: string;
+        link: string;
+        snippet: string;
+    }>;
+    shopping_results?: Array<{
+        title: string;
+        price: string;
+        source: string;
+        link: string;
+    }>;
+    news_results?: Array<{
+        title: string;
+        link: string;
+        snippet: string;
+        date: string;
+        source: string;
+    }>;
+    image_results?: Array<{
+        title: string;
+        link: string;
+        original: string;
+        thumbnail: string;
+    }>;
+}
+interface RealtimeMessage {
+    id: string;
+    type: string;
+    data: any;
+    timestamp: number;
+    userId?: string;
+    metadata?: Record<string, any>;
+}
+interface PresenceUser {
+    userId: string;
+    metadata?: Record<string, any>;
+    joinedAt: number;
+    lastSeen: number;
+}
+interface RealtimeChannel {
+    subscribe(options?: {
+        userId?: string;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    unsubscribe(): Promise<void>;
+    publish(type: string, data: any, options?: {
+        userId?: string;
+        metadata?: Record<string, any>;
+    }): Promise<string>;
+    onMessage(callback: (message: RealtimeMessage) => void): () => void;
+    onPresence(callback: (users: PresenceUser[]) => void): () => void;
+    getPresence(): Promise<PresenceUser[]>;
+    getMessages(options?: {
+        limit?: number;
+        before?: string;
+        after?: string;
+    }): Promise<RealtimeMessage[]>;
+}
+interface RealtimeSubscribeOptions {
+    userId?: string;
+    metadata?: Record<string, any>;
+}
+interface RealtimePublishOptions {
+    userId?: string;
+    metadata?: Record<string, any>;
+}
+interface RealtimeGetMessagesOptions {
+    limit?: number;
+    before?: string;
+    after?: string;
+}
+interface BlinkRealtime {
+    channel(name: string): RealtimeChannel;
+    subscribe(channelName: string, callback: (message: RealtimeMessage) => void, options?: RealtimeSubscribeOptions): Promise<() => void>;
+    publish(channelName: string, type: string, data: any, options?: RealtimePublishOptions): Promise<string>;
+    presence(channelName: string): Promise<PresenceUser[]>;
+    onPresence(channelName: string, callback: (users: PresenceUser[]) => void): () => void;
+}
+declare class BlinkRealtimeError extends BlinkError {
+    constructor(message: string, status?: number, details?: any);
+}
+interface SendEmailAttachment {
+    filename: string;
+    url: string;
+    type?: string;
+    content?: string;
+    disposition?: 'attachment' | 'inline';
+    cid?: string;
+}
+interface SendEmailRequest {
+    to: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+    from?: string;
+    replyTo?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    attachments?: SendEmailAttachment[];
+}
+interface SendEmailResponse {
+    success: boolean;
+    messageId: string;
+}
+interface BlinkNotifications {
+    email(params: SendEmailRequest): Promise<SendEmailResponse>;
+}
+
+/**
+ * HTTP client for Blink API requests
+ * Handles authentication, error handling, and request/response processing
+ */
+
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: any;
+    searchParams?: Record<string, string>;
+    signal?: AbortSignal;
+}
+interface BlinkResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Headers;
+}
+declare class HttpClient {
+    private readonly authUrl;
+    private readonly coreUrl;
+    readonly projectId: string;
+    private getToken;
+    private getValidToken?;
+    constructor(config: BlinkClientConfig, getToken: () => string | null, getValidToken?: () => Promise<string | null>);
+    /**
+     * Make an authenticated request to the Blink API
+     */
+    request<T = any>(path: string, options?: RequestOptions): Promise<BlinkResponse<T>>;
+    /**
+     * GET request
+     */
+    get<T = any>(path: string, searchParams?: Record<string, string>): Promise<BlinkResponse<T>>;
+    /**
+     * POST request
+     */
+    post<T = any>(path: string, body?: any, headers?: Record<string, string>): Promise<BlinkResponse<T>>;
+    /**
+     * PATCH request
+     */
+    patch<T = any>(path: string, body?: any, headers?: Record<string, string>): Promise<BlinkResponse<T>>;
+    /**
+     * DELETE request
+     */
+    delete<T = any>(path: string, searchParams?: Record<string, string>): Promise<BlinkResponse<T>>;
+    /**
+     * Database-specific requests
+     */
+    dbGet<T = any>(table: string, searchParams?: Record<string, string>): Promise<BlinkResponse<T[]>>;
+    dbPost<T = any>(table: string, body: any, options?: {
+        returning?: boolean;
+    }): Promise<BlinkResponse<T | T[]>>;
+    dbPatch<T = any>(table: string, body: any, searchParams?: Record<string, string>, options?: {
+        returning?: boolean;
+    }): Promise<BlinkResponse<T[]>>;
+    dbDelete<T = any>(table: string, searchParams?: Record<string, string>, options?: {
+        returning?: boolean;
+    }): Promise<BlinkResponse<T[]>>;
+    dbSql<T = any>(query: string, params?: any[]): Promise<BlinkResponse<{
+        rows: T[];
+        columns: string[];
+        rowCount: number;
+        executionTime: number;
+    }>>;
+    dbBatch<T = any>(statements: Array<{
+        sql: string;
+        args?: any[];
+    }>, mode?: 'read' | 'write'): Promise<BlinkResponse<{
+        results: Array<{
+            rows: T[];
+            columns: string[];
+            rowCount: number;
+        }>;
+        executionTime: number;
+        success: boolean;
+    }>>;
+    /**
+     * Upload file with progress tracking
+     */
+    uploadFile(path: string, file: File | Blob | Buffer, filePath: string, options?: {
+        upsert?: boolean;
+        onProgress?: (percent: number) => void;
+    }): Promise<BlinkResponse<any>>;
+    /**
+     * Upload with progress tracking using XMLHttpRequest
+     */
+    private uploadWithProgress;
+    /**
+     * AI-specific requests
+     */
+    aiText(prompt: string, options?: {
+        model?: string;
+        messages?: Array<{
+            role: string;
+            content: string | any[];
+        }>;
+        stream?: boolean;
+        search?: boolean;
+        maxSteps?: number;
+        experimental_continueSteps?: boolean;
+        maxTokens?: number;
+        temperature?: number;
+        signal?: AbortSignal;
+    }): Promise<BlinkResponse<any>>;
+    /**
+     * Stream AI text generation with Vercel AI SDK data stream format
+     */
+    streamAiText(prompt: string, options: {
+        model?: string | undefined;
+        messages?: {
+            role: string;
+            content: string | any[];
+        }[] | undefined;
+        search?: boolean | undefined;
+        maxSteps?: number | undefined;
+        experimental_continueSteps?: boolean | undefined;
+        maxTokens?: number | undefined;
+        temperature?: number | undefined;
+        signal?: AbortSignal | undefined;
+    } | undefined, onChunk: (chunk: string) => void): Promise<any>;
+    aiObject(prompt: string, options?: {
+        model?: string;
+        output?: 'object' | 'array' | 'enum';
+        schema?: any;
+        enum?: string[];
+        stream?: boolean;
+        signal?: AbortSignal;
+    }): Promise<BlinkResponse<any>>;
+    /**
+     * Stream AI object generation with Vercel AI SDK data stream format
+     */
+    streamAiObject(prompt: string, options: {
+        model?: string | undefined;
+        output?: "object" | "array" | "enum" | undefined;
+        schema?: any;
+        enum?: string[] | undefined;
+        signal?: AbortSignal | undefined;
+    } | undefined, onPartial: (partial: any) => void): Promise<any>;
+    aiImage(prompt: string, options?: {
+        model?: string;
+        size?: string;
+        quality?: 'standard' | 'hd';
+        n?: number;
+        response_format?: 'url' | 'b64_json';
+        signal?: AbortSignal;
+    }): Promise<BlinkResponse<any>>;
+    aiSpeech(text: string, options?: {
+        model?: string;
+        voice?: string;
+        response_format?: string;
+        speed?: number;
+        signal?: AbortSignal;
+    }): Promise<BlinkResponse<any>>;
+    aiTranscribe(audio: string | number[], options?: {
+        model?: string;
+        language?: string;
+        response_format?: string;
+        signal?: AbortSignal;
+    }): Promise<BlinkResponse<any>>;
+    /**
+     * Data-specific requests
+     */
+    dataExtractFromUrl(projectId: string, request: ExtractFromUrlRequest): Promise<BlinkResponse<ExtractFromUrlResponse>>;
+    dataExtractFromBlob(projectId: string, file: File, chunking?: boolean, chunkSize?: number): Promise<BlinkResponse<ExtractFromBlobResponse>>;
+    dataScrape(projectId: string, request: ScrapeRequest): Promise<BlinkResponse<ScrapeResponse>>;
+    dataScreenshot(projectId: string, request: ScreenshotRequest): Promise<BlinkResponse<ScreenshotResponse>>;
+    dataFetch(projectId: string, request: FetchRequest): Promise<BlinkResponse<FetchResponse | AsyncFetchResponse>>;
+    dataSearch(projectId: string, request: SearchRequest): Promise<BlinkResponse<SearchResponse>>;
+    /**
+     * Realtime-specific requests
+     */
+    realtimePublish(projectId: string, request: {
+        channel: string;
+        type: string;
+        data: any;
+        userId?: string;
+        metadata?: Record<string, any>;
+    }): Promise<BlinkResponse<{
+        messageId: string;
+        channel: string;
+        timestamp: number;
+    }>>;
+    realtimeGetPresence(projectId: string, channel: string): Promise<BlinkResponse<{
+        channel: string;
+        users: any[];
+        count: number;
+    }>>;
+    realtimeGetMessages(projectId: string, options: {
+        channel: string;
+        limit?: number;
+        start?: string;
+        end?: string;
+    }): Promise<BlinkResponse<{
+        channel: string;
+        messages: any[];
+        count: number;
+        hasMore: boolean;
+    }>>;
+    /**
+     * Private helper methods
+     */
+    private buildUrl;
+    private parseResponse;
+    private handleErrorResponse;
+    /**
+     * Parse Vercel AI SDK data stream format
+     * Handles text chunks (0:"text"), partial objects (2:[...]), and metadata (d:, e:)
+     */
+    private parseDataStream;
+}
 
 /**
  * Blink Auth Module - Client-side authentication management
@@ -810,4 +1545,4 @@ declare class BlinkRealtimeImpl implements BlinkRealtime {
     onPresence(channelName: string, callback: (users: PresenceUser[]) => void): () => void;
 }
 
-export { type AnalyticsEvent, type AuthStateChangeCallback, BlinkAIImpl, type BlinkAnalytics, BlinkAnalyticsImpl, type BlinkClient, type BlinkData, BlinkDataImpl, BlinkDatabase, BlinkRealtimeChannel, BlinkRealtimeImpl, BlinkStorageImpl, BlinkTable, createClient };
+export { type AnalyticsEvent, type AuthState, type AuthStateChangeCallback, type AuthTokens, type BlinkAI, BlinkAIImpl, type BlinkAnalytics, BlinkAnalyticsImpl, type BlinkClient, type BlinkClientConfig, type BlinkData, BlinkDataImpl, BlinkDatabase, type BlinkRealtime, BlinkRealtimeChannel, BlinkRealtimeError, BlinkRealtimeImpl, type BlinkStorage, BlinkStorageImpl, BlinkTable, type BlinkUser, type CreateOptions, type DataExtraction, type FileObject, type FilterCondition, type ImageGenerationRequest, type ImageGenerationResponse, type ListResponse, type Message, type ObjectGenerationRequest, type ObjectGenerationResponse, type PresenceUser, type QueryOptions, type RealtimeChannel, type RealtimeGetMessagesOptions, type RealtimeMessage, type RealtimePublishOptions, type RealtimeSubscribeOptions, type SearchRequest, type SearchResponse, type SpeechGenerationRequest, type SpeechGenerationResponse, type StorageUploadOptions, type StorageUploadResponse, type TableOperations, type TextGenerationRequest, type TextGenerationResponse, type TokenUsage, type TranscriptionRequest, type TranscriptionResponse, type UpdateOptions, type UpsertOptions, createClient };