@blinkdotnew/dev-sdk 2.1.2 → 2.1.4

package/dist/index.d.mts

@@ -61,6 +61,39 @@ interface BlinkClientConfig {
     projectId: string;
     authRequired?: boolean;
     auth?: BlinkAuthConfig;
+    /**
+     * Publishable key (client-safe).
+     *
+     * Used for **public endpoints** when no user JWT is present (e.g. analytics ingest, storage upload,
+     * optional public DB reads). Never use for privileged operations.
+     */
+    publishableKey?: string;
+    /**
+     * Secret key (server-only, privileged). Permanent, never expires.
+     *
+     * Used in **server runtimes** (Edge Functions, Workers) for privileged operations that require
+     * service-role access (e.g. raw SQL, bypassing row-level security).
+     *
+     * Format: `blnk_sk_{projectId-last-8}_{random}` (similar to Stripe's `sk_live_...`)
+     *
+     * **Security**: Never expose this key in client-side code. It is injected by the platform
+     * into edge function environments as `BLINK_SECRET_KEY`.
+     *
+     * When present, this key takes precedence over user JWTs for all requests.
+     *
+     * @example
+     * // Edge function (Deno)
+     * const blink = createClient({
+     *   projectId: Deno.env.get('BLINK_PROJECT_ID')!,
+     *   secretKey: Deno.env.get('BLINK_SECRET_KEY'),
+     * })
+     */
+    secretKey?: string;
+    /**
+     * @deprecated Use `secretKey` instead. Service tokens are JWT-based and expire after 365 days.
+     * Secret keys are permanent and never expire.
+     */
+    serviceToken?: string;
     /**
      * Storage adapter for cross-platform token persistence
      *
@@ -281,6 +314,9 @@ declare class BlinkError extends Error {
     constructor(message: string, code?: string | undefined, status?: number | undefined, details?: any);
 }
 interface StorageUploadOptions {
+    /**
+     * @deprecated Blink storage uploads are add-only by default. This option is ignored.
+     */
     upsert?: boolean;
     onProgress?: (percent: number) => void;
 }
@@ -445,6 +481,45 @@ interface TranscriptionRequest {
     response_format?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt';
     signal?: AbortSignal;
 }
+interface VideoGenerationRequest {
+    prompt: string;
+    model?: string;
+    image_url?: string;
+    duration?: string;
+    aspect_ratio?: string;
+    resolution?: string;
+    negative_prompt?: string;
+    generate_audio?: boolean;
+    seed?: number;
+    cfg_scale?: number;
+    signal?: AbortSignal;
+}
+interface VideoGenerationResponse {
+    result: {
+        video: {
+            url: string;
+            content_type?: string;
+            file_name?: string;
+            file_size?: number;
+        };
+        seed?: number;
+        video_id?: string;
+        thumbnail?: {
+            url: string;
+        };
+    };
+    metadata?: {
+        projectId: string;
+        timestamp: string;
+        provider: string;
+        model: string;
+    };
+    usage?: {
+        creditsCharged: number;
+        costUSD: number;
+        model: string;
+    };
+}
 interface TranscriptionResponse {
     text: string;
     transcript?: string;
@@ -483,6 +558,7 @@ interface BlinkAI {
         background?: "auto" | "transparent" | "opaque";
         signal?: AbortSignal;
     }): Promise<ImageGenerationResponse>;
+    generateVideo(options: VideoGenerationRequest): Promise<VideoGenerationResponse>;
     generateSpeech(options: SpeechGenerationRequest): Promise<SpeechGenerationResponse>;
     transcribeAudio(options: TranscriptionRequest): Promise<TranscriptionResponse>;
 }
@@ -731,13 +807,61 @@ interface BlinkNotifications {
     email(params: SendEmailRequest): Promise<SendEmailResponse>;
 }
 
