@omnikit-ai/sdk 2.0.3

package/dist/index.d.mts

@@ -0,0 +1,1471 @@
+export { cleanTokenFromUrl, getAccessToken, isTokenInUrl, removeAccessToken, saveAccessToken, setAccessToken } from './auth-utils.mjs';
+
+/**
+ * Omnikit SDK Type Definitions v2.0
+ */
+/**
+ * Configuration for creating an Omnikit client
+ */
+/**
+ * Initial app metadata for instant display (no API call, no flicker).
+ * Pass build-time values here for immediate rendering.
+ */
+interface InitialMetadata {
+    name?: string;
+    logoUrl?: string;
+    thumbnailUrl?: string;
+}
+interface OmnikitConfig {
+    /** App ID (required) */
+    appId: string;
+    /**
+     * API base URL
+     * @default 'https://api.omnikit.ai/api'
+     */
+    baseUrl?: string;
+    /**
+     * Alias for baseUrl
+     * @default 'https://api.omnikit.ai/api'
+     */
+    serverUrl?: string;
+    /**
+     * User access token (optional)
+     * If not provided, will auto-detect from URL or localStorage
+     */
+    token?: string;
+    /**
+     * Service role token for elevated admin operations (optional)
+     * When provided, enables asServiceRole operations
+     */
+    serviceToken?: string;
+    /**
+     * API key for server-to-server authentication (optional)
+     * Used in backend functions (Deno Edge Functions) where user auth isn't needed.
+     * Takes precedence over serviceToken if both are provided.
+     */
+    apiKey?: string;
+    /**
+     * Auto-detect and load token from URL params or localStorage
+     * @default true
+     */
+    autoInitAuth?: boolean;
+    /**
+     * Initial app metadata for instant display (no flicker).
+     * Values are cached in localStorage and auto-refreshed from server.
+     */
+    initialMetadata?: InitialMetadata;
+}
+interface CollectionField {
+    name: string;
+    display_name?: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'email' | 'enum' | 'reference' | 'reference_array';
+    required?: boolean;
+    unique?: boolean;
+    default?: any;
+    reference_collection?: string;
+    /** @deprecated Use reference_collection instead */
+    reference_entity?: string;
+    enum_values?: string[];
+    is_display?: boolean;
+}
+/** @deprecated Use CollectionField instead */
+type EntityField = CollectionField;
+interface CollectionDefinition {
+    name: string;
+    display_name?: string;
+    description?: string;
+    fields: CollectionField[];
+    rls?: {
+        read?: string;
+        write?: string;
+        update?: string;
+        delete?: string;
+    };
+}
+/** @deprecated Use CollectionDefinition instead */
+type EntityDefinition = CollectionDefinition;
+interface AppMetadata {
+    id: string;
+    name: string;
+    description?: string;
+    created_date?: string;
+    updated_date?: string;
+    logo_url?: string;
+    logo_file_id?: string;
+    thumbnail_url?: string;
+    slug?: string;
+    domain?: string;
+    visibility?: string;
+    auth_settings?: {
+        platform_auth_providers?: string[];
+    };
+}
+interface AppSchema {
+    app: AppMetadata;
+    entities: CollectionDefinition[] | Record<string, CollectionDefinition>;
+    integrations?: Record<string, any>;
+    visibility?: 'public' | 'private';
+    data_access_mode?: 'public' | 'user_private';
+    status?: string;
+    app_stage?: string;
+    public_settings?: string;
+    main_page?: string;
+    platform_version?: number;
+}
+/**
+ * MongoDB-style list options (Mongoose-compatible)
+ * Used in the second parameter of list(filter, options)
+ *
+ * @example
+ * ```typescript
+ * // Sort ascending by name
+ * await Entity.list({}, { sort: { name: 1 } })
+ *
+ * // Sort descending by timestamp
+ * await Entity.list({}, { sort: { timestamp: -1 } })
+ *
+ * // With pagination
+ * await Entity.list({}, { sort: { created_at: -1 }, limit: 20, offset: 10 })
+ * ```
+ */
+interface ListOptions {
+    /** Sort order: { field: 1 } for ascending, { field: -1 } for descending. Also accepts string format: 'field' or '-field' */
+    sort?: Record<string, 1 | -1> | string;
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Number of results to skip (for pagination) */
+    offset?: number;
+}
+/**
+ * @deprecated Use separate filter and ListOptions parameters instead
+ * This interface is kept for backward compatibility
+ *
+ * @example Old style (still works):
+ * ```typescript
+ * await Entity.list({ q: { status: 'active' }, sort: '-created_at' })
+ * ```
+ *
+ * @example New style (recommended):
+ * ```typescript
+ * await Entity.list({ status: 'active' }, { sort: { created_at: -1 } })
+ * ```
+ */
+interface QueryOptions {
+    q?: Record<string, any>;
+    sort?: string;
+    limit?: number;
+    offset?: number;
+    _count?: boolean;
+    [key: string]: any;
+}
+/**
+ * Base collection record type
+ * Extend this in your app for type-safe collections
+ */
+interface CollectionRecord {
+    id: string;
+    _id?: string;
+    created_at?: string;
+    updated_at?: string;
+    created_by?: string;
+    created_by_id?: string;
+    [key: string]: any;
+}
+/** @deprecated Use CollectionRecord instead */
+type Entity = CollectionRecord;
+/** @deprecated Use CollectionRecord instead */
+type EntityRecord = CollectionRecord;
+interface AuthResponse {
+    token?: string;
+    user?: UserInfo;
+    access_token?: string;
+    refresh_token?: string;
+    token_type?: string;
+}
+interface OAuthProvider {
+    provider_id: string;
+    provider_type: 'platform' | 'custom';
+    display_name: string;
+    icon_data: string;
+    brand_color: string;
+    login_endpoint: string;
+    enabled: boolean;
+}
+interface OAuthProvidersResponse {
+    providers: OAuthProvider[];
+    email_enabled: boolean;
+    app_id?: string;
+    app_name?: string;
+}
+interface UserInfo {
+    id: string;
+    platform_user_id?: string;
+    app_id?: string;
+    email: string;
+    full_name?: string;
+    role?: string;
+    profile_image_url?: string;
+    bio?: string;
+    is_verified?: boolean;
+    disabled?: boolean;
+    is_service?: boolean;
+    created_date?: string;
+    updated_date?: string;
+    [key: string]: any;
+}
+interface EmailParams {
+    to: string;
+    subject: string;
+    body: string;
+    from_name?: string;
+}
+interface LLMMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string | Array<{
+        type: string;
+        text?: string;
+        file?: any;
+        image_url?: any;
+    }>;
+}
+/**
+ * Available LLM models for InvokeLLM
+ * - 'gemini-flash': Fast and cost-effective (default)
+ * - 'gemini-pro': Smarter with extended thinking (128 token thinking budget)
+ */
+type LLMModel = 'gemini-flash' | 'gemini-pro';
+interface LLMParams {
+    /** Message-based format for advanced use */
+    messages?: LLMMessage[];
+    /** Simple text prompt (alternative to messages) */
+    prompt?: string;
+    /** File URLs to include (images, PDFs, audio, videos, etc.) - supports YouTube URLs and uploaded video files */
+    file_urls?: string[];
+    /** Enable Google Search grounding */
+    google_search?: boolean;
+    /** Enable URL context grounding */
+    url_context?: boolean;
+    /**
+     * Force JSON output format. Specify the JSON schema in your prompt text.
+     * @example { type: "json_object" }
+     */
+    response_format?: {
+        type: 'json_object';
+    } | Record<string, any>;
+    /**
+     * Model to use for LLM processing
+     * - 'gemini-flash': Fast and cost-effective (default)
+     * - 'gemini-pro': Smarter with extended thinking for complex reasoning
+     */
+    model?: LLMModel | string;
+    /**
+     * @deprecated All integrations are now async by default. This parameter is ignored.
+     * The SDK automatically polls for completion and returns the result.
+     */
+    async_mode?: boolean;
+    /** @deprecated Use google_search instead */
+    web_search?: boolean;
+    /** @deprecated No longer used */
+    web_search_options?: {
+        search_context_size?: 'small' | 'medium' | 'large';
+    };
+    /**
+     * Stream tokens via SSE instead of returning complete response.
+     * When true, tokens are streamed in real-time via onToken callback.
+     * @default false
+     */
+    stream?: boolean;
+    /**
+     * Callback for each token when streaming (requires stream: true)
+     * @param token - The streamed token
+     */
+    onToken?: (token: string) => void;
+    /**
+     * Callback when streaming completes (requires stream: true)
+     * @param result - Complete result with metadata
+     */
+    onComplete?: (result: LLMStreamResult) => void;
+    /**
+     * Callback when streaming encounters an error (requires stream: true)
+     * @param error - The error that occurred
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Result from streaming LLM completion
+ */
+interface LLMStreamResult {
+    /** Complete response text */
+    result: string;
+    /** Model that was used */
+    model_used: string;
+    /** Token usage statistics */
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    /** Whether images were in the input */
+    has_images?: boolean;
+    /** Whether files were in the input */
+    has_files?: boolean;
+}
+/**
+ * SSE event types for LLM streaming
+ */
+interface LLMStreamEvent {
+    /** Event type */
+    type: 'token' | 'done' | 'error';
+    /** Token content (for type: 'token') */
+    content?: string;
+    /** Complete result (for type: 'done') */
+    result?: string;
+    /** Model used (for type: 'done') */
+    model_used?: string;
+    /** Usage stats (for type: 'done') */
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    /** Error message (for type: 'error') */
+    message?: string;
+}
+/**
+ * Async job status types
+ */
+type AsyncJobStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Async job types
+ */
+type AsyncJobType = 'llm' | 'image' | 'speech' | 'video' | 'extract' | 'email' | 'sms';
+/**
+ * Response when async_mode is enabled
+ */
+interface AsyncJobCreatedResponse {
+    /** Whether this is an async response */
+    async: true;
+    /** Job ID for polling status */
+    job_id: string;
+    /** Initial job status */
+    status: AsyncJobStatus;
+    /** Human-readable message */
+    message: string;
+    /** URL to poll for status */
+    poll_url: string;
+}
+/**
+ * Job status response from CheckJobStatus
+ */
+interface AsyncJobStatusResponse {
+    /** Job ID */
+    job_id: string;
+    /** Current status */
+    status: AsyncJobStatus;
+    /** Progress (0.0 to 1.0) */
+    progress: number;
+    /** Human-readable status message */
+    status_message?: string;
+    /** Result data (when status is 'completed') */
+    result?: any;
+    /** Error message (when status is 'failed') */
+    error?: string;
+    /** Job creation timestamp */
+    created_at?: string;
+    /** Processing start timestamp */
+    started_at?: string;
+    /** Completion timestamp */
+    completed_at?: string;
+}
+/**
+ * Parameters for checking job status
+ */
+interface CheckJobStatusParams {
+    /** Job ID to check */
+    job_id: string;
+}
+/**
+ * Options for async operations with built-in polling
+ */
+interface AsyncOptions {
+    /**
+     * Called on status changes during polling.
+     * Note: For most operations (image/speech/video), status is simply 'pending' → 'processing' → 'completed'.
+     * Real progress tracking is only available for multi-file operations like ExtractData.
+     * @param status - Current job status ('pending' | 'processing' | 'completed' | 'failed')
+     * @param message - Human-readable status message (e.g., "Generating image with AI...")
+     */
+    onStatusChange?: (status: string, message?: string) => void;
+    /**
+     * Polling interval in milliseconds
+     * @default 2000
+     */
+    pollInterval?: number;
+    /**
+     * Maximum time to wait in milliseconds
+     * @default 300000 (5 minutes)
+     */
+    timeout?: number;
+    /**
+     * Return immediately with job_id instead of waiting for completion
+     * When true, returns AsyncJobCreatedResponse
+     * @default false
+     */
+    returnJobId?: boolean;
+}
+interface ImageParams {
+    /** Text prompt describing the desired image or transformation */
+    prompt: string;
+    /** Optional: URL of an existing image to edit/transform (for image editing) */
+    image_url?: string;
+}
+interface SpeechParams {
+    input: string;
+    model?: string;
+    voice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+    response_format?: 'mp3' | 'opus' | 'aac' | 'flac';
+    speed?: number;
+}
+interface VideoParams {
+    prompt: string;
+    model?: string;
+    negative_prompt?: string;
+    aspect_ratio?: '16:9' | '9:16';
+    resolution?: '720p' | '1080p';
+    duration_seconds?: '4' | '6' | '8';
+    person_generation?: 'allow_all' | 'allow_adult' | 'dont_allow';
+    image_url?: string;
+    last_frame_url?: string;
+    reference_image_urls?: string[];
+    video_url?: string;
+}
+interface VideoStatusParams {
+    operation_name: string;
+}
+interface ExtractParams {
+    file_urls: string[];
+}
+interface SMSParams {
+    /** Recipient phone number in E.164 format (+1234567890) */
+    to: string;
+    /** SMS message content (max 1600 characters) */
+    message: string;
+    /** Optional: Sender ID (alphanumeric, max 11 chars, supported in some countries) */
+    from_name?: string;
+}
+interface ServiceResponse {
+    success: boolean;
+    [key: string]: any;
+}
+interface BulkResult {
+    success: boolean;
+    inserted_count?: number;
+    deleted_count?: number;
+    ids?: string[];
+}
+interface ImportResult {
+    success: boolean;
+    imported_count?: number;
+    errors?: any[];
+}
+/**
+ * Collection class with type-safe CRUD operations
+ * @template T - Record type extending CollectionRecord base interface
+ */
+interface CollectionClass<T = CollectionRecord> {
+    /**
+     * Get a single record by ID
+     * @param id - Record ID
+     * @returns The record
+     */
+    get(id: string): Promise<T>;
+    /**
+     * List records with MongoDB/Mongoose-style filtering
+     *
+     * @example Simple filter
+     * ```typescript
+     * await Collection.list({ status: 'active' })
+     * ```
+     *
+     * @example With sort and pagination
+     * ```typescript
+     * await Collection.list(
+     *   { project_id: projectId },
+     *   { sort: { timestamp: -1 }, limit: 10 }
+     * )
+     * ```
+     *
+     * @example Complex MongoDB operators
+     * ```typescript
+     * await Collection.list({
+     *   $and: [
+     *     { priority: { $gte: 5 } },
+     *     { status: 'active' }
+     *   ]
+     * })
+     * ```
+     *
+     * @example Old style (still supported)
+     * ```typescript
+     * await Collection.list({ q: { status: 'active' }, sort: '-created_at' })
+     * ```
+     *
+     * @param filter - MongoDB query filter
+     * @param options - Sort, limit, offset options
+     * @returns Array of records
+     */
+    list(filter?: Record<string, any>, options?: ListOptions): Promise<T[]>;
+    list(options?: QueryOptions): Promise<T[]>;
+    /**
+     * Filter records by query (alias for list)
+     * @param filter - MongoDB query filter
+     * @param options - Sort, limit, offset options
+     * @returns Array of matching records
+     */
+    filter(filter?: Record<string, any>, options?: ListOptions): Promise<T[]>;
+    filter(options?: QueryOptions): Promise<T[]>;
+    /**
+     * Find a single record matching the query
+     *
+     * @example MongoDB/Mongoose style
+     * ```typescript
+     * await Collection.findOne({ email: 'user@example.com' })
+     * ```
+     *
+     * @param filter - MongoDB query filter
+     * @param options - Optional sort/limit options
+     * @returns Single record or null
+     */
+    findOne(filter?: Record<string, any>, options?: ListOptions): Promise<T | null>;
+    findOne(filters?: QueryOptions): Promise<T | null>;
+    /**
+     * Create a new record
+     * @param data - Record data
+     * @returns Created record
+     */
+    create(data: Partial<T>): Promise<T>;
+    /**
+     * Update an existing record
+     * @param id - Record ID
+     * @param data - Updated data
+     * @returns Updated record
+     */
+    update(id: string, data: Partial<T>): Promise<T>;
+    /**
+     * Delete a record by ID
+     * @param id - Record ID
+     * @returns Success boolean
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Count records matching the query
+     *
+     * @example MongoDB/Mongoose style
+     * ```typescript
+     * const activeCount = await Collection.count({ status: 'active' })
+     * ```
+     *
+     * @param filter - MongoDB query filter
+     * @returns Count
+     */
+    count(filter?: Record<string, any>): Promise<number>;
+    count(filters?: QueryOptions): Promise<number>;
+    /**
+     * Create multiple records at once
+     * @param items - Array of record data
+     * @returns Bulk operation result
+     */
+    bulkCreate(items: Partial<T>[]): Promise<BulkResult>;
+    /**
+     * Delete multiple records by ID
+     * @param ids - Array of record IDs
+     * @returns Bulk operation result
+     */
+    bulkDelete(ids: string[]): Promise<BulkResult>;
+    /**
+     * Import records from CSV or JSON file
+     * @param file - File to import
+     * @param format - File format ('csv' or 'json')
+     * @returns Import result
+     */
+    import(file: File, format: 'csv' | 'json'): Promise<ImportResult>;
+    /**
+     * Delete all records (requires explicit confirmation)
+     * @param confirm - Must be true to proceed
+     * @returns Bulk operation result
+     */
+    deleteAll(confirm: boolean): Promise<BulkResult>;
+    /** @deprecated Use get() instead */
+    findById(id: string): Promise<T>;
+}
+/** @deprecated Use CollectionClass instead */
+type EntityClass<T = CollectionRecord> = CollectionClass<T>;
+/**
+ * Enhanced User collection class with convenience methods
+ * Automatically available for User collections - no wrapper needed!
+ *
+ * @example
+ * // Update current user (single argument)
+ * await User.update({ bio: "Software developer" });
+ *
+ * @example
+ * // Update specific user by ID (two arguments, admin)
+ * await User.update("user-id-123", { role: "editor" });
+ *
+ * @example
+ * // Get current user
+ * const me = await User.me();
+ */
+interface UserCollectionClass<T = UserInfo> extends Omit<CollectionClass<T>, 'update'> {
+    /**
+     * Smart update method with two signatures:
+     * - update(data) - Updates current logged-in user
+     * - update(id, data) - Updates specific user by ID (admin)
+     */
+    update(data: Partial<T>): Promise<T>;
+    update(id: string, data: Partial<T>): Promise<T>;
+    /**
+     * Get current logged-in user
+     * Same as auth.me()
+     * @returns Current user information
+     */
+    me(): Promise<T>;
+    /**
+     * Update current logged-in user
+     * Same as auth.updateMe()
+     * @param data - Fields to update
+     * @returns Updated user information
+     */
+    updateMe(data: Partial<T>): Promise<T>;
+}
+/** @deprecated Use UserCollectionClass instead */
+type UserEntityClass<T = UserInfo> = UserCollectionClass<T>;
+/**
+ * Integration method signature
+ */
+type IntegrationMethod = (params?: Record<string, any>, useServiceToken?: boolean) => Promise<any>;
+/**
+ * BuiltIn integration methods
+ */
+interface BuiltInIntegration {
+    SendEmail(params: EmailParams): Promise<ServiceResponse>;
+    SendSMS(params: SMSParams): Promise<ServiceResponse>;
+    /**
+     * Invoke LLM for text/vision/file processing
+     * @param params - LLM parameters
+     * @param options - Async options for handling long-running operations
+     * @returns Result or AsyncJobCreatedResponse (if async_mode or returnJobId)
+     */
+    InvokeLLM(params: LLMParams, options?: AsyncOptions): Promise<ServiceResponse | AsyncJobCreatedResponse>;
+    UploadFile(params: {
+        file: File;
+        metadata?: Record<string, any>;
+    }): Promise<ServiceResponse>;
+    /**
+     * Upload a private file (only uploader can access via signed URLs)
+     * @param params - File to upload
+     * @returns Response with file_uri (use CreateFileSignedUrl to get displayable URL)
+     */
+    UploadPrivateFile(params: {
+        file: File;
+    }): Promise<{
+        file_uri: string;
+        file_id: string;
+        filename: string;
+        size: number;
+        content_type: string;
+    }>;
+    /**
+     * Create a temporary signed URL for a private file
+     * @param params - file_uri from UploadPrivateFile and optional expiry time
+     * @returns Signed URL that can be used in <img> tags
+     */
+    CreateFileSignedUrl(params: {
+        file_uri: string;
+        expires_in?: number;
+    }): Promise<{
+        signed_url: string;
+        expires_in: number;
+    }>;
+    /**
+     * Download a private file (triggers browser download)
+     * Uses backend proxy to avoid CORS issues with R2 presigned URLs
+     * @param params - file_uri from UploadPrivateFile and optional filename for download
+     */
+    DownloadPrivateFile(params: {
+        file_uri: string;
+        filename?: string;
+    }): Promise<void>;
+    GenerateImage(params: ImageParams): Promise<ServiceResponse>;
+    GenerateSpeech(params: SpeechParams): Promise<ServiceResponse>;
+    GenerateVideo(params: VideoParams): Promise<ServiceResponse>;
+    CheckVideoStatus(params: VideoStatusParams): Promise<ServiceResponse>;
+    ExtractData(params: ExtractParams): Promise<ServiceResponse>;
+    /**
+     * Check the status of an async job
+     * @param params - Job ID to check
+     * @returns Current job status with progress and result
+     */
+    CheckJobStatus(params: CheckJobStatusParams): Promise<AsyncJobStatusResponse>;
+}
+/**
+ * Auth module interface
+ */
+interface AuthModule {
+    /**
+     * Check if user is authenticated
+     * @returns True if authenticated
+     */
+    isAuthenticated(): Promise<boolean>;
+    /**
+     * Get current user info
+     * @returns Current user
+     */
+    me(): Promise<UserInfo>;
+    /**
+     * Redirect to platform login page
+     * @param returnPath - Path to return to after login
+     */
+    login(returnPath?: string): void;
+    /**
+     * Request a passwordless login code to email
+     * @param email - User email
+     * @param returnUrl - Optional return URL
+     */
+    requestLoginCode(email: string, returnUrl?: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    /**
+     * Verify the login code and set the session token
+     * @param email - User email
+     * @param code - Verification code
+     */
+    verifyLoginCode(email: string, code: string): Promise<AuthResponse>;
+    /**
+     * Get available OAuth providers for this app
+     * Returns both platform providers (zero-config) and custom SSO providers
+     * @returns List of enabled OAuth providers
+     */
+    getAvailableProviders(): Promise<OAuthProvidersResponse>;
+    /**
+     * Initiate OAuth login with any provider
+     * @param providerId - Provider ID (e.g., "google", "microsoft", "github")
+     * @param returnUrl - Optional return URL
+     */
+    loginWithProvider(providerId: string, returnUrl?: string): void;
+    /**
+     * Initiate Google OAuth Login
+     * @deprecated Use loginWithProvider("google", returnUrl) instead
+     * @param returnUrl - Optional return URL
+     */
+    loginWithGoogle(returnUrl?: string): void;
+    /**
+     * Logout current user
+     */
+    logout(): Promise<void>;
+    /**
+     * Refresh access token
+     * @returns New auth response
+     */
+    refreshToken(): Promise<AuthResponse>;
+    /**
+     * Update current user info
+     * @param data - Updated user data
+     * @returns Updated user
+     */
+    updateMe(data: Partial<UserInfo>): Promise<UserInfo>;
+    /**
+     * Update current user profile
+     * Alias for updateMe with clearer naming
+     * @param data - Updated user data
+     * @returns Updated user
+     */
+    updateProfile(data: Partial<UserInfo>): Promise<UserInfo>;
+    /** @deprecated Use me() instead */
+    getCurrentUser(): Promise<UserInfo>;
+    /**
+     * Subscribe to user state changes (for React auth state sync)
+     * Called when user logs in, logs out, or updates profile
+     * @param callback - Function to call with new user (or null on logout)
+     * @returns Unsubscribe function
+     */
+    onUserChange(callback: (user: UserInfo | null) => void): () => void;
+}
+/**
+ * Service role client interface (elevated admin operations)
+ * Available when serviceToken is provided in config
+ */
+interface ServiceRoleClient {
+    /** Collection operations with service role privileges */
+    collections: Record<string, CollectionClass>;
+    /** @deprecated Use collections instead */
+    entities?: Record<string, CollectionClass>;
+    /** Service operations with service role privileges (new flat structure) */
+    services: Record<string, IntegrationMethod>;
+    /** @deprecated Use services instead. Integration operations with service role privileges */
+    integrations: Record<string, Record<string, IntegrationMethod>>;
+}
+/**
+ * Main Omnikit Client interface
+ */
+/**
+ * Cached app metadata for instant access (no API call, no flicker).
+ * Values are loaded from localStorage cache or initial config.
+ */
+interface CachedMetadata {
+    /** App ID */
+    id: string;
+    /** App name */
+    name: string;
+    /** Logo URL (empty string if none) */
+    logoUrl: string;
+    /** Thumbnail URL */
+    thumbnailUrl: string;
+    /** App visibility ('public' | 'private' | 'public_with_login') */
+    visibility: string;
+    /** Enabled platform OAuth providers (e.g., ['google', 'microsoft']) */
+    platformAuthProviders: string[];
+}
+interface OmnikitClient {
+    /** App ID */
+    appId: string;
+    /** API base URL */
+    baseUrl: string;
+    /**
+     * App metadata - available instantly without API call (no flicker!).
+     * Uses localStorage cache with build-time fallback.
+     * @example
+     * <img src={omnikit.metadata.logoUrl} alt={omnikit.metadata.name} />
+     * <span>{omnikit.metadata.name}</span>
+     */
+    metadata: CachedMetadata;
+    /** Collection operations */
+    collections: Record<string, CollectionClass>;
+    /** @deprecated Use collections instead */
+    entities: Record<string, CollectionClass>;
+    /** Integration operations */
+    integrations: Record<string, Record<string, IntegrationMethod>>;
+    /** Authentication methods */
+    auth: AuthModule;
+    /**
+     * Service role operations (admin/elevated privileges)
+     * Only available when serviceToken is provided in config
+     * Throws error if accessed without serviceToken
+     */
+    asServiceRole?: ServiceRoleClient;
+    /** @internal */
+    getAppMetadata(): Promise<AppSchema>;
+    /** @internal */
+    makeRequest(url: string, method?: string, data?: any, options?: RequestOptions): Promise<any>;
+    /** @internal */
+    setAuthToken(token: string): void;
+    /** @internal */
+    getAuthToken(): string | null;
+    /** @internal */
+    clearAuthToken(): void;
+    /** @internal */
+    ensureInitialized(): Promise<void>;
+    /**
+     * Invoke a backend function by name.
+     *
+     * Backend functions are defined in backend/functions/*.js and auto-deployed during build.
+     *
+     * @example
+     * ```typescript
+     * const result = await omnikit.invokeFunction('processPayment', {
+     *   amount: 100,
+     *   userId: 'abc123'
+     * });
+     * ```
+     *
+     * @param functionName - Name of the function (filename without .js extension)
+     * @param body - Optional request body to pass to the function
+     * @returns Response from the function
+     */
+    invokeFunction(functionName: string, body?: Record<string, any>): Promise<any>;
+}
+/**
+ * Request options for makeRequest
+ */
+interface RequestOptions {
+    /** Use service token instead of user token */
+    useServiceToken?: boolean;
+    /** Additional headers */
+    headers?: Record<string, string>;
+    /** Query parameters for GET requests */
+    queryParams?: Record<string, any>;
+}
+/**
+ * Custom error class
+ */
+declare class OmnikitError$1 extends Error {
+    status?: number;
+    code?: string;
+    data?: any;
+    isAuthError?: boolean;
+    constructor(message: string, status?: number, code?: string, data?: any);
+    /**
+     * Check if error is a 404 Not Found
+     */
+    isNotFound(): boolean;
+    /**
+     * Check if error is a 403 Forbidden
+     */
+    isForbidden(): boolean;
+    /**
+     * Check if error is a 401 Unauthorized
+     */
+    isUnauthorized(): boolean;
+    /**
+     * Check if error is a 400 Bad Request
+     */
+    isBadRequest(): boolean;
+    /**
+     * Check if error is a 500 Internal Server Error
+     */
+    isServerError(): boolean;
+}
+/**
+ * Service definition from backend schema (flat structure)
+ */
+interface ServiceDefinition {
+    name: string;
+    path: string;
+    description: string;
+    method?: string;
+    category?: string;
+    async?: boolean;
+    params: Record<string, any>;
+    path_params?: string[] | null;
+    configurable?: boolean | null;
+    providers?: string[] | null;
+}
+/**
+ * Template integration definition from backend schema
+ */
+interface TemplateDefinition {
+    name: string;
+    description: string;
+    category: string;
+    icon?: string;
+    requires_secret: string;
+    help_url: string;
+    methods: string[];
+    connected: boolean;
+}
+/**
+ * Services schema response from backend (new flat structure)
+ */
+interface ServicesSchema {
+    services: ServiceDefinition[];
+    templates: TemplateDefinition[];
+}
+/**
+ * @deprecated Use ServiceDefinition instead
+ * Integration endpoint metadata from backend schema (legacy)
+ */
+interface IntegrationEndpoint {
+    name: string;
+    description?: string;
+    path: string;
+    method?: string;
+    path_params?: string[];
+    schema?: Record<string, any>;
+}
+/**
+ * @deprecated Use ServicesSchema instead
+ * Integration package metadata from backend schema (legacy)
+ */
+interface IntegrationPackage {
+    package_name: string;
+    package_description?: string;
+    endpoints: IntegrationEndpoint[];
+}
+/**
+ * @deprecated Use ServicesSchema instead
+ * Integration schema response from backend (legacy)
+ */
+interface IntegrationSchema {
+    installed_packages: IntegrationPackage[];
+}
+/**
+ * Available voice options for Live Voice AI
+ */
+type LiveVoiceVoice = 'Puck' | 'Charon' | 'Kore' | 'Fenrir' | 'Aoede';
+/**
+ * Status of the live voice session
+ */
+type LiveVoiceStatus = 'idle' | 'connecting' | 'listening' | 'processing' | 'speaking' | 'disconnected' | 'error';
+/**
+ * Configuration for creating a live voice session
+ */
+interface LiveVoiceConfig {
+    /**
+     * System instruction to guide AI behavior
+     * @example "You are a helpful customer service agent for a pizza shop."
+     */
+    systemInstruction?: string;
+    /**
+     * Voice to use for AI responses
+     * @default 'Puck'
+     */
+    voice?: LiveVoiceVoice;
+    /**
+     * Called when transcript is received (user or assistant speech)
+     * @param text - Transcribed text
+     * @param role - Who spoke ('user' or 'assistant')
+     */
+    onTranscript?: (text: string, role: 'user' | 'assistant') => void;
+    /**
+     * Called when session status changes
+     * @param status - New session status
+     */
+    onStatusChange?: (status: LiveVoiceStatus) => void;
+    /**
+     * Called when an error occurs
+     * @param error - Error that occurred
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called when session is started (with session ID)
+     * @param sessionId - Unique session identifier
+     */
+    onSessionStarted?: (sessionId: string) => void;
+    /**
+     * Called when session ends
+     * @param durationSeconds - Total session duration in seconds
+     */
+    onSessionEnded?: (durationSeconds: number) => void;
+}
+/**
+ * Live voice session interface for managing real-time voice conversations
+ */
+interface LiveVoiceSession {
+    /**
+     * Start the voice session
+     * Requests microphone permission and establishes WebSocket connection
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the voice session
+     * Closes WebSocket and releases microphone
+     */
+    stop(): Promise<void>;
+    /**
+     * Interrupt the AI while it's speaking
+     * Use this when user wants to cut off the AI mid-sentence
+     */
+    interrupt(): void;
+    /**
+     * Whether the session is currently active
+     */
+    readonly isActive: boolean;
+    /**
+     * Current session status
+     */
+    readonly status: LiveVoiceStatus;
+    /**
+     * Session ID (available after connection)
+     */
+    readonly sessionId: string | null;
+}
+/**
+ * Message types sent from client to server over WebSocket
+ */
+interface LiveVoiceClientMessage {
+    type: 'audio' | 'config' | 'interrupt' | 'end';
+    data?: ArrayBuffer;
+    systemInstruction?: string;
+    voice?: LiveVoiceVoice;
+}
+/**
+ * Message types sent from server to client over WebSocket
+ */
+interface LiveVoiceServerMessage {
+    type: 'audio' | 'transcript' | 'status' | 'error' | 'session_started' | 'session_ended';
+    data?: ArrayBuffer;
+    text?: string;
+    role?: 'user' | 'assistant';
+    status?: LiveVoiceStatus;
+    message?: string;
+    code?: string;
+    session_id?: string;
+    duration_seconds?: number;
+}
+
+/**
+ * Omnikit SDK v2.0 - Main Client
+ *
+ * Features:
+ * - Auto-initialization on first use (no explicit initialize() required)
+ * - Service role pattern for admin operations
+ * - Automatic token detection from URL or localStorage
+ * - Simplified integration access (no .call() needed)
+ * - Enhanced collection operations (bulkCreate, bulkDelete, import, deleteAll)
+ * - Improved auth module (isAuthenticated, me, updateMe)
+ */
+
+/**
+ * Enhanced error class with helper methods
+ */
+declare class OmnikitError extends Error implements OmnikitError$1 {
+    status?: number;
+    code?: string;
+    data?: any;
+    isAuthError?: boolean;
+    constructor(message: string, status?: number, code?: string, data?: any);
+    isNotFound(): boolean;
+    isForbidden(): boolean;
+    isUnauthorized(): boolean;
+    isBadRequest(): boolean;
+    isServerError(): boolean;
+}
+declare class APIClient implements OmnikitClient {
+    appId: string;
+    baseUrl: string;
+    private userToken;
+    private _serviceToken;
+    private _apiKey;
+    private initialized;
+    private initPromise;
+    private _collections;
+    private _services;
+    private _integrations;
+    private _auth;
+    private _asServiceRole?;
+    private _metadata;
+    private _metadataListeners;
+    private _userListeners;
+    constructor(config: OmnikitConfig);
+    /**
+     * Load metadata from localStorage cache, falling back to initial config
+     * Guards localStorage access for Deno/Node compatibility
+     */
+    private loadCachedMetadata;
+    /**
+     * Update metadata cache in localStorage
+     * IMPORTANT: Mutate in place to preserve object reference for exports
+     */
+    private updateMetadataCache;
+    /**
+     * App metadata - available instantly without API call (no flicker!)
+     */
+    get metadata(): {
+        id: string;
+        name: string;
+        logoUrl: string;
+        thumbnailUrl: string;
+        visibility: string;
+        platformAuthProviders: string[];
+    };
+    /**
+     * Subscribe to metadata updates (for React components to trigger re-render)
+     * @returns Unsubscribe function
+     */
+    onMetadataChange(callback: () => void): () => void;
+    /**
+     * Subscribe to user state changes (for React auth state sync)
+     * Called when user logs in, logs out, or updates profile
+     * @returns Unsubscribe function
+     */
+    onUserChange(callback: (user: UserInfo | null) => void): () => void;
+    /**
+     * Emit user change event to all listeners
+     */
+    private emitUserChange;
+    /**
+     * Lazy getter for collections - auto-initializes on first access
+     */
+    get collections(): Record<string, CollectionClass>;
+    /**
+     * @deprecated Use collections instead. This alias exists for backward compatibility.
+     */
+    get entities(): Record<string, CollectionClass>;
+    /**
+     * Lazy getter for services (new flat structure) - auto-initializes on first access
+     * Usage: omnikit.services.SendEmail({ to, subject, body })
+     */
+    get services(): Record<string, IntegrationMethod>;
+    /**
+     * @deprecated Use services instead for flat access
+     * Lazy getter for integrations - auto-initializes on first access
+     */
+    get integrations(): Record<string, Record<string, IntegrationMethod>>;
+    /**
+     * Lazy getter for auth - auto-initializes on first access
+     */
+    get auth(): AuthModule;
+    /**
+     * Lazy getter for service role operations
+     * Only available when serviceToken is provided
+     */
+    get asServiceRole(): ServiceRoleClient;
+    /**
+     * Create auth proxy that auto-initializes
+     */
+    private createAuthProxy;
+    /**
+     * Convert PascalCase to snake_case
+     * Example: PdfDocument -> pdf_document, UserProfile -> user_profile
+     */
+    private toSnakeCase;
+    /**
+     * Create collections proxy that auto-initializes
+     * @param useServiceToken - Whether to use service token for requests
+     */
+    private createCollectionsProxy;
+    /**
+     * Poll for job completion with progress callbacks
+     * @param jobId - Job ID to poll
+     * @param options - Async options (onStatusChange, pollInterval, timeout)
+     * @returns Final job result
+     */
+    private pollJobUntilComplete;
+    /**
+     * Stream LLM response token by token via SSE
+     * @param params - LLM request parameters with streaming callbacks
+     * @returns Promise that resolves to the complete response string
+     */
+    private streamLLMResponse;
+    /**
+     * Create services proxy that auto-initializes (new flat structure)
+     * @param useServiceToken - Whether to use service token for requests
+     */
+    private createServicesProxy;
+    /**
+     * @deprecated Use createServicesProxy instead
+     * Create integrations proxy that auto-initializes
+     * @param useServiceToken - Whether to use service token for requests
+     */
+    private createIntegrationsProxy;
+    /**
+     * Ensure SDK is initialized (auto-initializes once on first call)
+     */
+    ensureInitialized(): Promise<void>;
+    /**
+     * Initialize SDK by fetching app schema and integration endpoints
+     * This happens automatically on first use - no need to call explicitly
+     */
+    private initialize;
+    /**
+     * Fetch app schema from backend
+     */
+    private fetchAppSchema;
+    /**
+     * Fetch integration schema from backend
+     * Returns ServicesSchema (new flat format) or IntegrationSchema (legacy)
+     */
+    private fetchIntegrationSchema;
+    /**
+     * Create collection classes from schema
+     */
+    private createCollections;
+    /**
+     * Create a single collection class with all CRUD operations
+     * Automatically enhances User collection with convenience methods
+     */
+    private createCollectionClass;
+    /**
+     * Create services from new flat schema (recommended)
+     * Services are exposed as omnikit.services.ServiceName
+     */
+    private createServicesFromSchema;
+    /**
+     * Create a service method from ServiceDefinition
+     */
+    private createServiceMethod;
+    /**
+     * Handle file upload via presigned URL flow
+     * Supports both public and private file uploads based on path
+     */
+    private handleFileUpload;
+    /**
+     * @deprecated Use createServicesFromSchema instead
+     * Create integration methods from legacy backend schema
+     */
+    private createIntegrationsFromSchema;
+    /**
+     * @deprecated Backend now returns final method names
+     * Format endpoint name to PascalCase method name (legacy)
+     */
+    private formatMethodName;
+    /**
+     * Create integration method that calls backend endpoint
+     */
+    private createIntegrationMethod;
+    /**
+     * Normalize integration response to add common aliases for bulletproof access
+     * Prevents runtime errors from AI-generated code using wrong property names
+     */
+    private normalizeIntegrationResponse;
+    /**
+     * HTTP request helper with JSON
+     */
+    makeRequest(url: string, method?: string, data?: any, options?: RequestOptions): Promise<any>;
+    /**
+     * HTTP request helper with FormData (for file uploads)
+     */
+    private makeRequestWithFormData;
+    /**
+     * Get app metadata (for internal use)
+     */
+    getAppMetadata(): Promise<AppSchema>;
+    /**
+     * Set auth token
+     */
+    setAuthToken(token: string): void;
+    /**
+     * Get current auth token
+     */
+    getAuthToken(): string | null;
+    /**
+     * Clear auth token
+     */
+    clearAuthToken(): void;
+    /**
+     * Create a live voice session for real-time voice conversation with AI.
+     *
+     * The session manages WebSocket communication, microphone capture, and audio playback.
+     *
+     * @example
+     * ```typescript
+     * const session = omnikit.createLiveVoiceSession({
+     *   systemInstruction: 'You are a helpful assistant.',
+     *   voice: 'Puck',
+     *   onTranscript: (text, role) => console.log(`${role}: ${text}`),
+     *   onStatusChange: (status) => console.log(`Status: ${status}`),
+     *   onError: (error) => console.error(error),
+     * });
+     *
+     * await session.start();
+     * // ... user speaks, AI responds ...
+     * await session.stop();
+     * ```
+     *
+     * @param config - Optional configuration for the voice session
+     * @returns A LiveVoiceSession object to control the session
+     */
+    createLiveVoiceSession(config?: LiveVoiceConfig): LiveVoiceSession;
+    /**
+     * Invoke a backend function by name.
+     *
+     * Backend functions are deployed to Supabase Edge Functions and can be invoked
+     * from the frontend using this method.
+     *
+     * @example
+     * ```typescript
+     * // Invoke a function
+     * const result = await omnikit.invokeFunction('processPayment', {
+     *   amount: 100,
+     *   userId: 'abc123'
+     * });
+     * console.log(result.transactionId); // Direct access to function response
+     * ```
+     *
+     * @param functionName - Name of the function to invoke (matches filename without .js)
+     * @param body - Optional request body to send to the function
+     * @returns Response data from the function (unwrapped)
+     * @throws Error if the function invocation fails
+     */
+    invokeFunction(functionName: string, body?: Record<string, any>): Promise<any>;
+}
+/**
+ * Factory function to create an Omnikit client
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from '@omnikit/sdk';
+ *
+ * const omnikit = createClient({
+ *   appId: 'your-app-id',
+ *   // token auto-detected from URL or localStorage
+ * });
+ *
+ * // Ready to use immediately - no initialize() needed!
+ * const users = await omnikit.collections.User.list();
+ * ```
+ */
+declare function createClient(config: OmnikitConfig): OmnikitClient;
+
+/**
+ * Live Voice Session Implementation
+ *
+ * Manages real-time bidirectional voice communication with Gemini Live API.
+ * Handles microphone capture, audio playback, and WebSocket communication.
+ */
+
+/**
+ * Implementation of LiveVoiceSession
+ */
+declare class LiveVoiceSessionImpl implements LiveVoiceSession {
+    private config?;
+    private ws;
+    private audioContext;
+    private mediaStream;
+    private scriptProcessor;
+    private sourceNode;
+    private gainNode;
+    private playbackQueue;
+    private isPlaying;
+    private _isActive;
+    private _status;
+    private _sessionId;
+    private baseUrl;
+    private appId;
+    private token;
+    constructor(baseUrl: string, appId: string, token: string | null, config?: LiveVoiceConfig | undefined);
+    get isActive(): boolean;
+    get status(): LiveVoiceStatus;
+    get sessionId(): string | null;
+    /**
+     * Start the voice session
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the voice session
+     */
+    stop(): Promise<void>;
+    /**
+     * Interrupt the AI while speaking
+     */
+    interrupt(): void;
+    /**
+     * Build WebSocket URL with auth and config
+     */
+    private buildWebSocketUrl;
+    /**
+     * Connect to WebSocket server
+     */
+    private connectWebSocket;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleMessage;
+    /**
+     * Handle incoming audio data from Gemini
+     */
+    private handleAudioData;
+    /**
+     * Play next audio chunk from queue
+     */
+    private playNextChunk;
+    /**
+     * Set up audio capture from microphone
+     */
+    private setupAudioCapture;
+    /**
+     * Simple linear resampling
+     */
+    private resample;
+    /**
+     * Update status and notify callback
+     */
+    private setStatus;
+    /**
+     * Clean up all resources
+     */
+    private cleanup;
+}
+
+export { APIClient, type AppMetadata, type AppSchema, type AsyncJobCreatedResponse, type AsyncJobStatus, type AsyncJobStatusResponse, type AsyncJobType, type AsyncOptions, type AuthModule, type AuthResponse, type BuiltInIntegration, type BulkResult, type CachedMetadata, type CheckJobStatusParams, type CollectionClass, type CollectionDefinition, type CollectionField, type CollectionRecord, type EmailParams, type Entity, type EntityClass, type EntityDefinition, type EntityField, type EntityRecord, type ExtractParams, type ImageParams, type ImportResult, type InitialMetadata, type IntegrationEndpoint, type IntegrationMethod, type IntegrationPackage, type IntegrationSchema, type LLMMessage, type LLMModel, type LLMParams, type LLMStreamEvent, type LLMStreamResult, type ListOptions, type LiveVoiceClientMessage, type LiveVoiceConfig, type LiveVoiceServerMessage, type LiveVoiceSession, LiveVoiceSessionImpl, type LiveVoiceStatus, type LiveVoiceVoice, type OAuthProvider, type OAuthProvidersResponse, type OmnikitClient, type OmnikitConfig, OmnikitError, type QueryOptions, type RequestOptions, type SMSParams, type ServiceDefinition, type ServiceResponse, type ServiceRoleClient, type ServicesSchema, type SpeechParams, type TemplateDefinition, type UserCollectionClass, type UserEntityClass, type UserInfo, type VideoParams, type VideoStatusParams, createClient };