@blinkdotnew/sdk 0.14.12 → 0.16.0

package/README.md

@@ -201,13 +201,13 @@ const unsubscribe = blink.auth.onAuthStateChanged((state) => {
 
 **🎉 NEW: Automatic Case Conversion!**  
 The SDK now automatically converts between JavaScript camelCase and SQL snake_case:
-- **Write code in camelCase**: `userId`, `createdAt`, `isCompleted`
-- **Stored as snake_case**: `user_id`, `created_at`, `is_completed`
+- **Table names**: `blink.db.emailDrafts` → `email_drafts` table
+- **Field names**: `userId`, `createdAt`, `isCompleted` → `user_id`, `created_at`, `is_completed`
 - **No manual conversion needed!**
 
 **⚠️ Important: Always Use camelCase in Your Code**
-- ✅ **Correct**: `{ userId: user.id, createdAt: new Date() }`
-- ❌ **Wrong**: `{ user_id: user.id, created_at: new Date() }`
+- ✅ **Correct**: `blink.db.emailDrafts.create({ userId: user.id, createdAt: new Date() })`
+- ❌ **Wrong**: `blink.db.email_drafts.create({ user_id: user.id, created_at: new Date() })`
 
 
 ```typescript
@@ -353,12 +353,27 @@ const { object: todoList } = await blink.ai.generateObject({
 // })
 // Error: "schema must be a JSON Schema of 'type: \"object\"', got 'type: \"array\"'"
 
-// Image generation
+// Generate and modify images with AI
+
+// Basic image generation - returns public URLs directly
 const { data } = await blink.ai.generateImage({
-  prompt: 'A serene landscape',
+  prompt: 'A serene landscape with mountains and a lake at sunset',
   size: '1024x1024',
-  quality: 'hd'
+  quality: 'hd',
+  n: 2
+})
+console.log('Image URL:', data[0].url)
+
+// Image editing - transform existing images with prompts
+const { data: headshots } = await blink.ai.modifyImage({
+  images: ['https://storage.example.com/user-photo.jpg'], // ... up to 16 images maximum!
+  prompt: 'Generate professional business headshot with studio lighting for this person.',
+  quality: 'hd',
+  n: 4
 })
+// Options: size ('1024x1024', '1536x1024'), quality ('standard'|'hd'), 
+// background ('auto'|'transparent'|'opaque'), n (1-10 images)
+
 
 // Speech synthesis
 const { url } = await blink.ai.generateSpeech({

package/dist/index.d.mts

@@ -119,8 +119,17 @@ interface FileObject {
 }
 interface BlinkStorage {
     upload(file: File | Blob | Buffer, path: string, options?: StorageUploadOptions): Promise<StorageUploadResponse>;
+    download(path: string, options?: {
+        filename?: string;
+    }): Promise<StorageDownloadResponse>;
     remove(...paths: string[]): Promise<void>;
 }
+interface StorageDownloadResponse {
+    downloadUrl: string;
+    filename: string;
+    contentType?: string;
+    size?: number;
+}
 interface TokenUsage {
     promptTokens: number;
     completionTokens: number;
@@ -211,10 +220,15 @@ interface ObjectGenerationResponse {
 interface ImageGenerationRequest {
     model?: string;
     prompt: string;
+    images?: string[];
     size?: string;
     quality?: 'standard' | 'hd';
+    background?: 'auto' | 'transparent' | 'opaque';
     n?: number;
     response_format?: 'url' | 'b64_json';
+    output_format?: 'png' | 'jpeg' | 'webp';
+    output_compression?: number;
+    moderation?: 'auto' | 'low';
     signal?: AbortSignal;
 }
 interface ImageGenerationResponse {
@@ -273,6 +287,15 @@ interface BlinkAI {
     generateObject(options: ObjectGenerationRequest): Promise<ObjectGenerationResponse>;
     streamObject(options: ObjectGenerationRequest, onPartial: (partial: any) => void): Promise<ObjectGenerationResponse>;
     generateImage(options: ImageGenerationRequest): Promise<ImageGenerationResponse>;
+    modifyImage(options: {
+        images: string[];
+        prompt: string;
+        size?: string;
+        quality?: "standard" | "hd";
+        n?: number;
+        background?: "auto" | "transparent" | "opaque";
+        signal?: AbortSignal;
+    }): Promise<ImageGenerationResponse>;
     generateSpeech(options: SpeechGenerationRequest): Promise<SpeechGenerationResponse>;
     transcribeAudio(options: TranscriptionRequest): Promise<TranscriptionResponse>;
 }
@@ -660,10 +683,15 @@ declare class HttpClient {
     } | undefined, onPartial: (partial: any) => void): Promise<any>;
     aiImage(prompt: string, options?: {
         model?: string;
+        images?: string[];
         size?: string;
         quality?: 'standard' | 'hd';
+        background?: 'auto' | 'transparent' | 'opaque';
         n?: number;
         response_format?: 'url' | 'b64_json';
+        output_format?: 'png' | 'jpeg' | 'webp';
+        output_compression?: number;
+        moderation?: 'auto' | 'low';
         signal?: AbortSignal;
     }): Promise<BlinkResponse<any>>;
     aiSpeech(text: string, options?: {
@@ -834,6 +862,7 @@ declare class BlinkAuth {
 declare class BlinkTable<T = any> implements TableOperations<T> {
     private tableName;
     private httpClient;
+    private readonly actualTableName;
     constructor(tableName: string, httpClient: HttpClient);
     /**
      * Create a single record
@@ -1129,6 +1158,32 @@ declare class BlinkStorageImpl implements BlinkStorage {
      * ```
      */
     upload(file: File | Blob | Buffer, path: string, options?: StorageUploadOptions): Promise<StorageUploadResponse>;
+    /**
+     * Get a download URL for a file that triggers browser download
+     *
+     * @param path - Path to the file in project storage
+     * @param options - Download options including custom filename
+     * @returns Promise resolving to download response with download URL
+     *
+     * @example
+     * ```ts
+     * // Download with original filename
+     * const { downloadUrl, filename } = await blink.storage.download('images/photo.jpg');
+     * window.open(downloadUrl, '_blank');
+     *
+     * // Download with custom filename
+     * const { downloadUrl } = await blink.storage.download(
+     *   'images/photo.jpg',
+     *   { filename: 'my-photo.jpg' }
+     * );
+     *
+     * // Create download link in React
+     * <a href={downloadUrl} download={filename}>Download Image</a>
+     * ```
+     */
+    download(path: string, options?: {
+        filename?: string;
+    }): Promise<StorageDownloadResponse>;
     /**
      * Remove one or more files from project storage
      *
@@ -1361,15 +1416,15 @@ declare class BlinkAIImpl implements BlinkAI {
      */
     streamObject(options: ObjectGenerationRequest, onPartial: (partial: any) => void): Promise<ObjectGenerationResponse>;
     /**
-     * Generates images from text descriptions using AI image models.
+     * Generates images from text descriptions using AI.
      *
      * @param options - Object containing:
-     *   - `prompt`: Text description of the image to generate (required)
-     *   - `size`: Image dimensions (e.g., "1024x1024", "512x512") - varies by model
-     *   - `quality`: Image quality ("standard" or "hd")
+     *   - `prompt`: Text description of the desired image (required)
+     *   - `size`: Image dimensions (default: "1024x1024")
+     *   - `quality`: Image quality ("standard" or "hd", default: "standard")
      *   - `n`: Number of images to generate (default: 1)
-     *   - `response_format`: Output format ("url" or "b64_json")
-     *   - Plus optional model, signal parameters
+     *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+     *   - Plus optional signal parameter
      *
      * @example
      * ```ts
@@ -1382,31 +1437,103 @@ declare class BlinkAIImpl implements BlinkAI {
      * // High-quality image with specific size
      * const { data } = await blink.ai.generateImage({
      *   prompt: "A futuristic city skyline with flying cars",
-     *   size: "1792x1024",
+     *   size: "1536x1024",
      *   quality: "hd",
-     *   model: "dall-e-3"
+     *   background: "transparent"
      * });
      *
      * // Multiple images
      * const { data } = await blink.ai.generateImage({
      *   prompt: "A cute robot mascot for a tech company",
      *   n: 3,
-     *   size: "1024x1024"
+     *   size: "1024x1024",
+     *   quality: "hd"
      * });
      * data.forEach((img, i) => console.log(`Image ${i+1}:`, img.url));
+     * ```
      *
-     * // Base64 format for direct embedding
-     * const { data } = await blink.ai.generateImage({
-     *   prompt: "A minimalist logo design",
-     *   response_format: "b64_json"
+     * @returns Promise<ImageGenerationResponse> - Object containing:
+     *   - `data`: Array of generated images with URLs
+     *   - `created`: Timestamp of generation
+     *   - `usage`: Token usage information
+     */
+    generateImage(options: {
+        prompt: string;
+        size?: string;
+        quality?: "standard" | "hd";
+        n?: number;
+        background?: "auto" | "transparent" | "opaque";
+        signal?: AbortSignal;
+    }): Promise<ImageGenerationResponse>;
+    /**
+     * Modifies existing images using AI with text prompts for image-to-image editing.
+     *
+     * @param options - Object containing:
+     *   - `images`: Array of public image URLs to modify (required, up to 16 images)
+     *   - `prompt`: Text description of desired modifications (required)
+     *   - `size`: Output image dimensions (default: "auto")
+     *   - `quality`: Image quality ("standard" or "hd", default: "standard")
+     *   - `n`: Number of output images to generate (default: 1)
+     *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+     *   - Plus optional signal parameter
+     *
+     * @example
+     * ```ts
+     * // Professional headshots from casual photos
+     * const { data } = await blink.ai.modifyImage({
+     *   images: [
+     *     "https://storage.example.com/user-photo-1.jpg",
+     *     "https://storage.example.com/user-photo-2.jpg"
+     *   ],
+     *   prompt: "Transform into professional business headshots with studio lighting",
+     *   quality: "hd",
+     *   n: 4
+     * });
+     * data.forEach((img, i) => console.log(`Headshot ${i+1}:`, img.url));
+     *
+     * // Artistic style transformation
+     * const { data } = await blink.ai.modifyImage({
+     *   images: ["https://storage.example.com/portrait.jpg"],
+     *   prompt: "Transform into oil painting style with dramatic lighting",
+     *   quality: "hd",
+     *   size: "1024x1024"
+     * });
+     *
+     * // Background replacement
+     * const { data } = await blink.ai.modifyImage({
+     *   images: ["https://storage.example.com/product.jpg"],
+     *   prompt: "Remove background and place on clean white studio background",
+     *   background: "transparent",
+     *   n: 2
+     * });
+     *
+     * // Batch processing multiple photos
+     * const userPhotos = [
+     *   "https://storage.example.com/photo1.jpg",
+     *   "https://storage.example.com/photo2.jpg",
+     *   "https://storage.example.com/photo3.jpg"
+     * ];
+     * const { data } = await blink.ai.modifyImage({
+     *   images: userPhotos,
+     *   prompt: "Convert to black and white vintage style photographs",
+     *   quality: "hd"
      * });
-     * console.log("Base64 data:", data[0].b64_json);
      * ```
      *
      * @returns Promise<ImageGenerationResponse> - Object containing:
-     *   - `data`: Array of generated images with url or b64_json
+     *   - `data`: Array of modified images with URLs
+     *   - `created`: Timestamp of generation
+     *   - `usage`: Token usage information
      */
-    generateImage(options: ImageGenerationRequest): Promise<ImageGenerationResponse>;
+    modifyImage(options: {
+        images: string[];
+        prompt: string;
+        size?: string;
+        quality?: "standard" | "hd";
+        n?: number;
+        background?: "auto" | "transparent" | "opaque";
+        signal?: AbortSignal;
+    }): Promise<ImageGenerationResponse>;
     /**
      * Converts text to speech using AI voice synthesis models.
      *

package/dist/index.d.ts

@@ -119,8 +119,17 @@ interface FileObject {
 }
 interface BlinkStorage {
     upload(file: File | Blob | Buffer, path: string, options?: StorageUploadOptions): Promise<StorageUploadResponse>;
+    download(path: string, options?: {
+        filename?: string;
+    }): Promise<StorageDownloadResponse>;
     remove(...paths: string[]): Promise<void>;
 }
+interface StorageDownloadResponse {
+    downloadUrl: string;
+    filename: string;
+    contentType?: string;
+    size?: number;
+}
 interface TokenUsage {
     promptTokens: number;
     completionTokens: number;
@@ -211,10 +220,15 @@ interface ObjectGenerationResponse {
 interface ImageGenerationRequest {
     model?: string;
     prompt: string;
+    images?: string[];
     size?: string;
     quality?: 'standard' | 'hd';
+    background?: 'auto' | 'transparent' | 'opaque';
     n?: number;
     response_format?: 'url' | 'b64_json';
+    output_format?: 'png' | 'jpeg' | 'webp';
+    output_compression?: number;
+    moderation?: 'auto' | 'low';
     signal?: AbortSignal;
 }
 interface ImageGenerationResponse {
@@ -273,6 +287,15 @@ interface BlinkAI {
     generateObject(options: ObjectGenerationRequest): Promise<ObjectGenerationResponse>;
     streamObject(options: ObjectGenerationRequest, onPartial: (partial: any) => void): Promise<ObjectGenerationResponse>;
     generateImage(options: ImageGenerationRequest): Promise<ImageGenerationResponse>;
+    modifyImage(options: {
+        images: string[];
+        prompt: string;
+        size?: string;
+        quality?: "standard" | "hd";
+        n?: number;
+        background?: "auto" | "transparent" | "opaque";
+        signal?: AbortSignal;
+    }): Promise<ImageGenerationResponse>;
     generateSpeech(options: SpeechGenerationRequest): Promise<SpeechGenerationResponse>;
     transcribeAudio(options: TranscriptionRequest): Promise<TranscriptionResponse>;
 }
@@ -660,10 +683,15 @@ declare class HttpClient {
     } | undefined, onPartial: (partial: any) => void): Promise<any>;
     aiImage(prompt: string, options?: {
         model?: string;
+        images?: string[];
         size?: string;
         quality?: 'standard' | 'hd';
+        background?: 'auto' | 'transparent' | 'opaque';
         n?: number;
         response_format?: 'url' | 'b64_json';
+        output_format?: 'png' | 'jpeg' | 'webp';
+        output_compression?: number;
+        moderation?: 'auto' | 'low';
         signal?: AbortSignal;
     }): Promise<BlinkResponse<any>>;
     aiSpeech(text: string, options?: {
@@ -834,6 +862,7 @@ declare class BlinkAuth {
 declare class BlinkTable<T = any> implements TableOperations<T> {
     private tableName;
     private httpClient;
+    private readonly actualTableName;
     constructor(tableName: string, httpClient: HttpClient);
     /**
      * Create a single record
@@ -1129,6 +1158,32 @@ declare class BlinkStorageImpl implements BlinkStorage {
      * ```
      */
     upload(file: File | Blob | Buffer, path: string, options?: StorageUploadOptions): Promise<StorageUploadResponse>;
+    /**
+     * Get a download URL for a file that triggers browser download
+     *
+     * @param path - Path to the file in project storage
+     * @param options - Download options including custom filename
+     * @returns Promise resolving to download response with download URL
+     *
+     * @example
+     * ```ts
+     * // Download with original filename
+     * const { downloadUrl, filename } = await blink.storage.download('images/photo.jpg');
+     * window.open(downloadUrl, '_blank');
+     *
+     * // Download with custom filename
+     * const { downloadUrl } = await blink.storage.download(
+     *   'images/photo.jpg',
+     *   { filename: 'my-photo.jpg' }
+     * );
+     *
+     * // Create download link in React
+     * <a href={downloadUrl} download={filename}>Download Image</a>
+     * ```
+     */
+    download(path: string, options?: {
+        filename?: string;
+    }): Promise<StorageDownloadResponse>;
     /**
      * Remove one or more files from project storage
      *
@@ -1361,15 +1416,15 @@ declare class BlinkAIImpl implements BlinkAI {
      */
     streamObject(options: ObjectGenerationRequest, onPartial: (partial: any) => void): Promise<ObjectGenerationResponse>;
     /**
-     * Generates images from text descriptions using AI image models.
+     * Generates images from text descriptions using AI.
      *
      * @param options - Object containing:
-     *   - `prompt`: Text description of the image to generate (required)
-     *   - `size`: Image dimensions (e.g., "1024x1024", "512x512") - varies by model
-     *   - `quality`: Image quality ("standard" or "hd")
+     *   - `prompt`: Text description of the desired image (required)
+     *   - `size`: Image dimensions (default: "1024x1024")
+     *   - `quality`: Image quality ("standard" or "hd", default: "standard")
      *   - `n`: Number of images to generate (default: 1)
-     *   - `response_format`: Output format ("url" or "b64_json")
-     *   - Plus optional model, signal parameters
+     *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+     *   - Plus optional signal parameter
      *
      * @example
      * ```ts
@@ -1382,31 +1437,103 @@ declare class BlinkAIImpl implements BlinkAI {
      * // High-quality image with specific size
      * const { data } = await blink.ai.generateImage({
      *   prompt: "A futuristic city skyline with flying cars",
-     *   size: "1792x1024",
+     *   size: "1536x1024",
      *   quality: "hd",
-     *   model: "dall-e-3"
+     *   background: "transparent"
      * });
      *
      * // Multiple images
      * const { data } = await blink.ai.generateImage({
      *   prompt: "A cute robot mascot for a tech company",
      *   n: 3,
-     *   size: "1024x1024"
+     *   size: "1024x1024",
+     *   quality: "hd"
      * });
      * data.forEach((img, i) => console.log(`Image ${i+1}:`, img.url));
+     * ```
      *
-     * // Base64 format for direct embedding
-     * const { data } = await blink.ai.generateImage({
-     *   prompt: "A minimalist logo design",
-     *   response_format: "b64_json"
+     * @returns Promise<ImageGenerationResponse> - Object containing:
+     *   - `data`: Array of generated images with URLs
+     *   - `created`: Timestamp of generation
+     *   - `usage`: Token usage information
+     */
+    generateImage(options: {
+        prompt: string;
+        size?: string;
+        quality?: "standard" | "hd";
+        n?: number;
+        background?: "auto" | "transparent" | "opaque";
+        signal?: AbortSignal;
+    }): Promise<ImageGenerationResponse>;
+    /**
+     * Modifies existing images using AI with text prompts for image-to-image editing.
+     *
+     * @param options - Object containing:
+     *   - `images`: Array of public image URLs to modify (required, up to 16 images)
+     *   - `prompt`: Text description of desired modifications (required)
+     *   - `size`: Output image dimensions (default: "auto")
+     *   - `quality`: Image quality ("standard" or "hd", default: "standard")
+     *   - `n`: Number of output images to generate (default: 1)
+     *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+     *   - Plus optional signal parameter
+     *
+     * @example
+     * ```ts
+     * // Professional headshots from casual photos
+     * const { data } = await blink.ai.modifyImage({
+     *   images: [
+     *     "https://storage.example.com/user-photo-1.jpg",
+     *     "https://storage.example.com/user-photo-2.jpg"
+     *   ],
+     *   prompt: "Transform into professional business headshots with studio lighting",
+     *   quality: "hd",
+     *   n: 4
+     * });
+     * data.forEach((img, i) => console.log(`Headshot ${i+1}:`, img.url));
+     *
+     * // Artistic style transformation
+     * const { data } = await blink.ai.modifyImage({
+     *   images: ["https://storage.example.com/portrait.jpg"],
+     *   prompt: "Transform into oil painting style with dramatic lighting",
+     *   quality: "hd",
+     *   size: "1024x1024"
+     * });
+     *
+     * // Background replacement
+     * const { data } = await blink.ai.modifyImage({
+     *   images: ["https://storage.example.com/product.jpg"],
+     *   prompt: "Remove background and place on clean white studio background",
+     *   background: "transparent",
+     *   n: 2
+     * });
+     *
+     * // Batch processing multiple photos
+     * const userPhotos = [
+     *   "https://storage.example.com/photo1.jpg",
+     *   "https://storage.example.com/photo2.jpg",
+     *   "https://storage.example.com/photo3.jpg"
+     * ];
+     * const { data } = await blink.ai.modifyImage({
+     *   images: userPhotos,
+     *   prompt: "Convert to black and white vintage style photographs",
+     *   quality: "hd"
      * });
-     * console.log("Base64 data:", data[0].b64_json);
      * ```
      *
      * @returns Promise<ImageGenerationResponse> - Object containing:
-     *   - `data`: Array of generated images with url or b64_json
+     *   - `data`: Array of modified images with URLs
+     *   - `created`: Timestamp of generation
+     *   - `usage`: Token usage information
      */
-    generateImage(options: ImageGenerationRequest): Promise<ImageGenerationResponse>;
+    modifyImage(options: {
+        images: string[];
+        prompt: string;
+        size?: string;
+        quality?: "standard" | "hd";
+        n?: number;
+        background?: "auto" | "transparent" | "opaque";
+        signal?: AbortSignal;
+    }): Promise<ImageGenerationResponse>;
     /**
      * Converts text to speech using AI voice synthesis models.
      *

package/dist/index.js

@@ -1530,6 +1530,9 @@ var BlinkAuth = class {
 };
 
 // src/database.ts
+function camelToSnake3(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
 function generateSecureId() {
   if (typeof crypto !== "undefined" && crypto.getRandomValues) {
     const array = new Uint8Array(16);
@@ -1552,14 +1555,16 @@ var BlinkTable = class {
   constructor(tableName, httpClient) {
     this.tableName = tableName;
     this.httpClient = httpClient;
+    this.actualTableName = camelToSnake3(tableName);
   }
+  actualTableName;
   /**
    * Create a single record
    */
   async create(data, options = {}) {
     const record = ensureRecordId(data);
     const response = await this.httpClient.dbPost(
-      this.tableName,
+      this.actualTableName,
       record,
       { returning: options.returning !== false }
     );
@@ -1575,7 +1580,7 @@ var BlinkTable = class {
   async createMany(data, options = {}) {
     const records = data.map(ensureRecordId);
     const response = await this.httpClient.dbPost(
-      this.tableName,
+      this.actualTableName,
       records,
       { returning: options.returning !== false }
     );
@@ -1595,7 +1600,7 @@ var BlinkTable = class {
     }
     const record = ensureRecordId(data);
     const response = await this.httpClient.request(
-      `/api/db/${this.httpClient.projectId}/rest/v1/${this.tableName}?on_conflict=${options.onConflict || "id"}`,
+      `/api/db/${this.httpClient.projectId}/rest/v1/${this.actualTableName}?on_conflict=${options.onConflict || "id"}`,
       {
         method: "POST",
         body: record,
@@ -1621,7 +1626,7 @@ var BlinkTable = class {
       headers["Prefer"] = `${headers["Prefer"] || ""} resolution=merge-duplicates`.trim();
     }
     const response = await this.httpClient.request(
-      `/api/db/${this.httpClient.projectId}/rest/v1/${this.tableName}?on_conflict=${options.onConflict || "id"}`,
+      `/api/db/${this.httpClient.projectId}/rest/v1/${this.actualTableName}?on_conflict=${options.onConflict || "id"}`,
       {
         method: "POST",
         body: records,
@@ -1639,7 +1644,7 @@ var BlinkTable = class {
       id: `eq.${id}`,
       limit: "1"
     };
-    const response = await this.httpClient.dbGet(this.tableName, searchParams);
+    const response = await this.httpClient.dbGet(this.actualTableName, searchParams);
     const records = response.data;
     if (records.length === 0) {
       return null;
@@ -1652,7 +1657,7 @@ var BlinkTable = class {
   async list(options = {}) {
     const queryParams = buildQuery(options);
     const searchParams = queryParams;
-    const response = await this.httpClient.dbGet(this.tableName, searchParams);
+    const response = await this.httpClient.dbGet(this.actualTableName, searchParams);
     const records = response.data;
     return records;
   }
@@ -1664,7 +1669,7 @@ var BlinkTable = class {
       id: `eq.${id}`
     };
     const response = await this.httpClient.dbPatch(
-      this.tableName,
+      this.actualTableName,
       data,
       searchParams,
       { returning: options.returning !== false }
@@ -1694,7 +1699,7 @@ var BlinkTable = class {
     const searchParams = {
       id: `eq.${id}`
     };
-    await this.httpClient.dbDelete(this.tableName, searchParams);
+    await this.httpClient.dbDelete(this.actualTableName, searchParams);
   }
   /**
    * Delete multiple records based on filter
@@ -1702,7 +1707,7 @@ var BlinkTable = class {
   async deleteMany(options) {
     const queryParams = buildQuery({ where: options.where });
     const searchParams = queryParams;
-    await this.httpClient.dbDelete(this.tableName, searchParams);
+    await this.httpClient.dbDelete(this.actualTableName, searchParams);
   }
   /**
    * Count records matching filter
@@ -1713,7 +1718,7 @@ var BlinkTable = class {
       select: ["id"]
     });
     const response = await this.httpClient.request(
-      `/api/db/${this.httpClient.projectId}/rest/v1/${this.tableName}`,
+      `/api/db/${this.httpClient.projectId}/rest/v1/${this.actualTableName}`,
       {
         method: "GET",
         searchParams: queryParams,
@@ -1882,6 +1887,74 @@ var BlinkStorageImpl = class {
       );
     }
   }
+  /**
+   * Get a download URL for a file that triggers browser download
+   * 
+   * @param path - Path to the file in project storage
+   * @param options - Download options including custom filename
+   * @returns Promise resolving to download response with download URL
+   * 
+   * @example
+   * ```ts
+   * // Download with original filename
+   * const { downloadUrl, filename } = await blink.storage.download('images/photo.jpg');
+   * window.open(downloadUrl, '_blank');
+   * 
+   * // Download with custom filename
+   * const { downloadUrl } = await blink.storage.download(
+   *   'images/photo.jpg',
+   *   { filename: 'my-photo.jpg' }
+   * );
+   * 
+   * // Create download link in React
+   * <a href={downloadUrl} download={filename}>Download Image</a>
+   * ```
+   */
+  async download(path, options = {}) {
+    try {
+      if (!path || typeof path !== "string" || !path.trim()) {
+        throw new BlinkStorageError("Path must be a non-empty string");
+      }
+      const response = await this.httpClient.request(
+        `/api/storage/${this.httpClient.projectId}/download`,
+        {
+          method: "GET",
+          searchParams: {
+            path: path.trim(),
+            ...options.filename && { filename: options.filename }
+          }
+        }
+      );
+      if (response.data?.downloadUrl) {
+        return {
+          downloadUrl: response.data.downloadUrl,
+          filename: response.data.filename || options.filename || path.split("/").pop() || "download",
+          contentType: response.data.contentType,
+          size: response.data.size
+        };
+      } else {
+        throw new BlinkStorageError("Invalid response format: missing downloadUrl");
+      }
+    } catch (error) {
+      if (error instanceof BlinkStorageError) {
+        throw error;
+      }
+      if (error instanceof Error && "status" in error) {
+        const status = error.status;
+        if (status === 404) {
+          throw new BlinkStorageError("File not found", 404);
+        }
+        if (status === 400) {
+          throw new BlinkStorageError("Invalid request parameters", 400);
+        }
+      }
+      throw new BlinkStorageError(
+        `Download failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
   /**
    * Remove one or more files from project storage
    * 
@@ -2349,15 +2422,15 @@ var BlinkAIImpl = class {
     }
   }
   /**
-   * Generates images from text descriptions using AI image models.
+   * Generates images from text descriptions using AI.
    * 
    * @param options - Object containing:
-   *   - `prompt`: Text description of the image to generate (required)
-   *   - `size`: Image dimensions (e.g., "1024x1024", "512x512") - varies by model
-   *   - `quality`: Image quality ("standard" or "hd")
+   *   - `prompt`: Text description of the desired image (required)
+   *   - `size`: Image dimensions (default: "1024x1024")
+   *   - `quality`: Image quality ("standard" or "hd", default: "standard")
    *   - `n`: Number of images to generate (default: 1)
-   *   - `response_format`: Output format ("url" or "b64_json")
-   *   - Plus optional model, signal parameters
+   *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+   *   - Plus optional signal parameter
    * 
    * @example
    * ```ts
@@ -2370,29 +2443,25 @@ var BlinkAIImpl = class {
    * // High-quality image with specific size
    * const { data } = await blink.ai.generateImage({
    *   prompt: "A futuristic city skyline with flying cars",
-   *   size: "1792x1024",
+   *   size: "1536x1024",
    *   quality: "hd",
-   *   model: "dall-e-3"
+   *   background: "transparent"
    * });
    * 
    * // Multiple images
    * const { data } = await blink.ai.generateImage({
    *   prompt: "A cute robot mascot for a tech company",
    *   n: 3,
-   *   size: "1024x1024"
+   *   size: "1024x1024",
+   *   quality: "hd"
    * });
    * data.forEach((img, i) => console.log(`Image ${i+1}:`, img.url));
-   * 
-   * // Base64 format for direct embedding
-   * const { data } = await blink.ai.generateImage({
-   *   prompt: "A minimalist logo design",
-   *   response_format: "b64_json"
-   * });
-   * console.log("Base64 data:", data[0].b64_json);
    * ```
    * 
    * @returns Promise<ImageGenerationResponse> - Object containing:
-   *   - `data`: Array of generated images with url or b64_json
+   *   - `data`: Array of generated images with URLs
+   *   - `created`: Timestamp of generation
+   *   - `usage`: Token usage information
    */
   async generateImage(options) {
     try {
@@ -2402,11 +2471,12 @@ var BlinkAIImpl = class {
       const response = await this.httpClient.aiImage(
         options.prompt,
         {
-          model: options.model,
+          model: "gpt-image-1",
           size: options.size,
           quality: options.quality,
           n: options.n,
-          response_format: options.response_format,
+          background: options.background,
+          response_format: "url",
           signal: options.signal
         }
       );
@@ -2426,10 +2496,8 @@ var BlinkAIImpl = class {
           return { url: item };
         } else if (item.url) {
           return item;
-        } else if (item.b64_json) {
-          return { b64_json: item.b64_json };
         } else {
-          return { url: item };
+          throw new BlinkAIError("Invalid image response format");
         }
       });
       return imageResponse;
@@ -2444,6 +2512,129 @@ var BlinkAIImpl = class {
       );
     }
   }
+  /**
+   * Modifies existing images using AI with text prompts for image-to-image editing.
+   * 
+   * @param options - Object containing:
+   *   - `images`: Array of public image URLs to modify (required, up to 16 images)
+   *   - `prompt`: Text description of desired modifications (required)
+   *   - `size`: Output image dimensions (default: "auto")
+   *   - `quality`: Image quality ("standard" or "hd", default: "standard")
+   *   - `n`: Number of output images to generate (default: 1)
+   *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+   *   - Plus optional signal parameter
+   * 
+   * @example
+   * ```ts
+   * // Professional headshots from casual photos
+   * const { data } = await blink.ai.modifyImage({
+   *   images: [
+   *     "https://storage.example.com/user-photo-1.jpg",
+   *     "https://storage.example.com/user-photo-2.jpg"
+   *   ],
+   *   prompt: "Transform into professional business headshots with studio lighting",
+   *   quality: "hd",
+   *   n: 4
+   * });
+   * data.forEach((img, i) => console.log(`Headshot ${i+1}:`, img.url));
+   * 
+   * // Artistic style transformation
+   * const { data } = await blink.ai.modifyImage({
+   *   images: ["https://storage.example.com/portrait.jpg"],
+   *   prompt: "Transform into oil painting style with dramatic lighting",
+   *   quality: "hd",
+   *   size: "1024x1024"
+   * });
+   * 
+   * // Background replacement
+   * const { data } = await blink.ai.modifyImage({
+   *   images: ["https://storage.example.com/product.jpg"],
+   *   prompt: "Remove background and place on clean white studio background",
+   *   background: "transparent",
+   *   n: 2
+   * });
+   * 
+   * // Batch processing multiple photos
+   * const userPhotos = [
+   *   "https://storage.example.com/photo1.jpg",
+   *   "https://storage.example.com/photo2.jpg",
+   *   "https://storage.example.com/photo3.jpg"
+   * ];
+   * const { data } = await blink.ai.modifyImage({
+   *   images: userPhotos,
+   *   prompt: "Convert to black and white vintage style photographs",
+   *   quality: "hd"
+   * });
+   * ```
+   * 
+   * @returns Promise<ImageGenerationResponse> - Object containing:
+   *   - `data`: Array of modified images with URLs
+   *   - `created`: Timestamp of generation
+   *   - `usage`: Token usage information
+   */
+  async modifyImage(options) {
+    try {
+      if (!options.prompt) {
+        throw new BlinkAIError("Prompt is required");
+      }
+      if (!options.images || !Array.isArray(options.images) || options.images.length === 0) {
+        throw new BlinkAIError("Images array is required and must contain at least one image URL");
+      }
+      if (options.images.length > 16) {
+        throw new BlinkAIError("Maximum 16 images allowed");
+      }
+      for (let i = 0; i < options.images.length; i++) {
+        const validation = this.validateImageUrl(options.images[i]);
+        if (!validation.isValid) {
+          throw new BlinkAIError(`Image ${i + 1}: ${validation.error}`);
+        }
+      }
+      const response = await this.httpClient.aiImage(
+        options.prompt,
+        // Non-null assertion since we validated above
+        {
+          model: "gpt-image-1",
+          images: options.images,
+          size: options.size,
+          quality: options.quality,
+          n: options.n,
+          background: options.background,
+          response_format: "url",
+          signal: options.signal
+        }
+      );
+      let imageResponse;
+      if (response.data?.result?.data) {
+        imageResponse = response.data.result;
+      } else if (response.data?.data) {
+        imageResponse = response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing image data");
+      }
+      if (!Array.isArray(imageResponse.data)) {
+        throw new BlinkAIError("Invalid response format: data should be an array");
+      }
+      imageResponse.data = imageResponse.data.map((item) => {
+        if (typeof item === "string") {
+          return { url: item };
+        } else if (item.url) {
+          return item;
+        } else {
+          throw new BlinkAIError("Invalid image response format");
+        }
+      });
+      return imageResponse;
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Image modification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
   /**
    * Converts text to speech using AI voice synthesis models.
    * 

package/dist/index.mjs

@@ -1528,6 +1528,9 @@ var BlinkAuth = class {
 };
 
 // src/database.ts
+function camelToSnake3(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
 function generateSecureId() {
   if (typeof crypto !== "undefined" && crypto.getRandomValues) {
     const array = new Uint8Array(16);
@@ -1550,14 +1553,16 @@ var BlinkTable = class {
   constructor(tableName, httpClient) {
     this.tableName = tableName;
     this.httpClient = httpClient;
+    this.actualTableName = camelToSnake3(tableName);
   }
+  actualTableName;
   /**
    * Create a single record
    */
   async create(data, options = {}) {
     const record = ensureRecordId(data);
     const response = await this.httpClient.dbPost(
-      this.tableName,
+      this.actualTableName,
       record,
       { returning: options.returning !== false }
     );
@@ -1573,7 +1578,7 @@ var BlinkTable = class {
   async createMany(data, options = {}) {
     const records = data.map(ensureRecordId);
     const response = await this.httpClient.dbPost(
-      this.tableName,
+      this.actualTableName,
       records,
       { returning: options.returning !== false }
     );
@@ -1593,7 +1598,7 @@ var BlinkTable = class {
     }
     const record = ensureRecordId(data);
     const response = await this.httpClient.request(
-      `/api/db/${this.httpClient.projectId}/rest/v1/${this.tableName}?on_conflict=${options.onConflict || "id"}`,
+      `/api/db/${this.httpClient.projectId}/rest/v1/${this.actualTableName}?on_conflict=${options.onConflict || "id"}`,
       {
         method: "POST",
         body: record,
@@ -1619,7 +1624,7 @@ var BlinkTable = class {
       headers["Prefer"] = `${headers["Prefer"] || ""} resolution=merge-duplicates`.trim();
     }
     const response = await this.httpClient.request(
-      `/api/db/${this.httpClient.projectId}/rest/v1/${this.tableName}?on_conflict=${options.onConflict || "id"}`,
+      `/api/db/${this.httpClient.projectId}/rest/v1/${this.actualTableName}?on_conflict=${options.onConflict || "id"}`,
       {
         method: "POST",
         body: records,
@@ -1637,7 +1642,7 @@ var BlinkTable = class {
       id: `eq.${id}`,
       limit: "1"
     };
-    const response = await this.httpClient.dbGet(this.tableName, searchParams);
+    const response = await this.httpClient.dbGet(this.actualTableName, searchParams);
     const records = response.data;
     if (records.length === 0) {
       return null;
@@ -1650,7 +1655,7 @@ var BlinkTable = class {
   async list(options = {}) {
     const queryParams = buildQuery(options);
     const searchParams = queryParams;
-    const response = await this.httpClient.dbGet(this.tableName, searchParams);
+    const response = await this.httpClient.dbGet(this.actualTableName, searchParams);
     const records = response.data;
     return records;
   }
@@ -1662,7 +1667,7 @@ var BlinkTable = class {
       id: `eq.${id}`
     };
     const response = await this.httpClient.dbPatch(
-      this.tableName,
+      this.actualTableName,
       data,
       searchParams,
       { returning: options.returning !== false }
@@ -1692,7 +1697,7 @@ var BlinkTable = class {
     const searchParams = {
       id: `eq.${id}`
     };
-    await this.httpClient.dbDelete(this.tableName, searchParams);
+    await this.httpClient.dbDelete(this.actualTableName, searchParams);
   }
   /**
    * Delete multiple records based on filter
@@ -1700,7 +1705,7 @@ var BlinkTable = class {
   async deleteMany(options) {
     const queryParams = buildQuery({ where: options.where });
     const searchParams = queryParams;
-    await this.httpClient.dbDelete(this.tableName, searchParams);
+    await this.httpClient.dbDelete(this.actualTableName, searchParams);
   }
   /**
    * Count records matching filter
@@ -1711,7 +1716,7 @@ var BlinkTable = class {
       select: ["id"]
     });
     const response = await this.httpClient.request(
-      `/api/db/${this.httpClient.projectId}/rest/v1/${this.tableName}`,
+      `/api/db/${this.httpClient.projectId}/rest/v1/${this.actualTableName}`,
       {
         method: "GET",
         searchParams: queryParams,
@@ -1880,6 +1885,74 @@ var BlinkStorageImpl = class {
       );
     }
   }
+  /**
+   * Get a download URL for a file that triggers browser download
+   * 
+   * @param path - Path to the file in project storage
+   * @param options - Download options including custom filename
+   * @returns Promise resolving to download response with download URL
+   * 
+   * @example
+   * ```ts
+   * // Download with original filename
+   * const { downloadUrl, filename } = await blink.storage.download('images/photo.jpg');
+   * window.open(downloadUrl, '_blank');
+   * 
+   * // Download with custom filename
+   * const { downloadUrl } = await blink.storage.download(
+   *   'images/photo.jpg',
+   *   { filename: 'my-photo.jpg' }
+   * );
+   * 
+   * // Create download link in React
+   * <a href={downloadUrl} download={filename}>Download Image</a>
+   * ```
+   */
+  async download(path, options = {}) {
+    try {
+      if (!path || typeof path !== "string" || !path.trim()) {
+        throw new BlinkStorageError("Path must be a non-empty string");
+      }
+      const response = await this.httpClient.request(
+        `/api/storage/${this.httpClient.projectId}/download`,
+        {
+          method: "GET",
+          searchParams: {
+            path: path.trim(),
+            ...options.filename && { filename: options.filename }
+          }
+        }
+      );
+      if (response.data?.downloadUrl) {
+        return {
+          downloadUrl: response.data.downloadUrl,
+          filename: response.data.filename || options.filename || path.split("/").pop() || "download",
+          contentType: response.data.contentType,
+          size: response.data.size
+        };
+      } else {
+        throw new BlinkStorageError("Invalid response format: missing downloadUrl");
+      }
+    } catch (error) {
+      if (error instanceof BlinkStorageError) {
+        throw error;
+      }
+      if (error instanceof Error && "status" in error) {
+        const status = error.status;
+        if (status === 404) {
+          throw new BlinkStorageError("File not found", 404);
+        }
+        if (status === 400) {
+          throw new BlinkStorageError("Invalid request parameters", 400);
+        }
+      }
+      throw new BlinkStorageError(
+        `Download failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
   /**
    * Remove one or more files from project storage
    * 
@@ -2347,15 +2420,15 @@ var BlinkAIImpl = class {
     }
   }
   /**
-   * Generates images from text descriptions using AI image models.
+   * Generates images from text descriptions using AI.
    * 
    * @param options - Object containing:
-   *   - `prompt`: Text description of the image to generate (required)
-   *   - `size`: Image dimensions (e.g., "1024x1024", "512x512") - varies by model
-   *   - `quality`: Image quality ("standard" or "hd")
+   *   - `prompt`: Text description of the desired image (required)
+   *   - `size`: Image dimensions (default: "1024x1024")
+   *   - `quality`: Image quality ("standard" or "hd", default: "standard")
    *   - `n`: Number of images to generate (default: 1)
-   *   - `response_format`: Output format ("url" or "b64_json")
-   *   - Plus optional model, signal parameters
+   *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+   *   - Plus optional signal parameter
    * 
    * @example
    * ```ts
@@ -2368,29 +2441,25 @@ var BlinkAIImpl = class {
    * // High-quality image with specific size
    * const { data } = await blink.ai.generateImage({
    *   prompt: "A futuristic city skyline with flying cars",
-   *   size: "1792x1024",
+   *   size: "1536x1024",
    *   quality: "hd",
-   *   model: "dall-e-3"
+   *   background: "transparent"
    * });
    * 
    * // Multiple images
    * const { data } = await blink.ai.generateImage({
    *   prompt: "A cute robot mascot for a tech company",
    *   n: 3,
-   *   size: "1024x1024"
+   *   size: "1024x1024",
+   *   quality: "hd"
    * });
    * data.forEach((img, i) => console.log(`Image ${i+1}:`, img.url));
-   * 
-   * // Base64 format for direct embedding
-   * const { data } = await blink.ai.generateImage({
-   *   prompt: "A minimalist logo design",
-   *   response_format: "b64_json"
-   * });
-   * console.log("Base64 data:", data[0].b64_json);
    * ```
    * 
    * @returns Promise<ImageGenerationResponse> - Object containing:
-   *   - `data`: Array of generated images with url or b64_json
+   *   - `data`: Array of generated images with URLs
+   *   - `created`: Timestamp of generation
+   *   - `usage`: Token usage information
    */
   async generateImage(options) {
     try {
@@ -2400,11 +2469,12 @@ var BlinkAIImpl = class {
       const response = await this.httpClient.aiImage(
         options.prompt,
         {
-          model: options.model,
+          model: "gpt-image-1",
           size: options.size,
           quality: options.quality,
           n: options.n,
-          response_format: options.response_format,
+          background: options.background,
+          response_format: "url",
           signal: options.signal
         }
       );
@@ -2424,10 +2494,8 @@ var BlinkAIImpl = class {
           return { url: item };
         } else if (item.url) {
           return item;
-        } else if (item.b64_json) {
-          return { b64_json: item.b64_json };
         } else {
-          return { url: item };
+          throw new BlinkAIError("Invalid image response format");
         }
       });
       return imageResponse;
@@ -2442,6 +2510,129 @@ var BlinkAIImpl = class {
       );
     }
   }
+  /**
+   * Modifies existing images using AI with text prompts for image-to-image editing.
+   * 
+   * @param options - Object containing:
+   *   - `images`: Array of public image URLs to modify (required, up to 16 images)
+   *   - `prompt`: Text description of desired modifications (required)
+   *   - `size`: Output image dimensions (default: "auto")
+   *   - `quality`: Image quality ("standard" or "hd", default: "standard")
+   *   - `n`: Number of output images to generate (default: 1)
+   *   - `background`: Background handling ("auto", "transparent", "opaque", default: "auto")
+   *   - Plus optional signal parameter
+   * 
+   * @example
+   * ```ts
+   * // Professional headshots from casual photos
+   * const { data } = await blink.ai.modifyImage({
+   *   images: [
+   *     "https://storage.example.com/user-photo-1.jpg",
+   *     "https://storage.example.com/user-photo-2.jpg"
+   *   ],
+   *   prompt: "Transform into professional business headshots with studio lighting",
+   *   quality: "hd",
+   *   n: 4
+   * });
+   * data.forEach((img, i) => console.log(`Headshot ${i+1}:`, img.url));
+   * 
+   * // Artistic style transformation
+   * const { data } = await blink.ai.modifyImage({
+   *   images: ["https://storage.example.com/portrait.jpg"],
+   *   prompt: "Transform into oil painting style with dramatic lighting",
+   *   quality: "hd",
+   *   size: "1024x1024"
+   * });
+   * 
+   * // Background replacement
+   * const { data } = await blink.ai.modifyImage({
+   *   images: ["https://storage.example.com/product.jpg"],
+   *   prompt: "Remove background and place on clean white studio background",
+   *   background: "transparent",
+   *   n: 2
+   * });
+   * 
+   * // Batch processing multiple photos
+   * const userPhotos = [
+   *   "https://storage.example.com/photo1.jpg",
+   *   "https://storage.example.com/photo2.jpg",
+   *   "https://storage.example.com/photo3.jpg"
+   * ];
+   * const { data } = await blink.ai.modifyImage({
+   *   images: userPhotos,
+   *   prompt: "Convert to black and white vintage style photographs",
+   *   quality: "hd"
+   * });
+   * ```
+   * 
+   * @returns Promise<ImageGenerationResponse> - Object containing:
+   *   - `data`: Array of modified images with URLs
+   *   - `created`: Timestamp of generation
+   *   - `usage`: Token usage information
+   */
+  async modifyImage(options) {
+    try {
+      if (!options.prompt) {
+        throw new BlinkAIError("Prompt is required");
+      }
+      if (!options.images || !Array.isArray(options.images) || options.images.length === 0) {
+        throw new BlinkAIError("Images array is required and must contain at least one image URL");
+      }
+      if (options.images.length > 16) {
+        throw new BlinkAIError("Maximum 16 images allowed");
+      }
+      for (let i = 0; i < options.images.length; i++) {
+        const validation = this.validateImageUrl(options.images[i]);
+        if (!validation.isValid) {
+          throw new BlinkAIError(`Image ${i + 1}: ${validation.error}`);
+        }
+      }
+      const response = await this.httpClient.aiImage(
+        options.prompt,
+        // Non-null assertion since we validated above
+        {
+          model: "gpt-image-1",
+          images: options.images,
+          size: options.size,
+          quality: options.quality,
+          n: options.n,
+          background: options.background,
+          response_format: "url",
+          signal: options.signal
+        }
+      );
+      let imageResponse;
+      if (response.data?.result?.data) {
+        imageResponse = response.data.result;
+      } else if (response.data?.data) {
+        imageResponse = response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing image data");
+      }
+      if (!Array.isArray(imageResponse.data)) {
+        throw new BlinkAIError("Invalid response format: data should be an array");
+      }
+      imageResponse.data = imageResponse.data.map((item) => {
+        if (typeof item === "string") {
+          return { url: item };
+        } else if (item.url) {
+          return item;
+        } else {
+          throw new BlinkAIError("Invalid image response format");
+        }
+      });
+      return imageResponse;
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Image modification failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
   /**
    * Converts text to speech using AI voice synthesis models.
    * 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blinkdotnew/sdk",
-  "version": "0.14.12",
+  "version": "0.16.0",
   "description": "Blink TypeScript SDK for client-side applications - Zero-boilerplate CRUD + auth + AI + analytics + notifications for modern SaaS/AI apps",
   "keywords": [
     "blink",
@@ -50,7 +50,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@blink/core": "workspace:*",
+    "@blink/core": "0.4.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
   },