+type ConnectorProvider = 'discord' | 'notion' | 'google_drive' | 'google_calendar' | 'ai';
+type ConnectorAuthMode = 'oauth' | 'api_key' | 'blink_managed' | 'hybrid';
+interface ConnectorStatusData {
+    connected: boolean;
+    provider: ConnectorProvider;
+    auth_mode?: ConnectorAuthMode;
+    account_id?: string;
+    metadata?: Record<string, unknown>;
+    expires_at?: any;
+    scopes?: string[];
+}
+interface ConnectorStatusResponse {
+    success: boolean;
+    data: ConnectorStatusData;
+}
+interface ConnectorExecuteRequest<TParams = Record<string, unknown>> {
+    method: string;
+    params?: TParams;
+    account_id?: string;
+    http_method?: string;
+}
+interface ConnectorExecuteResponse<TData = any> {
+    success: boolean;
+    data: TData;
+}
+interface ConnectorApiKeyRequest<TMetadata = Record<string, unknown>> {
+    api_key: string;
+    account_id?: string;
+    metadata?: TMetadata;
+}
+interface ConnectorApiKeyResponse {
+    success: boolean;
+    data: {
+        id: string;
+        account_id?: string;
+    };
+}
+interface BlinkConnectors {
+    status(provider: ConnectorProvider, options?: {
+        account_id?: string;
+    }): Promise<ConnectorStatusResponse>;
+    execute<TParams = Record<string, unknown>, TData = any>(provider: ConnectorProvider, request: ConnectorExecuteRequest<TParams>): Promise<ConnectorExecuteResponse<TData>>;
+    saveApiKey<TMetadata = Record<string, unknown>>(provider: ConnectorProvider, request: ConnectorApiKeyRequest<TMetadata>): Promise<ConnectorApiKeyResponse>;
+}
+declare class BlinkConnectorError extends BlinkError {
+    constructor(message: string, status?: number, details?: any);
+}
+
 /**
  * HTTP client for Blink API requests
  * Handles authentication, error handling, and request/response processing
  */
 
 interface RequestOptions {
-    method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
     headers?: Record<string, string>;
     body?: any;
     searchParams?: Record<string, string>;
@@ -752,9 +876,14 @@ declare class HttpClient {
     private readonly authUrl;
     private readonly coreUrl;
     readonly projectId: string;
+    private readonly publishableKey?;
+    private readonly secretKey?;
     private getToken;
     private getValidToken?;
     constructor(config: BlinkClientConfig, getToken: () => string | null, getValidToken?: () => Promise<string | null>);
+    private shouldAttachPublishableKey;
+    private shouldSkipSecretKey;
+    private getAuthorizationHeader;
     /**
      * Make an authenticated request to the Blink API
      */
@@ -836,7 +965,7 @@ declare class HttpClient {
         signal?: AbortSignal;
     }): Promise<BlinkResponse<any>>;
     /**
-     * Stream AI text generation with Vercel AI SDK data stream format
+     * Stream AI text generation - uses Vercel AI SDK's pipeUIMessageStreamToResponse (Data Stream Protocol)
      */
     streamAiText(prompt: string, options: {
         model?: string | undefined;
@@ -860,7 +989,7 @@ declare class HttpClient {
         signal?: AbortSignal;
     }): Promise<BlinkResponse<any>>;
     /**
-     * Stream AI object generation with Vercel AI SDK data stream format
+     * Stream AI object generation - uses Vercel AI SDK's pipeTextStreamToResponse
      */
     streamAiObject(prompt: string, options: {
         model?: string | undefined;
@@ -895,6 +1024,18 @@ declare class HttpClient {
         response_format?: string;
         signal?: AbortSignal;
     }): Promise<BlinkResponse<any>>;
+    aiVideo(prompt: string, options?: {
+        model?: string;
+        image_url?: string;
+        duration?: string;
+        aspect_ratio?: string;
+        resolution?: string;
+        negative_prompt?: string;
+        generate_audio?: boolean;
+        seed?: number;
+        cfg_scale?: number;
+        signal?: AbortSignal;
+    }): Promise<BlinkResponse<any>>;
     /**
      * Data-specific requests
      */
@@ -904,6 +1045,13 @@ declare class HttpClient {
     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>>;
+    /**
+     * Connector requests
+     */
+    private formatProviderForPath;
+    connectorStatus(provider: ConnectorProvider): Promise<BlinkResponse<ConnectorStatusResponse>>;
+    connectorExecute<TParams = Record<string, unknown>, TData = any>(provider: ConnectorProvider, request: ConnectorExecuteRequest<TParams>): Promise<BlinkResponse<ConnectorExecuteResponse<TData>>>;
+    connectorSaveApiKey<TMetadata = Record<string, unknown>>(provider: ConnectorProvider, request: ConnectorApiKeyRequest<TMetadata>): Promise<BlinkResponse<ConnectorApiKeyResponse>>;
     /**
      * Realtime-specific requests
      */
@@ -941,17 +1089,17 @@ declare class HttpClient {
     private parseResponse;
     private handleErrorResponse;
     /**
-     * Parse Vercel AI SDK data stream format
-     * Handles text chunks (0:"text"), partial objects (2:[...]), and metadata (d:, e:)
+     * Parse Vercel AI SDK v5 Data Stream Protocol (Server-Sent Events)
+     * Supports all event types from the UI Message Stream protocol
      */
-    private parseDataStream;
+    private parseDataStreamProtocol;
 }
 
 /**
  * Platform detection for cross-platform compatibility
- * Detects whether code is running on web, React Native, or Node.js
+ * Detects whether code is running on web, React Native, Node.js, or Deno
  */
-type Platform = 'web' | 'react-native' | 'node';
+type Platform = 'web' | 'react-native' | 'node' | 'deno';
 /**
  * Current platform
  */
@@ -962,7 +1110,9 @@ declare const platform: Platform;
 declare const isWeb: boolean;
 declare const isReactNative: boolean;
 declare const isNode: boolean;
+declare const isDeno: boolean;
 declare const isBrowser: boolean;
+declare const isServer: boolean;
 
 /**
  * Blink Auth Module - Client-side authentication management
@@ -1175,6 +1325,11 @@ declare class BlinkAuth {
      * Uses expo-web-browser to open auth URL and polls for completion
      */
     private signInWithProviderUniversal;
+    /**
+     * OAuth flow via parent window (for iframe context)
+     * Delegates OAuth to parent window since OAuth providers block flows inside iframes
+     */
+    private signInWithProviderViaParent;
     /**
      * Generic provider sign-in method (headless mode)
      *
@@ -1633,6 +1788,50 @@ declare class BlinkAnalyticsImpl implements BlinkAnalytics {
     private detectChannel;
 }
 
+/**
+ * Blink Functions - Edge function invocation helper
+ * Provides a simple interface for calling Blink Edge Functions with automatic JWT attachment
+ */
+
+interface FunctionsInvokeOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: any;
+    headers?: Record<string, string>;
+    searchParams?: Record<string, string>;
+}
+interface FunctionsInvokeResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Headers;
+}
+interface BlinkFunctions {
+    /**
+     * Invoke a Blink Edge Function.
+     *
+     * Automatically attaches the user's JWT for authenticated requests.
+     * The function URL is constructed as: https://{projectSuffix}--{functionSlug}.functions.blink.new
+     *
+     * @param functionSlug - The slug of the edge function to invoke
+     * @param options - Request options (method, body, headers, etc.)
+     * @returns The function response
+     *
+     * @example
+     * // Simple POST request
+     * const { data } = await blink.functions.invoke('my-function', {
+     *   method: 'POST',
+     *   body: { message: 'Hello' }
+     * })
+     *
+     * @example
+     * // GET request with query params
+     * const { data } = await blink.functions.invoke('my-function', {
+     *   method: 'GET',
+     *   searchParams: { limit: '10' }
+     * })
+     */
+    invoke<T = any>(functionSlug: string, options?: FunctionsInvokeOptions): Promise<FunctionsInvokeResponse<T>>;
+}
+
 /**
  * Blink Client - Main SDK entry point
  * Factory function and client class for the Blink SDK
@@ -1647,6 +1846,8 @@ interface BlinkClient {
     realtime: BlinkRealtime;
     notifications: BlinkNotifications;
     analytics: BlinkAnalytics;
+    connectors: BlinkConnectors;
+    functions: BlinkFunctions;
 }
 /**
  * Create a new Blink client instance
@@ -2121,6 +2322,82 @@ declare class BlinkAIImpl implements BlinkAI {
         n?: number;
         signal?: AbortSignal;
     }): Promise<ImageGenerationResponse>;
+    /**
+     * Generates videos from text prompts or images using AI video generation models.
+     *
+     * @param options - Object containing:
+     *   - `prompt`: Text description of the video to generate (required)
+     *   - `model`: Video model to use (optional). Available models:
+     *       **Text-to-Video Models:**
+     *       - `"fal-ai/veo3.1"` - Google Veo 3.1 (best quality)
+     *       - `"fal-ai/veo3.1/fast"` (default) - Veo 3.1 fast mode (faster, cheaper)
+     *       - `"fal-ai/sora-2/text-to-video/pro"` - OpenAI Sora 2
+     *       - `"fal-ai/kling-video/v2.6/pro/text-to-video"` - Kling 2.6
+     *       **Image-to-Video Models:**
+     *       - `"fal-ai/veo3.1/image-to-video"` - Veo 3.1 I2V
+     *       - `"fal-ai/veo3.1/fast/image-to-video"` - Veo 3.1 fast I2V
+     *       - `"fal-ai/sora-2/image-to-video/pro"` - Sora 2 I2V
+     *       - `"fal-ai/kling-video/v2.6/pro/image-to-video"` - Kling 2.6 I2V
+     *   - `image_url`: Source image URL for image-to-video (required for I2V models)
+     *   - `duration`: Video duration ("4s", "5s", "6s", "8s", "10s", "12s")
+     *   - `aspect_ratio`: Aspect ratio ("16:9", "9:16", "1:1")
+     *   - `resolution`: Resolution ("720p", "1080p") - Veo/Sora only
+     *   - `negative_prompt`: What to avoid in generation - Veo/Kling only
+     *   - `generate_audio`: Generate audio with video (default: true)
+     *   - `seed`: For reproducibility - Veo only
+     *   - `cfg_scale`: Guidance scale (0-1) - Kling only
+     *   - Plus optional signal parameter
+     *
+     * @example
+     * ```ts
+     * // Basic text-to-video generation (uses default fast model)
+     * const { result } = await blink.ai.generateVideo({
+     *   prompt: "A serene sunset over the ocean with gentle waves"
+     * });
+     * console.log("Video URL:", result.video.url);
+     *
+     * // High quality with Veo 3.1
+     * const { result } = await blink.ai.generateVideo({
+     *   prompt: "A cinematic shot of a futuristic city at night",
+     *   model: "fal-ai/veo3.1",
+     *   resolution: "1080p",
+     *   aspect_ratio: "16:9"
+     * });
+     *
+     * // Image-to-video animation
+     * const { result } = await blink.ai.generateVideo({
+     *   prompt: "Animate this image with gentle camera movement",
+     *   model: "fal-ai/veo3.1/fast/image-to-video",
+     *   image_url: "https://example.com/my-image.jpg",
+     *   duration: "5s"
+     * });
+     *
+     * // Using Sora 2 for creative videos
+     * const { result } = await blink.ai.generateVideo({
+     *   prompt: "A magical forest with glowing fireflies",
+     *   model: "fal-ai/sora-2/text-to-video/pro",
+     *   duration: "8s"
+     * });
+     *
+     * // Using Kling for detailed videos
+     * const { result, usage } = await blink.ai.generateVideo({
+     *   prompt: "A professional cooking tutorial scene",
+     *   model: "fal-ai/kling-video/v2.6/pro/text-to-video",
+     *   negative_prompt: "blur, distort, low quality",
+     *   cfg_scale: 0.7
+     * });
+     * console.log("Credits charged:", usage?.creditsCharged);
+     * ```
+     *
+     * @returns Promise<VideoGenerationResponse> - Object containing:
+     *   - `result.video.url`: URL to the generated video
+     *   - `result.video.content_type`: MIME type (video/mp4)
+     *   - `result.video.file_name`: Generated filename
+     *   - `result.video.file_size`: File size in bytes
+     *   - `metadata`: Generation metadata (projectId, timestamp, model)
+     *   - `usage`: Credits charged and cost information
+     */
+    generateVideo(options: VideoGenerationRequest): Promise<VideoGenerationResponse>;
     /**
      * Converts text to speech using AI voice synthesis models.
      *
@@ -2296,4 +2573,14 @@ declare class BlinkRealtimeImpl implements BlinkRealtime {
     onPresence(channelName: string, callback: (users: PresenceUser[]) => void): () => void;
 }
 
-export { type AnalyticsEvent, AsyncStorageAdapter, 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 Message, NoOpStorageAdapter, 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 StorageAdapter, type StorageUploadOptions, type StorageUploadResponse, type TableOperations, type TextGenerationRequest, type TextGenerationResponse, type TokenUsage, type TranscriptionRequest, type TranscriptionResponse, type UpdateOptions, type UpsertOptions, type WebBrowserModule, WebStorageAdapter, createClient, getDefaultStorageAdapter, isBrowser, isNode, isReactNative, isWeb, platform };
+declare class BlinkConnectorsImpl implements BlinkConnectors {
+    private httpClient;
+    constructor(httpClient: HttpClient);
+    status(provider: ConnectorProvider, options?: {
+        account_id?: string;
+    }): Promise<ConnectorStatusResponse>;
+    execute<TParams = Record<string, unknown>, TData = any>(provider: ConnectorProvider, request: ConnectorExecuteRequest<TParams>): Promise<ConnectorExecuteResponse<TData>>;
+    saveApiKey<TMetadata = Record<string, unknown>>(provider: ConnectorProvider, request: ConnectorApiKeyRequest<TMetadata>): Promise<ConnectorApiKeyResponse>;
+}
+
+export { type AnalyticsEvent, AsyncStorageAdapter, type AuthState, type AuthStateChangeCallback, type AuthTokens, type BlinkAI, BlinkAIImpl, type BlinkAnalytics, BlinkAnalyticsImpl, type BlinkClient, type BlinkClientConfig, BlinkConnectorError, type BlinkConnectors, BlinkConnectorsImpl, type BlinkData, BlinkDataImpl, BlinkDatabase, type BlinkRealtime, BlinkRealtimeChannel, BlinkRealtimeError, BlinkRealtimeImpl, type BlinkStorage, BlinkStorageImpl, BlinkTable, type BlinkUser, type ConnectorApiKeyRequest, type ConnectorApiKeyResponse, type ConnectorAuthMode, type ConnectorExecuteRequest, type ConnectorExecuteResponse, type ConnectorProvider, type ConnectorStatusResponse, type CreateOptions, type DataExtraction, type FileObject, type FilterCondition, type ImageGenerationRequest, type ImageGenerationResponse, type Message, NoOpStorageAdapter, 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 StorageAdapter, type StorageUploadOptions, type StorageUploadResponse, type TableOperations, type TextGenerationRequest, type TextGenerationResponse, type TokenUsage, type TranscriptionRequest, type TranscriptionResponse, type UpdateOptions, type UpsertOptions, type WebBrowserModule, WebStorageAdapter, createClient, getDefaultStorageAdapter, isBrowser, isDeno, isNode, isReactNative, isServer, isWeb, platform };