@blinkdotnew/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2230 @@
+'use strict';
+
+// ../core/src/types.ts
+var BlinkError = class extends Error {
+  constructor(message, code, status, details) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.name = "BlinkError";
+  }
+};
+var BlinkAuthError = class extends BlinkError {
+  constructor(message, details) {
+    super(message, "AUTH_ERROR", 401, details);
+    this.name = "BlinkAuthError";
+  }
+};
+var BlinkNetworkError = class extends BlinkError {
+  constructor(message, status, details) {
+    super(message, "NETWORK_ERROR", status, details);
+    this.name = "BlinkNetworkError";
+  }
+};
+var BlinkValidationError = class extends BlinkError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", 400, details);
+    this.name = "BlinkValidationError";
+  }
+};
+var BlinkStorageError = class extends BlinkError {
+  constructor(message, status, details) {
+    super(message, "STORAGE_ERROR", status, details);
+    this.name = "BlinkStorageError";
+  }
+};
+var BlinkAIError = class extends BlinkError {
+  constructor(message, status, details) {
+    super(message, "AI_ERROR", status, details);
+    this.name = "BlinkAIError";
+  }
+};
+
+// ../core/src/query-builder.ts
+function buildFilterQuery(condition) {
+  if (!condition) return "";
+  if ("AND" in condition) {
+    const andConditions = condition.AND?.map(buildFilterQuery).filter(Boolean) || [];
+    return andConditions.length > 0 ? `and=(${andConditions.join(",")})` : "";
+  }
+  if ("OR" in condition) {
+    const orConditions = condition.OR?.map(buildFilterQuery).filter(Boolean) || [];
+    return orConditions.length > 0 ? `or=(${orConditions.join(",")})` : "";
+  }
+  const params = [];
+  for (const [field, value] of Object.entries(condition)) {
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "object" && !Array.isArray(value)) {
+      for (const [operator, operatorValue] of Object.entries(value)) {
+        const param = buildOperatorQuery(field, operator, operatorValue);
+        if (param) params.push(param);
+      }
+    } else {
+      params.push(`${field}=eq.${encodeQueryValue(value)}`);
+    }
+  }
+  return params.join("&");
+}
+function buildOperatorQuery(field, operator, value) {
+  switch (operator) {
+    case "eq":
+      return `${field}=eq.${encodeQueryValue(value)}`;
+    case "neq":
+      return `${field}=neq.${encodeQueryValue(value)}`;
+    case "gt":
+      return `${field}=gt.${encodeQueryValue(value)}`;
+    case "gte":
+      return `${field}=gte.${encodeQueryValue(value)}`;
+    case "lt":
+      return `${field}=lt.${encodeQueryValue(value)}`;
+    case "lte":
+      return `${field}=lte.${encodeQueryValue(value)}`;
+    case "like":
+      return `${field}=like.${encodeQueryValue(value)}`;
+    case "ilike":
+      return `${field}=ilike.${encodeQueryValue(value)}`;
+    case "is":
+      return `${field}=is.${value === null ? "null" : encodeQueryValue(value)}`;
+    case "not":
+      return `${field}=not.${encodeQueryValue(value)}`;
+    case "in":
+      if (Array.isArray(value)) {
+        const values = value.map(encodeQueryValue).join(",");
+        return `${field}=in.(${values})`;
+      }
+      return "";
+    case "not_in":
+      if (Array.isArray(value)) {
+        const values = value.map(encodeQueryValue).join(",");
+        return `${field}=not.in.(${values})`;
+      }
+      return "";
+    default:
+      return "";
+  }
+}
+function encodeQueryValue(value) {
+  if (value === null) return "null";
+  if (typeof value === "boolean") {
+    return value ? "1" : "0";
+  }
+  if (typeof value === "number") return value.toString();
+  return encodeURIComponent(String(value));
+}
+function buildQuery(options = {}) {
+  const params = {};
+  if (options.select && options.select.length > 0) {
+    params.select = options.select.join(",");
+  } else {
+    params.select = "*";
+  }
+  if (options.where) {
+    const filterQuery = buildFilterQuery(options.where);
+    if (filterQuery) {
+      const filterParams = filterQuery.split("&");
+      for (const param of filterParams) {
+        const [key, value] = param.split("=", 2);
+        if (key && value) {
+          params[key] = value;
+        }
+      }
+    }
+  }
+  if (options.orderBy) {
+    if (typeof options.orderBy === "string") {
+      params.order = options.orderBy;
+    } else {
+      const orderClauses = Object.entries(options.orderBy).map(([field, direction]) => `${field}.${direction}`);
+      params.order = orderClauses.join(",");
+    }
+  }
+  if (options.limit !== void 0) {
+    params.limit = options.limit.toString();
+  }
+  if (options.offset !== void 0) {
+    params.offset = options.offset.toString();
+  }
+  if (options.cursor) {
+    params.cursor = options.cursor;
+  }
+  return params;
+}
+
+// ../core/src/http-client.ts
+var HttpClient = class {
+  authUrl = "https://blink.new";
+  coreUrl = "https://core.blink.new";
+  projectId;
+  getToken;
+  getValidToken;
+  constructor(config, getToken, getValidToken) {
+    this.projectId = config.projectId;
+    this.getToken = getToken;
+    this.getValidToken = getValidToken;
+  }
+  /**
+   * Make an authenticated request to the Blink API
+   */
+  async request(path, options = {}) {
+    const url = this.buildUrl(path, options.searchParams);
+    const token = this.getValidToken ? await this.getValidToken() : this.getToken();
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const requestInit = {
+      method: options.method || "GET",
+      headers,
+      signal: options.signal
+    };
+    if (options.body && options.method !== "GET") {
+      requestInit.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
+    }
+    try {
+      const response = await fetch(url, requestInit);
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const data = await this.parseResponse(response);
+      return {
+        data,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      if (error instanceof BlinkError) {
+        throw error;
+      }
+      throw new BlinkNetworkError(
+        `Network request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * GET request
+   */
+  async get(path, searchParams) {
+    return this.request(path, { method: "GET", searchParams });
+  }
+  /**
+   * POST request
+   */
+  async post(path, body, headers) {
+    return this.request(path, { method: "POST", body, headers });
+  }
+  /**
+   * PATCH request
+   */
+  async patch(path, body, headers) {
+    return this.request(path, { method: "PATCH", body, headers });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(path, searchParams) {
+    return this.request(path, { method: "DELETE", searchParams });
+  }
+  /**
+   * Database-specific requests
+   */
+  // Table operations (PostgREST-compatible)
+  async dbGet(table, searchParams) {
+    return this.get(`/api/db/${this.projectId}/rest/v1/${table}`, searchParams);
+  }
+  async dbPost(table, body, options = {}) {
+    const headers = {};
+    if (options.returning) {
+      headers.Prefer = "return=representation";
+    }
+    return this.post(`/api/db/${this.projectId}/rest/v1/${table}`, body, headers);
+  }
+  async dbPatch(table, body, searchParams, options = {}) {
+    const headers = {};
+    if (options.returning) {
+      headers.Prefer = "return=representation";
+    }
+    return this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
+      method: "PATCH",
+      body,
+      headers,
+      searchParams
+    });
+  }
+  async dbDelete(table, searchParams, options = {}) {
+    const headers = {};
+    if (options.returning) {
+      headers.Prefer = "return=representation";
+    }
+    return this.request(`/api/db/${this.projectId}/rest/v1/${table}`, {
+      method: "DELETE",
+      headers,
+      searchParams
+    });
+  }
+  // Raw SQL operations
+  async dbSql(query, params) {
+    return this.post(`/api/db/${this.projectId}/sql`, { query, params });
+  }
+  // Batch SQL operations
+  async dbBatch(statements, mode = "write") {
+    return this.post(`/api/db/${this.projectId}/batch`, { statements, mode });
+  }
+  /**
+   * Upload file with progress tracking
+   */
+  async uploadFile(path, file, filePath, options = {}) {
+    const url = this.buildUrl(path);
+    const token = this.getValidToken ? await this.getValidToken() : this.getToken();
+    const formData = new FormData();
+    if (file instanceof File) {
+      formData.append("file", file);
+    } else if (file instanceof Blob) {
+      formData.append("file", file);
+    } else if (typeof Buffer !== "undefined" && file instanceof Buffer) {
+      const blob = new Blob([file]);
+      formData.append("file", blob);
+    } else {
+      throw new BlinkValidationError("Unsupported file type");
+    }
+    formData.append("path", filePath);
+    if (options.upsert !== void 0) {
+      formData.append("options", JSON.stringify({ upsert: options.upsert }));
+    }
+    const headers = {};
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    try {
+      if (typeof XMLHttpRequest !== "undefined" && options.onProgress) {
+        return this.uploadWithProgress(url, formData, headers, options.onProgress);
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: formData
+      });
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const data = await this.parseResponse(response);
+      return {
+        data,
+        status: response.status,
+        headers: response.headers
+      };
+    } catch (error) {
+      if (error instanceof BlinkError) {
+        throw error;
+      }
+      throw new BlinkNetworkError(
+        `File upload failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Upload with progress tracking using XMLHttpRequest
+   */
+  uploadWithProgress(url, formData, headers, onProgress) {
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.upload.addEventListener("progress", (event) => {
+        if (event.lengthComputable) {
+          const percent = Math.round(event.loaded / event.total * 100);
+          onProgress(percent);
+        }
+      });
+      xhr.addEventListener("load", async () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          try {
+            const data = JSON.parse(xhr.responseText);
+            resolve({
+              data,
+              status: xhr.status,
+              headers: new Headers()
+              // XMLHttpRequest doesn't provide easy access to response headers
+            });
+          } catch (error) {
+            reject(new BlinkNetworkError("Failed to parse response", xhr.status));
+          }
+        } else {
+          try {
+            const errorData = JSON.parse(xhr.responseText);
+            const message = errorData.error?.message || errorData.message || `HTTP ${xhr.status}`;
+            switch (xhr.status) {
+              case 401:
+                reject(new BlinkAuthError(message, errorData));
+                break;
+              case 400:
+                reject(new BlinkValidationError(message, errorData));
+                break;
+              default:
+                reject(new BlinkNetworkError(message, xhr.status, errorData));
+            }
+          } catch {
+            reject(new BlinkNetworkError(`HTTP ${xhr.status}`, xhr.status));
+          }
+        }
+      });
+      xhr.addEventListener("error", () => {
+        reject(new BlinkNetworkError("Network error during file upload"));
+      });
+      xhr.open("POST", url);
+      Object.entries(headers).forEach(([key, value]) => {
+        xhr.setRequestHeader(key, value);
+      });
+      xhr.send(formData);
+    });
+  }
+  /**
+   * AI-specific requests
+   */
+  async aiText(prompt, options = {}) {
+    const { signal, ...body } = options;
+    const requestBody = { ...body };
+    if (prompt) {
+      requestBody.prompt = prompt;
+    }
+    return this.request(`/api/ai/${this.projectId}/text`, {
+      method: "POST",
+      body: requestBody,
+      signal
+    });
+  }
+  /**
+   * Stream AI text generation with Vercel AI SDK data stream format
+   */
+  async streamAiText(prompt, options = {}, onChunk) {
+    const url = this.buildUrl(`/api/ai/${this.projectId}/text`);
+    const token = this.getValidToken ? await this.getValidToken() : this.getToken();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const body = {
+      prompt,
+      stream: true,
+      ...options
+    };
+    const { signal: _signal, ...jsonBody } = body;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(jsonBody),
+        signal: options.signal
+      });
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      if (!response.body) {
+        throw new BlinkNetworkError("No response body for streaming");
+      }
+      return this.parseDataStream(response.body, onChunk);
+    } catch (error) {
+      if (error instanceof BlinkError) {
+        throw error;
+      }
+      throw new BlinkNetworkError(
+        `Streaming request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        0,
+        { originalError: error }
+      );
+    }
+  }
+  async aiObject(prompt, options = {}) {
+    const { signal, ...body } = options;
+    const requestBody = { ...body };
+    if (prompt) {
+      requestBody.prompt = prompt;
+    }
+    return this.request(`/api/ai/${this.projectId}/object`, {
+      method: "POST",
+      body: requestBody,
+      signal
+    });
+  }
+  /**
+   * Stream AI object generation with Vercel AI SDK data stream format
+   */
+  async streamAiObject(prompt, options = {}, onPartial) {
+    const url = this.buildUrl(`/api/ai/${this.projectId}/object`);
+    const token = this.getValidToken ? await this.getValidToken() : this.getToken();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const body = {
+      prompt,
+      stream: true,
+      ...options
+    };
+    const { signal: _signal2, ...jsonBody2 } = body;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(jsonBody2),
+        signal: options.signal
+      });
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      if (!response.body) {
+        throw new BlinkNetworkError("No response body for streaming");
+      }
+      return this.parseDataStream(response.body, void 0, onPartial);
+    } catch (error) {
+      if (error instanceof BlinkError) {
+        throw error;
+      }
+      throw new BlinkNetworkError(
+        `Streaming request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        0,
+        { originalError: error }
+      );
+    }
+  }
+  async aiImage(prompt, options = {}) {
+    const { signal, ...body } = options;
+    return this.request(`/api/ai/${this.projectId}/image`, {
+      method: "POST",
+      body: {
+        prompt,
+        ...body
+      },
+      signal
+    });
+  }
+  async aiSpeech(text, options = {}) {
+    const { signal, ...body } = options;
+    return this.request(`/api/ai/${this.projectId}/speech`, {
+      method: "POST",
+      body: {
+        text,
+        ...body
+      },
+      signal
+    });
+  }
+  async aiTranscribe(audio, options = {}) {
+    const { signal, ...body } = options;
+    return this.request(`/api/ai/${this.projectId}/transcribe`, {
+      method: "POST",
+      body: {
+        audio,
+        ...body
+      },
+      signal
+    });
+  }
+  /**
+   * Private helper methods
+   */
+  buildUrl(path, searchParams) {
+    const baseUrl = path.includes("/api/auth/") ? this.authUrl : this.coreUrl;
+    const url = new URL(path, baseUrl);
+    if (searchParams) {
+      Object.entries(searchParams).forEach(([key, value]) => {
+        url.searchParams.set(key, value);
+      });
+    }
+    return url.toString();
+  }
+  async parseResponse(response) {
+    const contentType = response.headers.get("content-type");
+    if (contentType?.includes("application/json")) {
+      return response.json();
+    }
+    if (contentType?.includes("text/")) {
+      return response.text();
+    }
+    return response.blob();
+  }
+  async handleErrorResponse(response) {
+    let errorData;
+    try {
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        errorData = await response.json();
+      } else {
+        errorData = { message: await response.text() };
+      }
+    } catch {
+      errorData = { message: "Unknown error occurred" };
+    }
+    const message = errorData.error?.message || errorData.message || `HTTP ${response.status}`;
+    errorData.error?.code || errorData.code;
+    switch (response.status) {
+      case 401:
+        throw new BlinkAuthError(message, errorData);
+      case 400:
+        throw new BlinkValidationError(message, errorData);
+      default:
+        throw new BlinkNetworkError(message, response.status, errorData);
+    }
+  }
+  /**
+   * Parse Vercel AI SDK data stream format
+   * Handles text chunks (0:"text"), partial objects (2:[...]), and metadata (d:, e:)
+   */
+  async parseDataStream(body, onChunk, onPartial) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let finalResult = {};
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            if (line.startsWith("f:")) {
+              const metadata = JSON.parse(line.slice(2));
+              finalResult.messageId = metadata.messageId;
+            } else if (line.startsWith("0:")) {
+              const textChunk = JSON.parse(line.slice(2));
+              if (onChunk) {
+                onChunk(textChunk);
+              }
+              finalResult.text = (finalResult.text || "") + textChunk;
+            } else if (line.startsWith("2:")) {
+              const data = JSON.parse(line.slice(2));
+              if (Array.isArray(data) && data.length > 0) {
+                const item = data[0];
+                if (typeof item === "string") {
+                  finalResult.status = item;
+                } else if (typeof item === "object") {
+                  if (onPartial) {
+                    onPartial(item);
+                  }
+                  finalResult.object = item;
+                }
+              }
+            } else if (line.startsWith("d:")) {
+              const metadata = JSON.parse(line.slice(2));
+              if (metadata.usage) {
+                finalResult.usage = metadata.usage;
+              }
+              if (metadata.finishReason) {
+                finalResult.finishReason = metadata.finishReason;
+              }
+            } else if (line.startsWith("e:")) {
+              const errorData = JSON.parse(line.slice(2));
+              finalResult.error = errorData;
+            }
+          } catch (error) {
+            console.warn("Failed to parse stream line:", line, error);
+          }
+        }
+      }
+      if (buffer.trim()) {
+        try {
+          if (buffer.startsWith("0:")) {
+            const textChunk = JSON.parse(buffer.slice(2));
+            if (onChunk) {
+              onChunk(textChunk);
+            }
+            finalResult.text = (finalResult.text || "") + textChunk;
+          } else if (buffer.startsWith("2:")) {
+            const data = JSON.parse(buffer.slice(2));
+            if (Array.isArray(data) && data.length > 0) {
+              const item = data[0];
+              if (typeof item === "object") {
+                if (onPartial) {
+                  onPartial(item);
+                }
+                finalResult.object = item;
+              }
+            }
+          } else if (buffer.startsWith("d:")) {
+            const metadata = JSON.parse(buffer.slice(2));
+            if (metadata.usage) {
+              finalResult.usage = metadata.usage;
+            }
+            if (metadata.finishReason) {
+              finalResult.finishReason = metadata.finishReason;
+            }
+          }
+        } catch (error) {
+          console.warn("Failed to parse final buffer:", buffer, error);
+        }
+      }
+      return finalResult;
+    } finally {
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/auth.ts
+var BlinkAuth = class {
+  config;
+  authState;
+  listeners = /* @__PURE__ */ new Set();
+  authUrl = "https://blink.new";
+  constructor(config) {
+    this.config = config;
+    this.authState = {
+      user: null,
+      tokens: null,
+      isAuthenticated: false,
+      isLoading: false
+    };
+    if (typeof window !== "undefined") {
+      this.initialize();
+    }
+  }
+  /**
+   * Initialize authentication from stored tokens or URL fragments
+   */
+  async initialize() {
+    console.log("\u{1F680} Initializing Blink Auth...");
+    this.setLoading(true);
+    try {
+      const tokensFromUrl = this.extractTokensFromUrl();
+      if (tokensFromUrl) {
+        console.log("\u{1F4E5} Found tokens in URL, setting them...");
+        await this.setTokens(tokensFromUrl, true);
+        this.clearUrlTokens();
+        console.log("\u2705 Auth initialization complete (from URL)");
+        return;
+      }
+      const storedTokens = this.getStoredTokens();
+      if (storedTokens) {
+        console.log("\u{1F4BE} Found stored tokens, validating...", {
+          hasAccessToken: !!storedTokens.access_token,
+          hasRefreshToken: !!storedTokens.refresh_token,
+          issuedAt: storedTokens.issued_at,
+          expiresIn: storedTokens.expires_in,
+          refreshExpiresIn: storedTokens.refresh_expires_in,
+          currentTime: Math.floor(Date.now() / 1e3)
+        });
+        this.authState.tokens = storedTokens;
+        console.log("\u{1F527} Tokens set in auth state, refresh token available:", !!this.authState.tokens?.refresh_token);
+        const isValid = await this.validateStoredTokens(storedTokens);
+        if (isValid) {
+          console.log("\u2705 Auth initialization complete (from storage)");
+          return;
+        } else {
+          console.log("\u{1F504} Stored tokens invalid, clearing...");
+          this.clearTokens();
+        }
+      }
+      console.log("\u274C No tokens found");
+      if (this.config.authRequired) {
+        console.log("\u{1F504} Auth required, redirecting to auth page...");
+        this.redirectToAuth();
+      } else {
+        console.log("\u26A0\uFE0F Auth not required, continuing without authentication");
+      }
+    } finally {
+      this.setLoading(false);
+    }
+  }
+  /**
+   * Redirect to Blink auth page
+   */
+  login(nextUrl) {
+    const redirectUrl = nextUrl || (typeof window !== "undefined" ? window.location.href : "");
+    const authUrl = new URL("/auth", this.authUrl);
+    authUrl.searchParams.set("redirect_url", redirectUrl);
+    if (this.config.projectId) {
+      authUrl.searchParams.set("project_id", this.config.projectId);
+    }
+    if (typeof window !== "undefined") {
+      window.location.href = authUrl.toString();
+    }
+  }
+  /**
+   * Logout and clear stored tokens
+   */
+  logout(redirectUrl) {
+    this.clearTokens();
+    if (redirectUrl && typeof window !== "undefined") {
+      window.location.href = redirectUrl;
+    }
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return this.authState.isAuthenticated;
+  }
+  /**
+   * Get current user (sync)
+   */
+  currentUser() {
+    return this.authState.user;
+  }
+  /**
+   * Get current access token
+   */
+  getToken() {
+    return this.authState.tokens?.access_token || null;
+  }
+  /**
+   * Check if access token is expired based on timestamp
+   */
+  isAccessTokenExpired() {
+    const tokens = this.authState.tokens;
+    if (!tokens || !tokens.issued_at) {
+      return true;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = tokens.issued_at + tokens.expires_in;
+    const bufferTime = 30;
+    return now >= expiresAt - bufferTime;
+  }
+  /**
+   * Check if refresh token is expired based on timestamp
+   */
+  isRefreshTokenExpired() {
+    const tokens = this.authState.tokens;
+    if (!tokens || !tokens.refresh_token || !tokens.issued_at || !tokens.refresh_expires_in) {
+      return true;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = tokens.issued_at + tokens.refresh_expires_in;
+    return now >= expiresAt;
+  }
+  /**
+   * Get a valid access token, refreshing if necessary
+   */
+  async getValidToken() {
+    const tokens = this.authState.tokens;
+    if (!tokens) {
+      return null;
+    }
+    if (!this.isAccessTokenExpired()) {
+      console.log("\u2705 Access token is still valid");
+      return tokens.access_token;
+    }
+    console.log("\u23F0 Access token expired, attempting refresh...");
+    if (this.isRefreshTokenExpired()) {
+      console.log("\u274C Refresh token also expired, clearing tokens");
+      this.clearTokens();
+      if (this.config.authRequired) {
+        this.redirectToAuth();
+      }
+      return null;
+    }
+    const refreshed = await this.refreshToken();
+    if (refreshed) {
+      console.log("\u2705 Token refreshed successfully");
+      return this.authState.tokens?.access_token || null;
+    } else {
+      console.log("\u274C Token refresh failed");
+      this.clearTokens();
+      if (this.config.authRequired) {
+        this.redirectToAuth();
+      }
+      return null;
+    }
+  }
+  /**
+   * Fetch current user profile from API
+   */
+  async me() {
+    let token = this.getToken();
+    if (!token) {
+      throw new BlinkAuthError("No access token available");
+    }
+    try {
+      const response = await fetch(`${this.authUrl}/api/auth/me`, {
+        headers: {
+          "Authorization": `Bearer ${token}`
+        }
+      });
+      if (!response.ok) {
+        if (response.status === 401) {
+          const refreshed = await this.refreshToken();
+          if (refreshed) {
+            token = this.getToken();
+            if (token) {
+              const retryResponse = await fetch(`${this.authUrl}/api/auth/me`, {
+                headers: {
+                  "Authorization": `Bearer ${token}`
+                }
+              });
+              if (retryResponse.ok) {
+                const retryData = await retryResponse.json();
+                const user2 = retryData.user;
+                this.updateAuthState({
+                  ...this.authState,
+                  user: user2
+                });
+                return user2;
+              }
+            }
+          }
+          this.clearTokens();
+          if (this.config.authRequired) {
+            this.redirectToAuth();
+          }
+        }
+        throw new BlinkAuthError(`Failed to fetch user: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const user = data.user;
+      this.updateAuthState({
+        ...this.authState,
+        user
+      });
+      return user;
+    } catch (error) {
+      if (error instanceof BlinkAuthError) {
+        throw error;
+      }
+      throw new BlinkAuthError(`Network error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Update user profile
+   */
+  async updateMe(updates) {
+    const token = this.getToken();
+    if (!token) {
+      throw new BlinkAuthError("No access token available");
+    }
+    try {
+      const response = await fetch(`${this.authUrl}/api/auth/me`, {
+        method: "PATCH",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(updates)
+      });
+      if (!response.ok) {
+        throw new BlinkAuthError(`Failed to update user: ${response.statusText}`);
+      }
+      const data = await response.json();
+      const user = data.user;
+      this.updateAuthState({
+        ...this.authState,
+        user
+      });
+      return user;
+    } catch (error) {
+      if (error instanceof BlinkAuthError) {
+        throw error;
+      }
+      throw new BlinkAuthError(`Network error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Manually set tokens (for server-side usage)
+   */
+  async setToken(jwt, persist = false) {
+    const tokens = {
+      access_token: jwt,
+      token_type: "Bearer",
+      expires_in: 15 * 60
+      // Default 15 minutes
+    };
+    await this.setTokens(tokens, persist);
+  }
+  /**
+   * Refresh access token using refresh token
+   */
+  async refreshToken() {
+    const refreshToken = this.authState.tokens?.refresh_token;
+    if (!refreshToken) {
+      return false;
+    }
+    try {
+      const response = await fetch(`${this.authUrl}/api/auth/refresh`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          refresh_token: refreshToken
+        })
+      });
+      if (!response.ok) {
+        if (response.status === 401) {
+          this.clearTokens();
+          if (this.config.authRequired) {
+            this.redirectToAuth();
+          }
+        }
+        return false;
+      }
+      const data = await response.json();
+      await this.setTokens({
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        token_type: data.token_type,
+        expires_in: data.expires_in,
+        refresh_expires_in: data.refresh_expires_in
+      }, true);
+      return true;
+    } catch (error) {
+      console.error("Token refresh failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Add auth state change listener
+   */
+  onAuthStateChanged(callback) {
+    this.listeners.add(callback);
+    callback(this.authState);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  /**
+   * Private helper methods
+   */
+  async validateStoredTokens(tokens) {
+    try {
+      console.log("\u{1F50D} Validating stored tokens...");
+      if (this.isAccessTokenExpired()) {
+        console.log("\u23F0 Access token expired based on timestamp, attempting refresh...");
+        if (!tokens.refresh_token) {
+          console.log("\u274C No refresh token available");
+          return false;
+        }
+        if (this.isRefreshTokenExpired()) {
+          console.log("\u274C Refresh token also expired");
+          return false;
+        }
+        const refreshed = await this.refreshToken();
+        if (refreshed) {
+          console.log("\u2705 Token refreshed successfully during validation");
+          return true;
+        } else {
+          console.log("\u274C Token refresh failed during validation");
+          return false;
+        }
+      }
+      const response = await fetch(`${this.authUrl}/api/auth/me`, {
+        headers: {
+          "Authorization": `Bearer ${tokens.access_token}`
+        }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        const user = data.user;
+        this.updateAuthState({
+          user,
+          tokens,
+          isAuthenticated: true,
+          isLoading: false
+        });
+        console.log("\u2705 Stored tokens are valid, user authenticated");
+        return true;
+      } else if (response.status === 401 && tokens.refresh_token) {
+        console.log("\u{1F504} Access token expired (server validation), attempting refresh...");
+        if (this.isRefreshTokenExpired()) {
+          console.log("\u274C Refresh token expired");
+          return false;
+        }
+        const refreshed = await this.refreshToken();
+        if (refreshed) {
+          console.log("\u2705 Token refreshed successfully after server validation");
+          return true;
+        } else {
+          console.log("\u274C Token refresh failed after server validation");
+          return false;
+        }
+      } else {
+        console.log("\u274C Token validation failed:", response.status, response.statusText);
+        return false;
+      }
+    } catch (error) {
+      console.log("\u{1F4A5} Error validating tokens:", error);
+      return false;
+    }
+  }
+  async setTokens(tokens, persist) {
+    const tokensWithTimestamp = {
+      ...tokens,
+      issued_at: tokens.issued_at || Math.floor(Date.now() / 1e3)
+    };
+    console.log("\u{1F510} Setting tokens:", {
+      persist,
+      hasAccessToken: !!tokensWithTimestamp.access_token,
+      hasRefreshToken: !!tokensWithTimestamp.refresh_token,
+      expiresIn: tokensWithTimestamp.expires_in,
+      issuedAt: tokensWithTimestamp.issued_at
+    });
+    if (persist && typeof window !== "undefined") {
+      localStorage.setItem("blink_tokens", JSON.stringify(tokensWithTimestamp));
+      console.log("\u{1F4BE} Tokens persisted to localStorage");
+    }
+    let user = null;
+    try {
+      console.log("\u{1F464} Fetching user data...");
+      const response = await fetch(`${this.authUrl}/api/auth/me`, {
+        headers: {
+          "Authorization": `Bearer ${tokensWithTimestamp.access_token}`
+        }
+      });
+      console.log("\u{1F4E1} User fetch response:", {
+        status: response.status,
+        statusText: response.statusText,
+        ok: response.ok
+      });
+      if (response.ok) {
+        const data = await response.json();
+        user = data.user;
+        console.log("\u2705 User data fetched successfully:", {
+          id: user?.id,
+          email: user?.email,
+          displayName: user?.displayName
+        });
+      } else {
+        console.log("\u274C Failed to fetch user data:", await response.text());
+      }
+    } catch (error) {
+      console.log("\u{1F4A5} Error fetching user data:", error);
+    }
+    this.updateAuthState({
+      user,
+      tokens: tokensWithTimestamp,
+      isAuthenticated: !!user,
+      isLoading: false
+    });
+    console.log("\u{1F3AF} Auth state updated:", {
+      hasUser: !!user,
+      isAuthenticated: !!user,
+      isLoading: false
+    });
+  }
+  clearTokens() {
+    if (typeof window !== "undefined") {
+      localStorage.removeItem("blink_tokens");
+    }
+    this.updateAuthState({
+      user: null,
+      tokens: null,
+      isAuthenticated: false,
+      isLoading: false
+    });
+  }
+  getStoredTokens() {
+    if (typeof window === "undefined") return null;
+    try {
+      const stored = localStorage.getItem("blink_tokens");
+      console.log("\u{1F50D} Checking localStorage for tokens:", {
+        hasStoredData: !!stored,
+        storedLength: stored?.length || 0
+      });
+      if (stored) {
+        const tokens = JSON.parse(stored);
+        console.log("\u{1F4E6} Parsed stored tokens:", {
+          hasAccessToken: !!tokens.access_token,
+          hasRefreshToken: !!tokens.refresh_token,
+          tokenType: tokens.token_type,
+          expiresIn: tokens.expires_in
+        });
+        return tokens;
+      }
+      return null;
+    } catch (error) {
+      console.log("\u{1F4A5} Error parsing stored tokens:", error);
+      localStorage.removeItem("blink_tokens");
+      return null;
+    }
+  }
+  extractTokensFromUrl() {
+    if (typeof window === "undefined") return null;
+    const params = new URLSearchParams(window.location.search);
+    const accessToken = params.get("access_token");
+    const refreshToken = params.get("refresh_token");
+    console.log("\u{1F50D} Extracting tokens from URL:", {
+      url: window.location.href,
+      accessToken: accessToken ? `${accessToken.substring(0, 20)}...` : null,
+      refreshToken: refreshToken ? `${refreshToken.substring(0, 20)}...` : null,
+      allParams: Object.fromEntries(params.entries())
+    });
+    if (accessToken) {
+      const tokens = {
+        access_token: accessToken,
+        refresh_token: refreshToken || void 0,
+        token_type: "Bearer",
+        expires_in: 15 * 60,
+        // 15 minutes default
+        refresh_expires_in: refreshToken ? 30 * 24 * 60 * 60 : void 0,
+        // 30 days default
+        issued_at: Math.floor(Date.now() / 1e3)
+        // Current timestamp
+      };
+      console.log("\u2705 Tokens extracted successfully:", {
+        hasAccessToken: !!tokens.access_token,
+        hasRefreshToken: !!tokens.refresh_token
+      });
+      return tokens;
+    }
+    console.log("\u274C No access token found in URL");
+    return null;
+  }
+  clearUrlTokens() {
+    if (typeof window === "undefined") return;
+    const url = new URL(window.location.href);
+    url.searchParams.delete("access_token");
+    url.searchParams.delete("refresh_token");
+    url.searchParams.delete("token_type");
+    url.searchParams.delete("project_id");
+    url.searchParams.delete("expires_in");
+    url.searchParams.delete("refresh_expires_in");
+    url.searchParams.delete("state");
+    url.searchParams.delete("code");
+    url.searchParams.delete("error");
+    url.searchParams.delete("error_description");
+    window.history.replaceState({}, "", url.toString());
+    console.log("\u{1F9F9} URL cleaned up, removed auth parameters");
+  }
+  redirectToAuth() {
+    if (typeof window !== "undefined") {
+      this.login();
+    }
+  }
+  setLoading(loading) {
+    this.updateAuthState({
+      ...this.authState,
+      isLoading: loading
+    });
+  }
+  updateAuthState(newState) {
+    this.authState = newState;
+    this.listeners.forEach((callback) => {
+      try {
+        callback(newState);
+      } catch (error) {
+        console.error("Error in auth state change callback:", error);
+      }
+    });
+  }
+};
+
+// src/database.ts
+var BlinkTable = class {
+  constructor(tableName, httpClient) {
+    this.tableName = tableName;
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create a single record
+   */
+  async create(data, options = {}) {
+    const response = await this.httpClient.dbPost(
+      this.tableName,
+      data,
+      { returning: options.returning !== false }
+    );
+    const result = Array.isArray(response.data) ? response.data[0] : response.data;
+    if (!result) {
+      throw new Error("Failed to create record");
+    }
+    return result;
+  }
+  /**
+   * Create multiple records
+   */
+  async createMany(data, options = {}) {
+    const response = await this.httpClient.dbPost(
+      this.tableName,
+      data,
+      { returning: options.returning !== false }
+    );
+    return Array.isArray(response.data) ? response.data : [response.data];
+  }
+  /**
+   * Upsert a single record (insert or update on conflict)
+   */
+  async upsert(data, options = {}) {
+    const headers = {};
+    if (options.returning !== false) {
+      headers.Prefer = "return=representation";
+    }
+    if (options.onConflict) {
+      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"}`,
+      {
+        method: "POST",
+        body: data,
+        headers
+      }
+    );
+    const result = Array.isArray(response.data) ? response.data[0] : response.data;
+    if (!result) {
+      throw new Error("Failed to upsert record");
+    }
+    return result;
+  }
+  /**
+   * Upsert multiple records
+   */
+  async upsertMany(data, options = {}) {
+    const headers = {};
+    if (options.returning !== false) {
+      headers.Prefer = "return=representation";
+    }
+    if (options.onConflict) {
+      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"}`,
+      {
+        method: "POST",
+        body: data,
+        headers
+      }
+    );
+    return Array.isArray(response.data) ? response.data : [response.data];
+  }
+  /**
+   * Get a single record by ID
+   */
+  async get(id) {
+    const searchParams = {
+      id: `eq.${id}`,
+      limit: "1"
+    };
+    const response = await this.httpClient.dbGet(this.tableName, searchParams);
+    const records = response.data;
+    return records.length > 0 ? records[0] : null;
+  }
+  /**
+   * List records with filtering, sorting, and pagination
+   */
+  async list(options = {}) {
+    const queryParams = buildQuery(options);
+    const searchParams = queryParams;
+    const response = await this.httpClient.dbGet(this.tableName, searchParams);
+    const records = response.data;
+    const hasMore = options.limit ? records.length === options.limit : false;
+    const nextCursor = hasMore && records.length > 0 ? this.extractCursor(records[records.length - 1]) : void 0;
+    return {
+      data: records,
+      count: records.length,
+      nextCursor,
+      hasMore
+    };
+  }
+  /**
+   * Update a single record by ID
+   */
+  async update(id, data, options = {}) {
+    const searchParams = {
+      id: `eq.${id}`
+    };
+    const response = await this.httpClient.dbPatch(
+      this.tableName,
+      data,
+      searchParams,
+      { returning: options.returning !== false }
+    );
+    const records = response.data;
+    if (!records || records.length === 0) {
+      throw new Error(`Record with id ${id} not found`);
+    }
+    return records[0];
+  }
+  /**
+   * Update multiple records
+   */
+  async updateMany(updates, options = {}) {
+    const results = [];
+    for (const update of updates) {
+      const { id, ...data } = update;
+      const result = await this.update(id, data, options);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Delete a single record by ID
+   */
+  async delete(id) {
+    const searchParams = {
+      id: `eq.${id}`
+    };
+    await this.httpClient.dbDelete(this.tableName, searchParams);
+  }
+  /**
+   * Delete multiple records based on filter
+   */
+  async deleteMany(options) {
+    const queryParams = buildQuery({ where: options.where });
+    const searchParams = queryParams;
+    await this.httpClient.dbDelete(this.tableName, searchParams);
+  }
+  /**
+   * Count records matching filter
+   */
+  async count(options = {}) {
+    const queryParams = buildQuery({
+      where: options.where,
+      select: ["id"]
+    });
+    const response = await this.httpClient.request(
+      `/api/db/${this.httpClient.projectId}/rest/v1/${this.tableName}`,
+      {
+        method: "GET",
+        searchParams: queryParams,
+        headers: {
+          "Prefer": "count=exact"
+        }
+      }
+    );
+    const contentRange = response.headers.get("content-range");
+    if (contentRange) {
+      const match = contentRange.match(/\/(\d+)$/);
+      if (match && match[1]) {
+        return parseInt(match[1], 10);
+      }
+    }
+    return Array.isArray(response.data) ? response.data.length : 0;
+  }
+  /**
+   * Check if any records exist matching filter
+   */
+  async exists(options) {
+    const count = await this.count(options);
+    return count > 0;
+  }
+  /**
+   * Raw SQL query on this table (for advanced use cases)
+   */
+  async sql(query, params) {
+    const response = await this.httpClient.dbSql(query, params);
+    return response.data;
+  }
+  /**
+   * Private helper methods
+   */
+  extractCursor(record) {
+    return record.id || record._id || String(Math.random());
+  }
+};
+var BlinkDatabase = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    const proxy = new Proxy(this, {
+      get(target, prop) {
+        if (prop === "table") {
+          return target.table.bind(target);
+        }
+        if (prop in target) {
+          const value = target[prop];
+          return typeof value === "function" ? value.bind(target) : value;
+        }
+        if (typeof prop === "string") {
+          return target.table(prop);
+        }
+        return void 0;
+      }
+    });
+    return proxy;
+  }
+  tables = /* @__PURE__ */ new Map();
+  /**
+   * Get a table instance for any table name
+   */
+  table(tableName) {
+    if (!this.tables.has(tableName)) {
+      this.tables.set(tableName, new BlinkTable(tableName, this.httpClient));
+    }
+    const table = this.tables.get(tableName);
+    if (!table) {
+      throw new Error(`Table ${tableName} not found`);
+    }
+    return table;
+  }
+  /**
+   * Execute raw SQL query
+   */
+  async sql(query, params) {
+    const response = await this.httpClient.dbSql(query, params);
+    return response.data;
+  }
+  /**
+   * Execute batch SQL operations
+   */
+  async batch(statements, mode = "write") {
+    const response = await this.httpClient.dbBatch(statements, mode);
+    return response.data;
+  }
+};
+
+// src/storage.ts
+var BlinkStorageImpl = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Upload a file to project storage
+   * 
+   * @param file - File, Blob, or Buffer to upload
+   * @param path - Destination path within project storage
+   * @param options - Upload options including upsert and progress callback
+   * @returns Promise resolving to upload response with public URL
+   * 
+   * @example
+   * ```ts
+   * const { publicUrl } = await blink.storage.upload(
+   *   fileInput.files[0],
+   *   `avatars/${user.id}.png`,
+   *   {
+   *     upsert: true,
+   *     onProgress: pct => console.log(`${pct}%`)
+   *   }
+   * );
+   * ```
+   */
+  async upload(file, path, options = {}) {
+    try {
+      if (!file) {
+        throw new BlinkStorageError("File is required");
+      }
+      if (!path || typeof path !== "string" || !path.trim()) {
+        throw new BlinkStorageError("Path must be a non-empty string");
+      }
+      const maxSize = 50 * 1024 * 1024;
+      let fileSize = 0;
+      if (file instanceof File || file instanceof Blob) {
+        fileSize = file.size;
+      } else if (typeof Buffer !== "undefined" && file instanceof Buffer) {
+        fileSize = file.length;
+      }
+      if (fileSize > maxSize) {
+        throw new BlinkStorageError(`File size (${Math.round(fileSize / 1024 / 1024)}MB) exceeds maximum allowed size (50MB)`);
+      }
+      const response = await this.httpClient.uploadFile(
+        `/api/storage/${this.httpClient.projectId}/upload`,
+        file,
+        path,
+        {
+          upsert: options.upsert,
+          onProgress: options.onProgress
+        }
+      );
+      if (response.data?.data?.publicUrl) {
+        return { publicUrl: response.data.data.publicUrl };
+      } else if (response.data?.publicUrl) {
+        return { publicUrl: response.data.publicUrl };
+      } else {
+        throw new BlinkStorageError("Invalid response format: missing publicUrl");
+      }
+    } catch (error) {
+      if (error instanceof BlinkStorageError) {
+        throw error;
+      }
+      if (error instanceof Error && "status" in error) {
+        const status = error.status;
+        if (status === 409) {
+          throw new BlinkStorageError("File already exists. Set upsert: true to overwrite.", 409);
+        }
+        if (status === 400) {
+          throw new BlinkStorageError("Invalid request parameters", 400);
+        }
+      }
+      throw new BlinkStorageError(
+        `Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Remove one or more files from project storage
+   * 
+   * @param paths - File paths to remove
+   * @returns Promise that resolves when files are removed
+   * 
+   * @example
+   * ```ts
+   * await blink.storage.remove('avatars/user1.png');
+   * await blink.storage.remove('file1.pdf', 'file2.pdf', 'file3.pdf');
+   * ```
+   */
+  async remove(...paths) {
+    try {
+      if (paths.length === 0) {
+        throw new BlinkStorageError("At least one path must be provided");
+      }
+      for (const path of paths) {
+        if (!path || typeof path !== "string") {
+          throw new BlinkStorageError("All paths must be non-empty strings");
+        }
+      }
+      await this.httpClient.request(
+        `/api/storage/${this.httpClient.projectId}/remove`,
+        {
+          method: "DELETE",
+          body: { paths },
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    } catch (error) {
+      if (error instanceof BlinkStorageError) {
+        throw error;
+      }
+      if (error instanceof Error && "status" in error) {
+        const status = error.status;
+        if (status === 400) {
+          throw new BlinkStorageError("Invalid request parameters", 400);
+        }
+      }
+      throw new BlinkStorageError(
+        `Failed to remove files: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+};
+
+// src/ai.ts
+var BlinkAIImpl = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Get MIME type for audio format
+   */
+  getMimeTypeForFormat(format) {
+    const mimeTypes = {
+      mp3: "audio/mpeg",
+      opus: "audio/opus",
+      aac: "audio/aac",
+      flac: "audio/flac",
+      wav: "audio/wav",
+      pcm: "audio/pcm"
+    };
+    return mimeTypes[format] || "audio/mpeg";
+  }
+  /**
+   * Generates a text response using the Blink AI engine.
+   * 
+   * @param options - An object containing either:
+   *   - `prompt`: a simple string prompt
+   *   - OR `messages`: an array of chat messages for conversation
+   *   - Plus optional model, maxTokens, temperature, signal parameters
+   * 
+   * @example
+   * ```ts
+   * // Simple prompt
+   * const { text } = await blink.ai.generateText({ 
+   *   prompt: "Write a poem about coding" 
+   * });
+   * 
+   * // Chat messages
+   * const { text } = await blink.ai.generateText({
+   *   messages: [
+   *     { role: "system", content: "You are a helpful assistant" },
+   *     { role: "user", content: "Explain quantum computing" }
+   *   ]
+   * });
+   * 
+   * // With options
+   * const { text, usage } = await blink.ai.generateText({
+   *   prompt: "Summarize this article",
+   *   model: "gpt-4o-mini",
+   *   maxTokens: 150,
+   *   temperature: 0.7
+   * });
+   * ```
+   * 
+   * @returns Promise<TextGenerationResponse> - Object containing:
+   *   - `text`: Generated text string
+   *   - `usage`: Token usage information
+   *   - `finishReason`: Why generation stopped ("stop", "length", etc.)
+   */
+  async generateText(options) {
+    try {
+      if (!options.prompt && !options.messages) {
+        throw new BlinkAIError("Either prompt or messages is required");
+      }
+      const requestBody = {
+        model: options.model,
+        stream: false,
+        maxTokens: options.maxTokens,
+        temperature: options.temperature,
+        signal: options.signal
+      };
+      if (options.prompt) {
+        requestBody.prompt = options.prompt;
+      }
+      if (options.messages) {
+        requestBody.messages = options.messages;
+      }
+      const response = await this.httpClient.aiText(
+        options.prompt || "",
+        requestBody
+      );
+      if (response.data?.result) {
+        return response.data.result;
+      } else if (response.data?.text) {
+        return response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing text");
+      }
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Text generation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Streams text generation with real-time updates as the AI generates content.
+   * 
+   * @param options - Same as generateText: either `prompt` or `messages` with optional parameters
+   * @param onChunk - Callback function that receives each text chunk as it's generated
+   * 
+   * @example
+   * ```ts
+   * // Stream with prompt
+   * await blink.ai.streamText(
+   *   { prompt: "Write a short story about space exploration" },
+   *   (chunk) => {
+   *     process.stdout.write(chunk); // Real-time output
+   *   }
+   * );
+   * 
+   * // Stream with messages
+   * await blink.ai.streamText(
+   *   { 
+   *     messages: [
+   *       { role: "system", content: "You are a creative writer" },
+   *       { role: "user", content: "Write a haiku about programming" }
+   *     ]
+   *   },
+   *   (chunk) => updateUI(chunk)
+   * );
+   * ```
+   * 
+   * @returns Promise<TextGenerationResponse> - Final complete response with full text and metadata
+   */
+  async streamText(options, onChunk) {
+    try {
+      if (!options.prompt && !options.messages) {
+        throw new BlinkAIError("Either prompt or messages is required");
+      }
+      const result = await this.httpClient.streamAiText(
+        options.prompt || "",
+        {
+          model: options.model,
+          messages: options.messages,
+          maxTokens: options.maxTokens,
+          temperature: options.temperature,
+          signal: options.signal
+        },
+        onChunk
+      );
+      return {
+        text: result.text || "",
+        finishReason: "stop",
+        usage: result.usage,
+        ...result
+      };
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Text streaming failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Generates structured JSON objects using AI with schema validation.
+   * 
+   * @param options - Object containing:
+   *   - `prompt`: Description of what object to generate (required)
+   *   - `schema`: JSON Schema to validate the generated object
+   *   - `output`: Type of output ("object", "array", "enum")
+   *   - `enum`: Array of allowed values for enum output
+   *   - Plus optional model, signal parameters
+   * 
+   * @example
+   * ```ts
+   * // Generate user profile
+   * const { object } = await blink.ai.generateObject({
+   *   prompt: "Generate a user profile for a software developer",
+   *   schema: {
+   *     type: "object",
+   *     properties: {
+   *       name: { type: "string" },
+   *       age: { type: "number" },
+   *       skills: { type: "array", items: { type: "string" } },
+   *       experience: { type: "number" }
+   *     },
+   *     required: ["name", "skills"]
+   *   }
+   * });
+   * 
+   * // Generate array of items
+   * const { object } = await blink.ai.generateObject({
+   *   prompt: "List 5 programming languages",
+   *   output: "array",
+   *   schema: {
+   *     type: "array",
+   *     items: { type: "string" }
+   *   }
+   * });
+   * 
+   * // Generate enum value
+   * const { object } = await blink.ai.generateObject({
+   *   prompt: "Choose the best programming language for web development",
+   *   output: "enum",
+   *   enum: ["JavaScript", "Python", "TypeScript", "Go"]
+   * });
+   * ```
+   * 
+   * @returns Promise<ObjectGenerationResponse> - Object containing:
+   *   - `object`: The generated and validated JSON object/array/enum
+   *   - `usage`: Token usage information
+   *   - `finishReason`: Why generation stopped
+   */
+  async generateObject(options) {
+    try {
+      if (!options.prompt) {
+        throw new BlinkAIError("Prompt is required");
+      }
+      const response = await this.httpClient.aiObject(
+        options.prompt,
+        {
+          model: options.model,
+          output: options.output,
+          schema: options.schema,
+          enum: options.enum,
+          stream: false,
+          signal: options.signal
+        }
+      );
+      if (response.data?.result) {
+        return response.data.result;
+      } else if (response.data?.object) {
+        return response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing object");
+      }
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Object generation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Streams structured object generation with real-time partial updates as the AI builds the object.
+   * 
+   * @param options - Same as generateObject: prompt, schema, output type, etc.
+   * @param onPartial - Callback function that receives partial object updates as they're generated
+   * 
+   * @example
+   * ```ts
+   * // Stream object generation with schema
+   * await blink.ai.streamObject(
+   *   {
+   *     prompt: "Generate a detailed product catalog entry",
+   *     schema: {
+   *       type: "object",
+   *       properties: {
+   *         name: { type: "string" },
+   *         price: { type: "number" },
+   *         description: { type: "string" },
+   *         features: { type: "array", items: { type: "string" } }
+   *       }
+   *     }
+   *   },
+   *   (partial) => {
+   *     console.log("Partial update:", partial);
+   *     updateProductForm(partial); // Update UI in real-time
+   *   }
+   * );
+   * ```
+   * 
+   * @returns Promise<ObjectGenerationResponse> - Final complete object with metadata
+   */
+  async streamObject(options, onPartial) {
+    try {
+      if (!options.prompt) {
+        throw new BlinkAIError("Prompt is required");
+      }
+      const result = await this.httpClient.streamAiObject(
+        options.prompt,
+        {
+          model: options.model,
+          output: options.output,
+          schema: options.schema,
+          enum: options.enum,
+          signal: options.signal
+        },
+        onPartial
+      );
+      return {
+        object: result.object || {},
+        finishReason: "stop",
+        usage: result.usage,
+        ...result
+      };
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Object streaming failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Generates images from text descriptions using AI image models.
+   * 
+   * @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")
+   *   - `n`: Number of images to generate (default: 1)
+   *   - `response_format`: Output format ("url" or "b64_json")
+   *   - Plus optional model, signal parameters
+   * 
+   * @example
+   * ```ts
+   * // Basic image generation
+   * const { data } = await blink.ai.generateImage({
+   *   prompt: "A serene landscape with mountains and a lake at sunset"
+   * });
+   * console.log("Image URL:", data[0].url);
+   * 
+   * // High-quality image with specific size
+   * const { data } = await blink.ai.generateImage({
+   *   prompt: "A futuristic city skyline with flying cars",
+   *   size: "1792x1024",
+   *   quality: "hd",
+   *   model: "dall-e-3"
+   * });
+   * 
+   * // Multiple images
+   * const { data } = await blink.ai.generateImage({
+   *   prompt: "A cute robot mascot for a tech company",
+   *   n: 3,
+   *   size: "1024x1024"
+   * });
+   * 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
+   */
+  async generateImage(options) {
+    try {
+      if (!options.prompt) {
+        throw new BlinkAIError("Prompt is required");
+      }
+      const response = await this.httpClient.aiImage(
+        options.prompt,
+        {
+          model: options.model,
+          size: options.size,
+          quality: options.quality,
+          n: options.n,
+          response_format: options.response_format,
+          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 if (item.b64_json) {
+          return { b64_json: item.b64_json };
+        } else {
+          return { url: item };
+        }
+      });
+      return imageResponse;
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Image generation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Converts text to speech using AI voice synthesis models.
+   * 
+   * @param options - Object containing:
+   *   - `text`: Text content to convert to speech (required)
+   *   - `voice`: Voice to use ("alloy", "echo", "fable", "onyx", "nova", "shimmer")
+   *   - `response_format`: Audio format ("mp3", "opus", "aac", "flac", "wav", "pcm")
+   *   - `speed`: Speech speed (0.25 to 4.0, default: 1.0)
+   *   - Plus optional model, signal parameters
+   * 
+   * @example
+   * ```ts
+   * // Basic text-to-speech
+   * const { url } = await blink.ai.generateSpeech({
+   *   text: "Hello, welcome to our AI-powered application!"
+   * });
+   * console.log("Audio URL:", url);
+   * 
+   * // Custom voice and format
+   * const { url, voice, format } = await blink.ai.generateSpeech({
+   *   text: "This is a demonstration of our speech synthesis capabilities.",
+   *   voice: "nova",
+   *   response_format: "wav",
+   *   speed: 1.2
+   * });
+   * console.log(`Generated ${format} audio with ${voice} voice:`, url);
+   * 
+   * // Slow, clear speech for accessibility
+   * const { url } = await blink.ai.generateSpeech({
+   *   text: "Please listen carefully to these important instructions.",
+   *   voice: "echo",
+   *   speed: 0.8
+   * });
+   * ```
+   * 
+   * @returns Promise<SpeechGenerationResponse> - Object containing:
+   *   - `url`: URL to the generated audio file
+   *   - `voice`: Voice used for generation
+   *   - `format`: Audio format
+   *   - `mimeType`: MIME type of the audio
+   */
+  async generateSpeech(options) {
+    try {
+      if (!options.text) {
+        throw new BlinkAIError("Text is required");
+      }
+      const response = await this.httpClient.aiSpeech(
+        options.text,
+        {
+          model: options.model,
+          voice: options.voice,
+          response_format: options.response_format,
+          speed: options.speed,
+          signal: options.signal
+        }
+      );
+      let speechResponse;
+      if (response.data?.result) {
+        speechResponse = response.data.result;
+      } else if (response.data?.url) {
+        speechResponse = response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing speech data");
+      }
+      if (!speechResponse.url) {
+        if (typeof response.data === "string") {
+          speechResponse = {
+            url: response.data,
+            voice: options.voice || "alloy",
+            format: options.response_format || "mp3",
+            mimeType: this.getMimeTypeForFormat(options.response_format || "mp3")
+          };
+        } else if (response.data?.data) {
+          speechResponse = {
+            url: response.data.data,
+            voice: options.voice || "alloy",
+            format: options.response_format || "mp3",
+            mimeType: this.getMimeTypeForFormat(options.response_format || "mp3")
+          };
+        } else {
+          throw new BlinkAIError("Invalid response format: no audio URL found");
+        }
+      }
+      if (!speechResponse.voice) {
+        speechResponse.voice = options.voice || "alloy";
+      }
+      if (!speechResponse.format) {
+        speechResponse.format = options.response_format || "mp3";
+      }
+      if (!speechResponse.mimeType) {
+        speechResponse.mimeType = this.getMimeTypeForFormat(speechResponse.format);
+      }
+      return speechResponse;
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Speech generation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+  /**
+   * Transcribes audio content to text using AI speech recognition models.
+   * 
+   * @param options - Object containing:
+   *   - `audio`: Audio input as URL string, base64 string, or number array buffer (required)
+   *   - `language`: Language code for transcription (e.g., "en", "es", "fr")
+   *   - `response_format`: Output format ("json", "text", "srt", "verbose_json", "vtt")
+   *   - Plus optional model, signal parameters
+   * 
+   * @example
+   * ```ts
+   * // Transcribe from URL
+   * const { text } = await blink.ai.transcribeAudio({
+   *   audio: "https://example.com/meeting-recording.mp3"
+   * });
+   * console.log("Transcription:", text);
+   * 
+   * // Transcribe with language hint
+   * const { text, language } = await blink.ai.transcribeAudio({
+   *   audio: "https://example.com/spanish-audio.wav",
+   *   language: "es"
+   * });
+   * console.log(`Transcribed ${language}:`, text);
+   * 
+   * // Transcribe with timestamps (verbose format)
+   * const result = await blink.ai.transcribeAudio({
+   *   audio: audioFileUrl,
+   *   response_format: "verbose_json"
+   * });
+   * result.segments?.forEach(segment => {
+   *   console.log(`${segment.start}s - ${segment.end}s: ${segment.text}`);
+   * });
+   * 
+   * // Transcribe from audio buffer
+   * const audioBuffer = new Array(1024).fill(0); // Your audio data
+   * const { text } = await blink.ai.transcribeAudio({
+   *   audio: audioBuffer,
+   *   language: "en"
+   * });
+   * ```
+   * 
+   * @returns Promise<TranscriptionResponse> - Object containing:
+   *   - `text`: Transcribed text content
+   *   - `transcript`: Alias for text
+   *   - `segments`: Array of timestamped segments (if verbose format)
+   *   - `language`: Detected language
+   *   - `duration`: Audio duration in seconds
+   */
+  async transcribeAudio(options) {
+    try {
+      if (!options.audio) {
+        throw new BlinkAIError("Audio is required");
+      }
+      const response = await this.httpClient.aiTranscribe(
+        options.audio,
+        {
+          model: options.model,
+          language: options.language,
+          response_format: options.response_format,
+          signal: options.signal
+        }
+      );
+      if (response.data?.result) {
+        return response.data.result;
+      } else if (response.data?.text || response.data?.transcript) {
+        return {
+          text: response.data.text || response.data.transcript,
+          transcript: response.data.transcript || response.data.text,
+          ...response.data
+        };
+      } else {
+        throw new BlinkAIError("Invalid response format: missing transcription text");
+      }
+    } catch (error) {
+      if (error instanceof BlinkAIError) {
+        throw error;
+      }
+      throw new BlinkAIError(
+        `Audio transcription failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        void 0,
+        { originalError: error }
+      );
+    }
+  }
+};
+
+// src/client.ts
+var BlinkClientImpl = class {
+  auth;
+  db;
+  storage;
+  ai;
+  httpClient;
+  constructor(config) {
+    this.auth = new BlinkAuth(config);
+    this.httpClient = new HttpClient(
+      config,
+      () => this.auth.getToken(),
+      () => this.auth.getValidToken()
+    );
+    this.db = new BlinkDatabase(this.httpClient);
+    this.storage = new BlinkStorageImpl(this.httpClient);
+    this.ai = new BlinkAIImpl(this.httpClient);
+  }
+};
+function createClient(config) {
+  if (!config.projectId) {
+    throw new Error("projectId is required");
+  }
+  const clientConfig = {
+    authRequired: true,
+    ...config
+  };
+  return new BlinkClientImpl(clientConfig);
+}
+
+exports.BlinkAIImpl = BlinkAIImpl;
+exports.BlinkDatabase = BlinkDatabase;
+exports.BlinkStorageImpl = BlinkStorageImpl;
+exports.BlinkTable = BlinkTable;
+exports.createClient = createClient;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map