@vaiftechnologies/vaif-client 0.1.0

package/dist/index.js

@@ -0,0 +1,2428 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RealtimeChannel: () => RealtimeChannel,
+  VaifAI: () => VaifAI,
+  VaifAuth: () => VaifAuth,
+  VaifClient: () => VaifClient,
+  VaifDatabase: () => VaifDatabase,
+  VaifFunctions: () => VaifFunctions,
+  VaifRealtime: () => VaifRealtime,
+  VaifStorage: () => VaifStorage,
+  VaifTypeGen: () => VaifTypeGen,
+  createClient: () => createClient,
+  createTypeGen: () => createTypeGen
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/database.ts
+var VaifDatabase = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Start a query on a table
+   *
+   * @example
+   * ```typescript
+   * const users = await vaif.db.from('users').select('*').execute();
+   * ```
+   */
+  from(table) {
+    return new QueryBuilder(this.client, table);
+  }
+  /**
+   * Execute raw SQL query (admin only)
+   *
+   * @example
+   * ```typescript
+   * const result = await vaif.db.raw('SELECT * FROM users WHERE id = $1', [userId]);
+   * ```
+   */
+  async raw(sql, params) {
+    const response = await this.client.request("/db/query", {
+      method: "POST",
+      body: { sql, params }
+    });
+    if (response.error) {
+      return {
+        data: [],
+        error: {
+          message: response.error.message,
+          code: response.error.code ?? "QUERY_ERROR"
+        },
+        status: response.status
+      };
+    }
+    return {
+      data: response.data?.rows ?? [],
+      error: null,
+      status: response.status
+    };
+  }
+  /**
+   * Execute a function (stored procedure)
+   */
+  async rpc(functionName, params) {
+    const response = await this.client.request(`/db/rpc/${functionName}`, {
+      method: "POST",
+      body: params ?? {}
+    });
+    return {
+      data: response.data,
+      error: response.error ? {
+        message: response.error.message,
+        code: response.error.code ?? "RPC_ERROR"
+      } : null,
+      status: response.status
+    };
+  }
+};
+var QueryBuilder = class {
+  constructor(client, table) {
+    this.queryType = "select";
+    this.selectColumns = "*";
+    this.insertData = null;
+    this.updateData = null;
+    this.filters = [];
+    this.orderSpecs = [];
+    this.limitCount = null;
+    this.offsetCount = null;
+    this.returning = null;
+    this.countOption = null;
+    this.negateNext = false;
+    this.onConflictColumns = null;
+    this.onConflictAction = null;
+    this.onConflictUpdate = null;
+    this.client = client;
+    this.table = table;
+  }
+  /**
+   * Select columns
+   */
+  select(columns = "*") {
+    this.queryType = "select";
+    this.selectColumns = Array.isArray(columns) ? columns.join(", ") : columns;
+    return this;
+  }
+  /**
+   * Insert data
+   */
+  insert(data) {
+    this.queryType = "insert";
+    this.insertData = data;
+    return this;
+  }
+  /**
+   * Update data
+   */
+  update(data) {
+    this.queryType = "update";
+    this.updateData = data;
+    return this;
+  }
+  /**
+   * Delete rows
+   */
+  delete() {
+    this.queryType = "delete";
+    return this;
+  }
+  /**
+   * Handle insert conflicts (upsert)
+   */
+  onConflict(columns) {
+    this.onConflictColumns = Array.isArray(columns) ? columns : [columns];
+    return this;
+  }
+  /**
+   * Do nothing on conflict
+   */
+  doNothing() {
+    this.onConflictAction = "nothing";
+    return this;
+  }
+  /**
+   * Update on conflict
+   */
+  doUpdate(data) {
+    this.onConflictAction = "update";
+    this.onConflictUpdate = data;
+    return this;
+  }
+  // Filter methods
+  eq(column, value) {
+    this.addFilter(column, this.negateNext ? "neq" : "eq", value);
+    this.negateNext = false;
+    return this;
+  }
+  neq(column, value) {
+    this.addFilter(column, this.negateNext ? "eq" : "neq", value);
+    this.negateNext = false;
+    return this;
+  }
+  gt(column, value) {
+    this.addFilter(column, this.negateNext ? "lte" : "gt", value);
+    this.negateNext = false;
+    return this;
+  }
+  gte(column, value) {
+    this.addFilter(column, this.negateNext ? "lt" : "gte", value);
+    this.negateNext = false;
+    return this;
+  }
+  lt(column, value) {
+    this.addFilter(column, this.negateNext ? "gte" : "lt", value);
+    this.negateNext = false;
+    return this;
+  }
+  lte(column, value) {
+    this.addFilter(column, this.negateNext ? "gt" : "lte", value);
+    this.negateNext = false;
+    return this;
+  }
+  like(column, pattern) {
+    this.addFilter(column, this.negateNext ? "nlike" : "like", pattern);
+    this.negateNext = false;
+    return this;
+  }
+  ilike(column, pattern) {
+    this.addFilter(column, this.negateNext ? "nilike" : "ilike", pattern);
+    this.negateNext = false;
+    return this;
+  }
+  is(column, value) {
+    this.addFilter(column, this.negateNext ? "isnot" : "is", value);
+    this.negateNext = false;
+    return this;
+  }
+  in(column, values) {
+    this.addFilter(column, this.negateNext ? "nin" : "in", values);
+    this.negateNext = false;
+    return this;
+  }
+  contains(column, value) {
+    this.addFilter(column, "cs", value);
+    this.negateNext = false;
+    return this;
+  }
+  containedBy(column, value) {
+    this.addFilter(column, "cd", value);
+    this.negateNext = false;
+    return this;
+  }
+  overlaps(column, value) {
+    this.addFilter(column, "ov", value);
+    this.negateNext = false;
+    return this;
+  }
+  textSearch(column, query, options) {
+    this.addFilter(column, "fts", query, options?.config);
+    this.negateNext = false;
+    return this;
+  }
+  /**
+   * Negate the next filter
+   */
+  get not() {
+    this.negateNext = true;
+    return this;
+  }
+  /**
+   * Combine filters with OR
+   */
+  or(filters) {
+    this.filters.push({ type: "or", value: filters });
+    return this;
+  }
+  /**
+   * Order results
+   */
+  order(column, options = {}) {
+    this.orderSpecs.push({
+      column,
+      ascending: options.ascending ?? true,
+      nullsFirst: options.nullsFirst
+    });
+    return this;
+  }
+  /**
+   * Limit results
+   */
+  limit(count) {
+    this.limitCount = count;
+    return this;
+  }
+  /**
+   * Offset results
+   */
+  offset(count) {
+    this.offsetCount = count;
+    return this;
+  }
+  /**
+   * Range of results
+   */
+  range(from, to) {
+    this.offsetCount = from;
+    this.limitCount = to - from + 1;
+    return this;
+  }
+  /**
+   * Include count
+   */
+  count(type = "exact") {
+    this.countOption = type;
+    return this;
+  }
+  /**
+   * Return single result
+   */
+  async single() {
+    this.limitCount = 1;
+    const result = await this.execute();
+    if (result.error) {
+      return {
+        data: null,
+        error: result.error,
+        status: result.status
+      };
+    }
+    if (!result.data || result.data.length === 0) {
+      return {
+        data: null,
+        error: {
+          message: "No rows returned",
+          code: "PGRST116"
+        },
+        status: 406
+      };
+    }
+    return {
+      data: result.data[0],
+      error: null,
+      status: result.status
+    };
+  }
+  /**
+   * Return first result or null
+   */
+  async maybeSingle() {
+    this.limitCount = 1;
+    const result = await this.execute();
+    if (result.error) {
+      return {
+        data: null,
+        error: result.error,
+        status: result.status
+      };
+    }
+    return {
+      data: result.data?.[0] ?? null,
+      error: null,
+      status: result.status
+    };
+  }
+  /**
+   * Execute the query
+   */
+  async execute() {
+    const body = this.buildQuery();
+    const response = await this.client.request(
+      `/db/${this.table}`,
+      {
+        method: this.getHttpMethod(),
+        body
+      }
+    );
+    if (response.error) {
+      return {
+        data: [],
+        error: {
+          message: response.error.message,
+          code: response.error.code ?? "QUERY_ERROR",
+          details: response.error.details?.toString()
+        },
+        status: response.status
+      };
+    }
+    return {
+      data: response.data?.data ?? [],
+      error: null,
+      status: response.status,
+      count: response.data?.count
+    };
+  }
+  // Private helpers
+  addFilter(column, operator, value, extra) {
+    this.filters.push({ type: "filter", column, operator, value, extra });
+  }
+  getHttpMethod() {
+    switch (this.queryType) {
+      case "insert":
+        return "POST";
+      case "update":
+        return "PATCH";
+      case "delete":
+        return "DELETE";
+      default:
+        return "GET";
+    }
+  }
+  buildQuery() {
+    const query = {
+      type: this.queryType
+    };
+    if (this.queryType === "select") {
+      query.select = this.selectColumns;
+    }
+    if (this.queryType === "insert" && this.insertData) {
+      query.data = this.insertData;
+      if (this.onConflictColumns) {
+        query.onConflict = {
+          columns: this.onConflictColumns,
+          action: this.onConflictAction,
+          update: this.onConflictUpdate
+        };
+      }
+    }
+    if (this.queryType === "update" && this.updateData) {
+      query.data = this.updateData;
+    }
+    if (this.filters.length > 0) {
+      query.filters = this.filters;
+    }
+    if (this.orderSpecs.length > 0) {
+      query.order = this.orderSpecs;
+    }
+    if (this.limitCount !== null) {
+      query.limit = this.limitCount;
+    }
+    if (this.offsetCount !== null) {
+      query.offset = this.offsetCount;
+    }
+    if (this.countOption) {
+      query.count = this.countOption;
+    }
+    if (this.returning) {
+      query.returning = this.returning;
+    }
+    return query;
+  }
+};
+
+// src/lib/realtime.ts
+var VaifRealtime = class {
+  constructor(client) {
+    this.socket = null;
+    this.channels = /* @__PURE__ */ new Map();
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 10;
+    this.reconnectInterval = 1e3;
+    this.heartbeatInterval = null;
+    this.client = client;
+  }
+  /**
+   * Connect to realtime server
+   */
+  connect(options = {}) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      return;
+    }
+    const config = this.client.getConfig();
+    const url = new URL(config.realtimeUrl);
+    url.searchParams.set("apikey", config.apiKey);
+    url.searchParams.set("project", config.projectId);
+    const token = this.client.getAccessToken();
+    if (token) {
+      url.searchParams.set("token", token);
+    }
+    this.socket = new WebSocket(url.toString());
+    this.socket.onopen = () => {
+      this.client.debug("Realtime connected");
+      this.reconnectAttempts = 0;
+      if (options.heartbeat !== false) {
+        this.startHeartbeat(options.heartbeatInterval ?? 3e4);
+      }
+      this.channels.forEach((channel) => {
+        channel.resubscribe();
+      });
+    };
+    this.socket.onmessage = (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        this.handleMessage(message);
+      } catch {
+        this.client.debug("Failed to parse realtime message");
+      }
+    };
+    this.socket.onclose = () => {
+      this.client.debug("Realtime disconnected");
+      this.stopHeartbeat();
+      if (options.autoReconnect !== false && this.reconnectAttempts < (options.maxReconnectAttempts ?? this.maxReconnectAttempts)) {
+        this.reconnectAttempts++;
+        const delay = Math.min(
+          (options.reconnectInterval ?? this.reconnectInterval) * this.reconnectAttempts,
+          3e4
+        );
+        setTimeout(() => this.connect(options), delay);
+      }
+    };
+    this.socket.onerror = (error) => {
+      this.client.debug("Realtime error", error);
+    };
+  }
+  /**
+   * Disconnect from realtime server
+   */
+  disconnect() {
+    this.stopHeartbeat();
+    this.channels.forEach((channel) => channel.unsubscribe());
+    this.channels.clear();
+    this.socket?.close();
+    this.socket = null;
+  }
+  /**
+   * Create or get a channel
+   */
+  channel(name) {
+    let channel = this.channels.get(name);
+    if (!channel) {
+      channel = new RealtimeChannel(this, name);
+      this.channels.set(name, channel);
+    }
+    return channel;
+  }
+  /**
+   * Remove a channel
+   */
+  removeChannel(name) {
+    const channel = this.channels.get(name);
+    if (channel) {
+      channel.unsubscribe();
+      this.channels.delete(name);
+    }
+  }
+  /**
+   * Send message to server
+   */
+  send(message) {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      this.socket.send(JSON.stringify(message));
+    }
+  }
+  /**
+   * Get WebSocket instance
+   */
+  getSocket() {
+    return this.socket;
+  }
+  handleMessage(message) {
+    const channel = this.channels.get(message.topic);
+    if (channel) {
+      channel.handleMessage(message);
+    }
+  }
+  startHeartbeat(interval) {
+    this.heartbeatInterval = setInterval(() => {
+      this.send({ topic: "phoenix", event: "heartbeat", payload: {} });
+    }, interval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+};
+var RealtimeChannel = class {
+  constructor(realtime, name) {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.status = "CLOSED";
+    this.presenceState = /* @__PURE__ */ new Map();
+    this.realtime = realtime;
+    this.name = name;
+  }
+  on(event, filter, callback) {
+    const key = `${event}:${JSON.stringify(filter)}`;
+    const callbacks = this.subscriptions.get(key) ?? [];
+    callbacks.push(callback);
+    this.subscriptions.set(key, callbacks);
+    return this;
+  }
+  /**
+   * Subscribe to channel
+   */
+  subscribe(callback) {
+    this.realtime.send({
+      topic: this.name,
+      event: "phx_join",
+      payload: {
+        subscriptions: Array.from(this.subscriptions.keys())
+      },
+      ref: `${this.name}-join`
+    });
+    this.status = "SUBSCRIBED";
+    callback?.(this.status);
+    return this;
+  }
+  /**
+   * Unsubscribe from channel
+   */
+  unsubscribe() {
+    this.realtime.send({
+      topic: this.name,
+      event: "phx_leave",
+      payload: {},
+      ref: `${this.name}-leave`
+    });
+    this.status = "CLOSED";
+    this.subscriptions.clear();
+  }
+  /**
+   * Broadcast message to channel
+   */
+  broadcast(event, payload) {
+    this.realtime.send({
+      topic: this.name,
+      event: "broadcast",
+      payload: { event, payload }
+    });
+  }
+  /**
+   * Track presence
+   */
+  track(payload) {
+    this.realtime.send({
+      topic: this.name,
+      event: "presence",
+      payload: { type: "track", payload }
+    });
+  }
+  /**
+   * Untrack presence
+   */
+  untrack() {
+    this.realtime.send({
+      topic: this.name,
+      event: "presence",
+      payload: { type: "untrack" }
+    });
+  }
+  /**
+   * Get current presence state
+   */
+  getPresenceState() {
+    return this.presenceState;
+  }
+  /**
+   * Handle incoming message
+   */
+  handleMessage(message) {
+    this.subscriptions.forEach((callbacks, key) => {
+      const [event] = key.split(":");
+      if (message.event === event || message.event === "broadcast") {
+        callbacks.forEach((callback) => callback(message.payload));
+      }
+    });
+  }
+  /**
+   * Resubscribe after reconnect
+   */
+  resubscribe() {
+    if (this.subscriptions.size > 0) {
+      this.subscribe();
+    }
+  }
+};
+
+// src/lib/storage.ts
+var VaifStorage = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get a storage bucket
+   */
+  from(bucket) {
+    return new StorageBucket(this.client, bucket);
+  }
+  /**
+   * List all buckets
+   */
+  async listBuckets() {
+    const response = await this.client.request("/storage/buckets");
+    return {
+      data: response.data,
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "STORAGE_ERROR"
+      } : null
+    };
+  }
+  /**
+   * Create a bucket
+   */
+  async createBucket(name, options = {}) {
+    const response = await this.client.request("/storage/buckets", {
+      method: "POST",
+      body: { name, ...options }
+    });
+    return {
+      data: response.data,
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "STORAGE_ERROR"
+      } : null
+    };
+  }
+  /**
+   * Delete a bucket
+   */
+  async deleteBucket(name) {
+    const response = await this.client.request(`/storage/buckets/${name}`, {
+      method: "DELETE"
+    });
+    return {
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "STORAGE_ERROR"
+      } : null
+    };
+  }
+};
+var StorageBucket = class {
+  constructor(client, bucket) {
+    this.client = client;
+    this.bucket = bucket;
+  }
+  /**
+   * Upload a file
+   */
+  async upload(path, file, options = {}) {
+    const formData = new FormData();
+    if (file instanceof File) {
+      formData.append("file", file);
+    } else if (file instanceof Blob) {
+      formData.append("file", file, path.split("/").pop() ?? "file");
+    } else if (file instanceof ArrayBuffer) {
+      formData.append("file", new Blob([file]), path.split("/").pop() ?? "file");
+    } else if (typeof file === "string") {
+      const blob = await fetch(file).then((r) => r.blob());
+      formData.append("file", blob, path.split("/").pop() ?? "file");
+    }
+    if (options.contentType) {
+      formData.append("contentType", options.contentType);
+    }
+    if (options.cacheControl) {
+      formData.append("cacheControl", options.cacheControl);
+    }
+    if (options.upsert) {
+      formData.append("upsert", "true");
+    }
+    if (options.metadata) {
+      formData.append("metadata", JSON.stringify(options.metadata));
+    }
+    const response = await this.client.request(
+      `/storage/${this.bucket}/${path}`,
+      {
+        method: "POST",
+        headers: {
+          // Don't set Content-Type, let browser set it with boundary
+        },
+        body: formData
+      }
+    );
+    return {
+      data: response.data,
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "UPLOAD_ERROR"
+      } : null
+    };
+  }
+  /**
+   * Download a file
+   */
+  async download(path, options = {}) {
+    const params = {};
+    if (options.transform) {
+      if (options.transform.width) params.width = String(options.transform.width);
+      if (options.transform.height) params.height = String(options.transform.height);
+      if (options.transform.resize) params.resize = options.transform.resize;
+      if (options.transform.format) params.format = options.transform.format;
+      if (options.transform.quality) params.quality = String(options.transform.quality);
+    }
+    const url = new URL(`/storage/${this.bucket}/${path}`, this.client.getConfig().apiUrl);
+    Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
+    try {
+      const response = await fetch(url.toString(), {
+        headers: {
+          apikey: this.client.getConfig().apiKey,
+          Authorization: `Bearer ${this.client.getAccessToken() ?? this.client.getConfig().apiKey}`
+        }
+      });
+      if (!response.ok) {
+        return {
+          data: null,
+          error: {
+            message: `Download failed: ${response.statusText}`,
+            statusCode: String(response.status),
+            error: "DOWNLOAD_ERROR"
+          }
+        };
+      }
+      return { data: await response.blob(), error: null };
+    } catch (err) {
+      return {
+        data: null,
+        error: {
+          message: err instanceof Error ? err.message : "Download failed",
+          statusCode: "0",
+          error: "NETWORK_ERROR"
+        }
+      };
+    }
+  }
+  /**
+   * Get public URL for a file
+   */
+  getPublicUrl(path) {
+    const config = this.client.getConfig();
+    return {
+      data: {
+        publicUrl: `${config.apiUrl}/storage/${this.bucket}/${path}`
+      }
+    };
+  }
+  /**
+   * Create signed URL
+   */
+  async createSignedUrl(path, options) {
+    const response = await this.client.request(
+      `/storage/${this.bucket}/${path}/sign`,
+      {
+        method: "POST",
+        body: {
+          expiresIn: options.expiresIn,
+          transform: options.transform,
+          download: options.download
+        }
+      }
+    );
+    return {
+      data: response.data,
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "SIGN_ERROR"
+      } : null
+    };
+  }
+  /**
+   * List files in a path
+   */
+  async list(path = "", options = {}) {
+    const response = await this.client.request(
+      `/storage/${this.bucket}/list`,
+      {
+        method: "POST",
+        body: {
+          prefix: path,
+          limit: options.limit,
+          offset: options.offset,
+          search: options.search,
+          sortBy: options.sortBy
+        }
+      }
+    );
+    return {
+      data: response.data,
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "LIST_ERROR"
+      } : null
+    };
+  }
+  /**
+   * Move/rename a file
+   */
+  async move(fromPath, toPath) {
+    const response = await this.client.request(`/storage/${this.bucket}/move`, {
+      method: "POST",
+      body: { from: fromPath, to: toPath }
+    });
+    return {
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "MOVE_ERROR"
+      } : null
+    };
+  }
+  /**
+   * Copy a file
+   */
+  async copy(fromPath, toPath) {
+    const response = await this.client.request(`/storage/${this.bucket}/copy`, {
+      method: "POST",
+      body: { from: fromPath, to: toPath }
+    });
+    return {
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "COPY_ERROR"
+      } : null
+    };
+  }
+  /**
+   * Delete a file
+   */
+  async remove(paths) {
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    const response = await this.client.request(`/storage/${this.bucket}/delete`, {
+      method: "DELETE",
+      body: { paths: pathArray }
+    });
+    return {
+      error: response.error ? {
+        message: response.error.message,
+        statusCode: String(response.status),
+        error: response.error.code ?? "DELETE_ERROR"
+      } : null
+    };
+  }
+};
+
+// src/lib/functions.ts
+var VaifFunctions = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Invoke an edge function
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.functions.invoke('send-email', {
+   *   body: { to: 'user@example.com', subject: 'Hello' }
+   * });
+   * ```
+   */
+  async invoke(functionName, options = {}) {
+    const config = this.client.getConfig();
+    const url = new URL(
+      `/functions/${functionName}`,
+      config.apiUrl
+    );
+    const headers = {
+      "X-Project-ID": config.projectId,
+      apikey: config.apiKey,
+      ...options.headers
+    };
+    const token = this.client.getAccessToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    if (options.body !== void 0) {
+      if (options.body instanceof FormData) {
+      } else if (options.body instanceof Blob) {
+        headers["Content-Type"] = options.body.type || "application/octet-stream";
+      } else {
+        headers["Content-Type"] = "application/json";
+      }
+    }
+    const timeoutMs = options.timeout ?? config.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url.toString(), {
+        method: options.method ?? "POST",
+        headers,
+        body: this.serializeBody(options.body),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const contentType = response.headers.get("content-type");
+      let data = null;
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      } else if (contentType?.includes("text/")) {
+        data = await response.text();
+      } else if (response.body) {
+        data = await response.blob();
+      }
+      if (!response.ok) {
+        const error = {
+          message: typeof data === "object" && data !== null && "message" in data ? data.message : `Function invocation failed with status ${response.status}`,
+          status: response.status,
+          name: functionName
+        };
+        return { data: null, error };
+      }
+      return { data, error: null };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      const error = {
+        message: err instanceof Error ? err.name === "AbortError" ? "Function invocation timed out" : err.message : "Function invocation failed",
+        status: 0,
+        name: functionName
+      };
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create a function URL for direct invocation
+   */
+  createUrl(functionName) {
+    const config = this.client.getConfig();
+    return `${config.apiUrl}/functions/${functionName}`;
+  }
+  /**
+   * Get list of deployed functions
+   */
+  async list() {
+    const response = await this.client.request("/functions");
+    return {
+      data: response.data,
+      error: response.error ? {
+        message: response.error.message,
+        status: response.status,
+        name: "list"
+      } : null
+    };
+  }
+  /**
+   * Get function details
+   */
+  async get(functionName) {
+    const response = await this.client.request(`/functions/${functionName}`);
+    return {
+      data: response.data,
+      error: response.error ? {
+        message: response.error.message,
+        status: response.status,
+        name: functionName
+      } : null
+    };
+  }
+  serializeBody(body) {
+    if (body === void 0) {
+      return void 0;
+    }
+    if (body instanceof FormData || body instanceof Blob) {
+      return body;
+    }
+    return JSON.stringify(body);
+  }
+};
+
+// src/lib/auth.ts
+var VaifAuth = class {
+  constructor(client) {
+    this.currentSession = null;
+    this.currentUser = null;
+    this.stateChangeCallbacks = /* @__PURE__ */ new Set();
+    this.refreshTimeout = null;
+    this.client = client;
+    this.restoreSession();
+  }
+  /**
+   * Get current session
+   */
+  async getSession() {
+    return {
+      data: { session: this.currentSession },
+      error: null
+    };
+  }
+  /**
+   * Get current user synchronously from cache
+   */
+  get user() {
+    return this.currentUser;
+  }
+  /**
+   * Get current user (fetches fresh data)
+   */
+  async getUser() {
+    if (!this.currentSession) {
+      return { data: { user: this.currentUser }, error: null };
+    }
+    const response = await this.client.request("/auth/user");
+    if (response.error) {
+      return {
+        data: { user: this.currentUser },
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    this.currentUser = response.data ?? null;
+    return { data: { user: this.currentUser }, error: null };
+  }
+  /**
+   * Sign up with email and password
+   */
+  async signUp(options) {
+    const response = await this.client.request("/auth/signup", {
+      method: "POST",
+      body: {
+        email: options.email,
+        password: options.password,
+        phone: options.phone,
+        data: options.data,
+        redirectTo: options.redirectTo
+      }
+    });
+    if (response.error) {
+      return {
+        data: { session: null, user: null },
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    const { session, user } = response.data ?? { session: null, user: null };
+    if (session) {
+      await this.setSession(session);
+      this.notifyStateChange("SIGNED_IN", session);
+    }
+    return {
+      data: { session, user },
+      error: null
+    };
+  }
+  /**
+   * Sign in with email and password
+   */
+  async signInWithPassword(options) {
+    const response = await this.client.request("/auth/token?grant_type=password", {
+      method: "POST",
+      body: {
+        email: options.email,
+        password: options.password,
+        phone: options.phone
+      }
+    });
+    if (response.error) {
+      return {
+        data: { session: null, user: null },
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    const { session, user } = response.data ?? { session: null, user: null };
+    if (session) {
+      await this.setSession(session);
+      this.notifyStateChange("SIGNED_IN", session);
+    }
+    return {
+      data: { session, user },
+      error: null
+    };
+  }
+  /**
+   * Sign in with OAuth provider
+   */
+  async signInWithOAuth(options) {
+    const config = this.client.getConfig();
+    const redirectTo = options.redirectTo ?? (typeof window !== "undefined" ? window.location?.origin : "") ?? "";
+    const params = new URLSearchParams({
+      provider: options.provider,
+      redirect_to: redirectTo
+    });
+    if (options.scopes) {
+      params.set("scopes", options.scopes);
+    }
+    if (options.queryParams) {
+      Object.entries(options.queryParams).forEach(([key, value]) => {
+        params.set(key, value);
+      });
+    }
+    const url = `${config.apiUrl}/auth/authorize?${params.toString()}`;
+    return {
+      data: {
+        provider: options.provider,
+        url
+      },
+      error: null
+    };
+  }
+  /**
+   * Sign in with magic link (passwordless)
+   */
+  async signInWithOtp(options) {
+    const response = await this.client.request("/auth/otp", {
+      method: "POST",
+      body: {
+        email: options.email,
+        phone: options.phone,
+        create_user: options.createUser ?? true,
+        redirect_to: options.redirectTo
+      }
+    });
+    if (response.error) {
+      return {
+        data: {},
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    return {
+      data: { messageId: response.data?.messageId },
+      error: null
+    };
+  }
+  /**
+   * Verify OTP code
+   */
+  async verifyOtp(options) {
+    const response = await this.client.request("/auth/verify", {
+      method: "POST",
+      body: {
+        email: options.email,
+        phone: options.phone,
+        token: options.token,
+        type: options.type
+      }
+    });
+    if (response.error) {
+      return {
+        data: { session: null, user: null },
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    const { session, user } = response.data ?? { session: null, user: null };
+    if (session) {
+      await this.setSession(session);
+      this.notifyStateChange("SIGNED_IN", session);
+    }
+    return {
+      data: { session, user },
+      error: null
+    };
+  }
+  /**
+   * Sign out
+   */
+  async signOut(options) {
+    const scope = options?.scope ?? "local";
+    if (scope !== "local") {
+      await this.client.request("/auth/logout", {
+        method: "POST",
+        body: { scope }
+      });
+    }
+    await this.clearSession();
+    this.notifyStateChange("SIGNED_OUT", null);
+    return { error: null };
+  }
+  /**
+   * Reset password
+   */
+  async resetPasswordForEmail(options) {
+    const response = await this.client.request("/auth/recover", {
+      method: "POST",
+      body: {
+        email: options.email,
+        redirect_to: options.redirectTo,
+        captcha_token: options.captchaToken
+      }
+    });
+    if (response.error) {
+      return {
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    return { error: null };
+  }
+  /**
+   * Update user
+   */
+  async updateUser(options) {
+    const response = await this.client.request("/auth/user", {
+      method: "PUT",
+      body: {
+        email: options.email,
+        password: options.password,
+        phone: options.phone,
+        data: options.data,
+        nonce: options.nonce
+      }
+    });
+    if (response.error) {
+      return {
+        data: { user: null },
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    this.currentUser = response.data;
+    this.notifyStateChange("USER_UPDATED", this.currentSession);
+    return { data: { user: response.data }, error: null };
+  }
+  /**
+   * Refresh session
+   */
+  async refreshSession() {
+    if (!this.currentSession?.refreshToken) {
+      return {
+        data: { session: null, user: null },
+        error: { message: "No refresh token available", status: 401 }
+      };
+    }
+    const response = await this.client.request("/auth/token?grant_type=refresh_token", {
+      method: "POST",
+      body: {
+        refresh_token: this.currentSession.refreshToken
+      }
+    });
+    if (response.error) {
+      await this.clearSession();
+      this.notifyStateChange("TOKEN_REFRESHED", null);
+      return {
+        data: { session: null, user: null },
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    const { session, user } = response.data ?? { session: null, user: null };
+    if (session) {
+      await this.setSession(session);
+      this.notifyStateChange("TOKEN_REFRESHED", session);
+    }
+    return {
+      data: { session, user },
+      error: null
+    };
+  }
+  /**
+   * Set session from URL (after OAuth redirect)
+   */
+  async setSessionFromUrl() {
+    if (typeof window === "undefined") {
+      return {
+        data: { session: null, user: null },
+        error: { message: "Not in browser environment", status: 0 }
+      };
+    }
+    const hashParams = new URLSearchParams(window.location.hash.slice(1));
+    const accessToken = hashParams.get("access_token");
+    const refreshToken = hashParams.get("refresh_token");
+    const expiresIn = hashParams.get("expires_in");
+    const tokenType = hashParams.get("token_type");
+    if (!accessToken) {
+      const error = hashParams.get("error_description") || hashParams.get("error");
+      return {
+        data: { session: null, user: null },
+        error: error ? { message: error, status: 0 } : null
+      };
+    }
+    const session = {
+      accessToken,
+      refreshToken: refreshToken ?? "",
+      expiresIn: expiresIn ? parseInt(expiresIn, 10) : 3600,
+      expiresAt: Date.now() + (expiresIn ? parseInt(expiresIn, 10) * 1e3 : 36e5),
+      tokenType: tokenType ?? "bearer",
+      user: null
+    };
+    this.client.setAccessToken(accessToken);
+    const userResponse = await this.client.request("/auth/user");
+    if (userResponse.data) {
+      session.user = userResponse.data;
+    }
+    await this.setSession(session);
+    this.notifyStateChange("SIGNED_IN", session);
+    window.history.replaceState(null, "", window.location.pathname);
+    return {
+      data: { session, user: session.user },
+      error: null
+    };
+  }
+  /**
+   * Subscribe to auth state changes
+   */
+  onAuthStateChange(callback) {
+    this.stateChangeCallbacks.add(callback);
+    if (this.currentSession) {
+      callback("INITIAL_SESSION", this.currentSession);
+    }
+    return {
+      data: {
+        subscription: {
+          unsubscribe: () => {
+            this.stateChangeCallbacks.delete(callback);
+          }
+        }
+      }
+    };
+  }
+  /**
+   * Exchange code for session (PKCE flow)
+   */
+  async exchangeCodeForSession(code) {
+    const response = await this.client.request("/auth/token?grant_type=authorization_code", {
+      method: "POST",
+      body: { code }
+    });
+    if (response.error) {
+      return {
+        data: { session: null, user: null },
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    const { session, user } = response.data ?? { session: null, user: null };
+    if (session) {
+      await this.setSession(session);
+      this.notifyStateChange("SIGNED_IN", session);
+    }
+    return {
+      data: { session, user },
+      error: null
+    };
+  }
+  /**
+   * Resend confirmation email
+   */
+  async resend(options) {
+    const response = await this.client.request("/auth/resend", {
+      method: "POST",
+      body: options
+    });
+    if (response.error) {
+      return {
+        error: {
+          message: response.error.message,
+          status: response.status
+        }
+      };
+    }
+    return { error: null };
+  }
+  // Private methods
+  async setSession(session) {
+    this.currentSession = session;
+    this.currentUser = session.user;
+    this.client.setAccessToken(session.accessToken);
+    const config = this.client.getConfig();
+    if (config.persistSession) {
+      await config.storage.setItem(
+        `vaif-session-${config.projectId}`,
+        JSON.stringify({
+          accessToken: session.accessToken,
+          refreshToken: session.refreshToken,
+          expiresAt: session.expiresAt
+        })
+      );
+    }
+    if (config.autoRefreshToken) {
+      this.scheduleRefresh(session);
+    }
+  }
+  async clearSession() {
+    this.currentSession = null;
+    this.currentUser = null;
+    this.client.setAccessToken(null);
+    if (this.refreshTimeout) {
+      clearTimeout(this.refreshTimeout);
+      this.refreshTimeout = null;
+    }
+    const config = this.client.getConfig();
+    if (config.persistSession) {
+      await config.storage.removeItem(`vaif-session-${config.projectId}`);
+    }
+  }
+  async restoreSession() {
+    const config = this.client.getConfig();
+    if (!config.persistSession) return;
+    try {
+      const sessionStr = await config.storage.getItem(`vaif-session-${config.projectId}`);
+      if (!sessionStr) return;
+      const stored = JSON.parse(sessionStr);
+      if (!stored.accessToken || stored.expiresAt < Date.now()) {
+        await this.clearSession();
+        return;
+      }
+      this.client.setAccessToken(stored.accessToken);
+      const response = await this.client.request("/auth/session");
+      if (response.data?.session) {
+        await this.setSession(response.data.session);
+        this.notifyStateChange("INITIAL_SESSION", response.data.session);
+      } else {
+        await this.clearSession();
+      }
+    } catch {
+      await this.clearSession();
+    }
+  }
+  scheduleRefresh(session) {
+    if (this.refreshTimeout) {
+      clearTimeout(this.refreshTimeout);
+    }
+    const expiresIn = session.expiresAt - Date.now() - 6e4;
+    if (expiresIn > 0) {
+      this.refreshTimeout = setTimeout(() => {
+        this.refreshSession();
+      }, expiresIn);
+    }
+  }
+  notifyStateChange(event, session) {
+    this.stateChangeCallbacks.forEach((callback) => {
+      try {
+        callback(event, session);
+      } catch {
+      }
+    });
+  }
+};
+
+// src/lib/ai.ts
+var VaifAI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Generate database schema from natural language
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.ai.generateSchema({
+   *   prompt: 'Create a blog with posts, authors, and comments',
+   *   format: 'drizzle',
+   *   includeRelations: true
+   * });
+   * ```
+   */
+  async generateSchema(request, options = {}) {
+    const response = await this.client.request(
+      "/ai/generate/schema",
+      {
+        method: "POST",
+        body: {
+          ...request,
+          model: options.model,
+          temperature: options.temperature,
+          maxTokens: options.maxTokens
+        }
+      }
+    );
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Generate edge function from natural language
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.ai.generateFunction({
+   *   prompt: 'Create a function that sends welcome emails to new users',
+   *   name: 'send-welcome-email',
+   *   runtime: 'edge'
+   * });
+   * ```
+   */
+  async generateFunction(request, options = {}) {
+    const response = await this.client.request(
+      "/ai/generate/function",
+      {
+        method: "POST",
+        body: {
+          ...request,
+          model: options.model,
+          temperature: options.temperature,
+          maxTokens: options.maxTokens
+        }
+      }
+    );
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Generate API endpoint from natural language
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.ai.generateEndpoint({
+   *   prompt: 'Create an endpoint to get user profile with their recent posts',
+   *   method: 'GET',
+   *   path: '/users/:id/profile',
+   *   requiresAuth: true
+   * });
+   * ```
+   */
+  async generateEndpoint(request, options = {}) {
+    const response = await this.client.request(
+      "/ai/generate/endpoint",
+      {
+        method: "POST",
+        body: {
+          ...request,
+          model: options.model,
+          temperature: options.temperature,
+          maxTokens: options.maxTokens
+        }
+      }
+    );
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Chat with AI assistant for project help
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.ai.chat({
+   *   messages: [
+   *     { role: 'user', content: 'How do I add pagination to my posts query?' }
+   *   ],
+   *   context: {
+   *     schema: mySchemaString
+   *   }
+   * });
+   * ```
+   */
+  async chat(request, options = {}) {
+    const response = await this.client.request("/ai/chat", {
+      method: "POST",
+      body: {
+        ...request,
+        model: options.model,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens
+      }
+    });
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Stream chat response
+   *
+   * @example
+   * ```typescript
+   * for await (const chunk of vaif.ai.chatStream({
+   *   messages: [{ role: 'user', content: 'Explain this schema' }]
+   * })) {
+   *   process.stdout.write(chunk);
+   * }
+   * ```
+   */
+  async *chatStream(request, options = {}) {
+    const config = this.client.getConfig();
+    const url = new URL("/ai/chat/stream", config.apiUrl);
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Project-ID": config.projectId,
+      apikey: config.apiKey
+    };
+    const token = this.client.getAccessToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        ...request,
+        model: options.model,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        stream: true
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`AI chat failed: ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split("\n");
+        for (const line of lines) {
+          if (line.startsWith("data: ")) {
+            const data = line.slice(6);
+            if (data === "[DONE]") {
+              return;
+            }
+            try {
+              const parsed = JSON.parse(data);
+              if (parsed.content) {
+                yield parsed.content;
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Get AI credits information
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await vaif.ai.getCredits();
+   * console.log(`Balance: ${data.balance} credits`);
+   * ```
+   */
+  async getCredits() {
+    const response = await this.client.request("/ai/credits");
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Explain code or schema
+   */
+  async explain(code, options = {}) {
+    const response = await this.client.request(
+      "/ai/explain",
+      {
+        method: "POST",
+        body: {
+          code,
+          language: options.language,
+          context: options.context,
+          model: options.model,
+          temperature: options.temperature
+        }
+      }
+    );
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Review code for issues and improvements
+   */
+  async review(code, options = {}) {
+    const response = await this.client.request("/ai/review", {
+      method: "POST",
+      body: {
+        code,
+        language: options.language,
+        focus: options.focus,
+        model: options.model,
+        temperature: options.temperature
+      }
+    });
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Generate TypeScript types from schema
+   */
+  async generateTypes(schema, options = {}) {
+    const response = await this.client.request(
+      "/ai/generate/types",
+      {
+        method: "POST",
+        body: {
+          schema,
+          format: options.format ?? "typescript",
+          model: options.model
+        }
+      }
+    );
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+  /**
+   * Generate SQL migration from schema diff
+   */
+  async generateMigration(options) {
+    const response = await this.client.request("/ai/generate/migration", {
+      method: "POST",
+      body: {
+        currentSchema: options.currentSchema,
+        targetSchema: options.targetSchema,
+        database: options.database ?? "postgresql",
+        model: options.model
+      }
+    });
+    if (response.error) {
+      return {
+        data: null,
+        error: {
+          message: response.error.message,
+          code: response.error.code,
+          status: response.status
+        }
+      };
+    }
+    return { data: response.data, error: null };
+  }
+};
+
+// src/lib/typegen.ts
+var PG_TO_TS_TYPES = {
+  // Numeric
+  smallint: "number",
+  integer: "number",
+  bigint: "number",
+  int2: "number",
+  int4: "number",
+  int8: "number",
+  decimal: "number",
+  numeric: "number",
+  real: "number",
+  "double precision": "number",
+  float4: "number",
+  float8: "number",
+  serial: "number",
+  bigserial: "number",
+  smallserial: "number",
+  money: "number",
+  // String
+  character: "string",
+  "character varying": "string",
+  varchar: "string",
+  char: "string",
+  text: "string",
+  name: "string",
+  citext: "string",
+  // Boolean
+  boolean: "boolean",
+  bool: "boolean",
+  // Date/Time
+  date: "string",
+  time: "string",
+  "time with time zone": "string",
+  "time without time zone": "string",
+  timestamp: "string",
+  "timestamp with time zone": "string",
+  "timestamp without time zone": "string",
+  timestamptz: "string",
+  timetz: "string",
+  interval: "string",
+  // Binary
+  bytea: "string",
+  // UUID
+  uuid: "string",
+  // JSON
+  json: "unknown",
+  jsonb: "unknown",
+  // Arrays (handled separately)
+  "ARRAY": "unknown[]",
+  // Network
+  inet: "string",
+  cidr: "string",
+  macaddr: "string",
+  macaddr8: "string",
+  // Geometric
+  point: "{ x: number; y: number }",
+  line: "string",
+  lseg: "string",
+  box: "string",
+  path: "string",
+  polygon: "string",
+  circle: "string",
+  // Text search
+  tsvector: "string",
+  tsquery: "string",
+  // Other
+  xml: "string",
+  void: "void",
+  unknown: "unknown"
+};
+var VaifTypeGen = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Fetch database schema from the API.
+   */
+  async fetchSchema(schema = "public") {
+    const response = await this.client.request(
+      `/database/schema?schema=${schema}`
+    );
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.data;
+  }
+  /**
+   * Generate TypeScript types from schema.
+   */
+  async generate(options = {}) {
+    const {
+      includeRow = true,
+      includeInsert = true,
+      includeUpdate = true,
+      includeRelationships = true,
+      schema = "public",
+      tables = [],
+      excludeTables = [],
+      includeComments = true,
+      exportFormat = "named",
+      namespace = "Database"
+    } = options;
+    const dbSchema = await this.fetchSchema(schema);
+    const lines = [];
+    lines.push("/**");
+    lines.push(" * VAIF Studio Database Types");
+    lines.push(` * Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    lines.push(" * DO NOT EDIT - This file is auto-generated");
+    lines.push(" */");
+    lines.push("");
+    if (dbSchema.enums.length > 0) {
+      lines.push("// Enums");
+      for (const enumDef of dbSchema.enums) {
+        lines.push(...this.generateEnum(enumDef, includeComments));
+        lines.push("");
+      }
+    }
+    let filteredTables = dbSchema.tables.filter((t) => {
+      if (tables.length > 0 && !tables.includes(t.name)) return false;
+      if (excludeTables.includes(t.name)) return false;
+      return true;
+    });
+    const tableTypes = [];
+    for (const table of filteredTables) {
+      const types = this.generateTableTypes(table, {
+        includeRow,
+        includeInsert,
+        includeUpdate,
+        includeRelationships,
+        includeComments,
+        allTables: dbSchema.tables
+      });
+      tableTypes.push(types);
+    }
+    for (const view of dbSchema.views) {
+      if (tables.length > 0 && !tables.includes(view.name)) continue;
+      if (excludeTables.includes(view.name)) continue;
+      const types = this.generateViewTypes(view, includeComments);
+      tableTypes.push(types);
+    }
+    if (exportFormat === "namespace") {
+      lines.push(`export namespace ${namespace} {`);
+      for (const types of tableTypes) {
+        lines.push(this.indent(types, 2));
+      }
+      lines.push("}");
+    } else {
+      lines.push(...tableTypes);
+    }
+    lines.push("");
+    lines.push("// Database type helper");
+    lines.push("export interface Database {");
+    lines.push("  public: {");
+    lines.push("    Tables: {");
+    for (const table of filteredTables) {
+      const pascalName = this.toPascalCase(table.name);
+      lines.push(`      ${table.name}: {`);
+      if (includeRow) lines.push(`        Row: ${pascalName}Row;`);
+      if (includeInsert) lines.push(`        Insert: ${pascalName}Insert;`);
+      if (includeUpdate) lines.push(`        Update: ${pascalName}Update;`);
+      lines.push("      };");
+    }
+    lines.push("    };");
+    lines.push("    Views: {");
+    for (const view of dbSchema.views) {
+      const pascalName = this.toPascalCase(view.name);
+      lines.push(`      ${view.name}: {`);
+      lines.push(`        Row: ${pascalName}Row;`);
+      lines.push("      };");
+    }
+    lines.push("    };");
+    lines.push("    Enums: {");
+    for (const enumDef of dbSchema.enums) {
+      lines.push(`      ${enumDef.name}: ${this.toPascalCase(enumDef.name)};`);
+    }
+    lines.push("    };");
+    lines.push("  };");
+    lines.push("}");
+    return lines.join("\n");
+  }
+  /**
+   * Generate TypeScript from schema JSON directly.
+   */
+  generateFromSchema(schema, options = {}) {
+    const {
+      includeRow = true,
+      includeInsert = true,
+      includeUpdate = true,
+      includeRelationships = true,
+      tables = [],
+      excludeTables = [],
+      includeComments = true,
+      exportFormat = "named",
+      namespace = "Database"
+    } = options;
+    const lines = [];
+    lines.push("/**");
+    lines.push(" * VAIF Studio Database Types");
+    lines.push(` * Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    lines.push(" * DO NOT EDIT - This file is auto-generated");
+    lines.push(" */");
+    lines.push("");
+    if (schema.enums && schema.enums.length > 0) {
+      lines.push("// Enums");
+      for (const enumDef of schema.enums) {
+        lines.push(...this.generateEnum(enumDef, includeComments));
+        lines.push("");
+      }
+    }
+    let filteredTables = (schema.tables || []).filter((t) => {
+      if (tables.length > 0 && !tables.includes(t.name)) return false;
+      if (excludeTables.includes(t.name)) return false;
+      return true;
+    });
+    const tableTypes = [];
+    for (const table of filteredTables) {
+      const types = this.generateTableTypes(table, {
+        includeRow,
+        includeInsert,
+        includeUpdate,
+        includeRelationships,
+        includeComments,
+        allTables: schema.tables
+      });
+      tableTypes.push(types);
+    }
+    if (exportFormat === "namespace") {
+      lines.push(`export namespace ${namespace} {`);
+      for (const types of tableTypes) {
+        lines.push(this.indent(types, 2));
+      }
+      lines.push("}");
+    } else {
+      lines.push(...tableTypes);
+    }
+    return lines.join("\n");
+  }
+  generateEnum(enumDef, includeComments) {
+    const lines = [];
+    const name = this.toPascalCase(enumDef.name);
+    if (includeComments) {
+      lines.push(`/** Enum: ${enumDef.name} */`);
+    }
+    lines.push(`export type ${name} = ${enumDef.values.map((v) => `'${v}'`).join(" | ")};`);
+    return lines;
+  }
+  generateTableTypes(table, options) {
+    const lines = [];
+    const pascalName = this.toPascalCase(table.name);
+    if (options.includeRow) {
+      if (options.includeComments && table.comment) {
+        lines.push(`/** ${table.comment} */`);
+      }
+      lines.push(`export interface ${pascalName}Row {`);
+      for (const col of table.columns) {
+        const tsType = this.pgTypeToTs(col.type);
+        const nullable = col.nullable ? " | null" : "";
+        if (options.includeComments && col.comment) {
+          lines.push(`  /** ${col.comment} */`);
+        }
+        lines.push(`  ${col.name}: ${tsType}${nullable};`);
+      }
+      if (options.includeRelationships) {
+        for (const fk of table.foreignKeys) {
+          const relatedTable = options.allTables.find(
+            (t) => t.name === fk.foreignTable
+          );
+          if (relatedTable) {
+            const relatedPascal = this.toPascalCase(fk.foreignTable);
+            lines.push(`  ${fk.foreignTable}?: ${relatedPascal}Row;`);
+          }
+        }
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    if (options.includeInsert) {
+      lines.push(`export interface ${pascalName}Insert {`);
+      for (const col of table.columns) {
+        const tsType = this.pgTypeToTs(col.type);
+        const optional = col.nullable || col.defaultValue !== void 0 || col.isPrimaryKey ? "?" : "";
+        const nullable = col.nullable ? " | null" : "";
+        lines.push(`  ${col.name}${optional}: ${tsType}${nullable};`);
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    if (options.includeUpdate) {
+      lines.push(`export interface ${pascalName}Update {`);
+      for (const col of table.columns) {
+        if (col.isPrimaryKey) continue;
+        const tsType = this.pgTypeToTs(col.type);
+        const nullable = col.nullable ? " | null" : "";
+        lines.push(`  ${col.name}?: ${tsType}${nullable};`);
+      }
+      lines.push("}");
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  generateViewTypes(view, includeComments) {
+    const lines = [];
+    const pascalName = this.toPascalCase(view.name);
+    if (includeComments) {
+      lines.push(`/** View: ${view.name} */`);
+    }
+    lines.push(`export interface ${pascalName}Row {`);
+    for (const col of view.columns) {
+      const tsType = this.pgTypeToTs(col.type);
+      const nullable = col.nullable ? " | null" : "";
+      lines.push(`  ${col.name}: ${tsType}${nullable};`);
+    }
+    lines.push("}");
+    lines.push("");
+    return lines.join("\n");
+  }
+  pgTypeToTs(pgType) {
+    if (pgType.endsWith("[]")) {
+      const baseType = pgType.slice(0, -2);
+      const tsBaseType = PG_TO_TS_TYPES[baseType.toLowerCase()] || "unknown";
+      return `${tsBaseType}[]`;
+    }
+    const arrayMatch = pgType.match(/^(.+)\s+ARRAY$/i);
+    if (arrayMatch) {
+      const baseType = arrayMatch[1];
+      const tsBaseType = PG_TO_TS_TYPES[baseType.toLowerCase()] || "unknown";
+      return `${tsBaseType}[]`;
+    }
+    const precisionMatch = pgType.match(/^(\w+)\(/);
+    if (precisionMatch) {
+      const baseType = precisionMatch[1];
+      return PG_TO_TS_TYPES[baseType.toLowerCase()] || "unknown";
+    }
+    return PG_TO_TS_TYPES[pgType.toLowerCase()] || "unknown";
+  }
+  toPascalCase(str) {
+    return str.split(/[_\s-]+/).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+  }
+  indent(text, spaces) {
+    const pad = " ".repeat(spaces);
+    return text.split("\n").map((line) => line ? pad + line : line).join("\n");
+  }
+};
+function createTypeGen(client) {
+  return new VaifTypeGen(client);
+}
+
+// src/lib/client.ts
+var DEFAULT_API_URL = "https://api.vaif.studio";
+var DEFAULT_REALTIME_URL = "wss://realtime.vaif.studio";
+var DEFAULT_TIMEOUT = 3e4;
+var memoryStorage = {
+  data: /* @__PURE__ */ new Map(),
+  getItem(key) {
+    return this.data.get(key) ?? null;
+  },
+  setItem(key, value) {
+    this.data.set(key, value);
+  },
+  removeItem(key) {
+    this.data.delete(key);
+  }
+};
+var browserStorage = typeof window !== "undefined" && window.localStorage ? {
+  getItem: (key) => window.localStorage.getItem(key),
+  setItem: (key, value) => window.localStorage.setItem(key, value),
+  removeItem: (key) => window.localStorage.removeItem(key)
+} : null;
+function createClient(options) {
+  return new VaifClient(options);
+}
+var VaifClient = class {
+  constructor(options) {
+    this.accessToken = null;
+    if (!options.projectId) {
+      throw new Error("projectId is required");
+    }
+    if (!options.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    this.config = {
+      projectId: options.projectId,
+      apiKey: options.apiKey,
+      apiUrl: options.apiUrl ?? DEFAULT_API_URL,
+      realtimeUrl: options.realtimeUrl ?? DEFAULT_REALTIME_URL,
+      timeout: options.timeout ?? DEFAULT_TIMEOUT,
+      headers: options.headers ?? {},
+      debug: options.debug ?? false,
+      autoRefreshToken: options.autoRefreshToken ?? true,
+      persistSession: options.persistSession ?? true,
+      storage: options.storage ?? browserStorage ?? memoryStorage
+    };
+    this.db = new VaifDatabase(this);
+    this.realtime = new VaifRealtime(this);
+    this.storage = new VaifStorage(this);
+    this.functions = new VaifFunctions(this);
+    this.auth = new VaifAuth(this);
+    this.ai = new VaifAI(this);
+    this.typegen = new VaifTypeGen(this);
+    this.restoreSession();
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Set access token for authenticated requests
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+  }
+  /**
+   * Get current access token
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Make an authenticated API request
+   */
+  async request(path, options = {}) {
+    const url = new URL(path, this.config.apiUrl);
+    if (options.params) {
+      Object.entries(options.params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      });
+    }
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Project-ID": this.config.projectId,
+      apikey: this.config.apiKey,
+      ...this.config.headers,
+      ...options.headers
+    };
+    if (this.accessToken) {
+      headers.Authorization = `Bearer ${this.accessToken}`;
+    }
+    const fetchOptions = {
+      method: options.method ?? "GET",
+      headers,
+      signal: options.signal
+    };
+    if (options.body && options.method !== "GET") {
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    const timeoutMs = options.timeout ?? this.config.timeout;
+    const timeoutController = new AbortController();
+    const timeoutId = setTimeout(() => timeoutController.abort(), timeoutMs);
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => timeoutController.abort());
+    }
+    fetchOptions.signal = timeoutController.signal;
+    try {
+      if (this.config.debug) {
+        console.log(`[VAIF] ${options.method ?? "GET"} ${url.toString()}`);
+      }
+      const response = await fetch(url.toString(), fetchOptions);
+      clearTimeout(timeoutId);
+      const contentType = response.headers.get("content-type");
+      let data = null;
+      let error = null;
+      if (contentType?.includes("application/json")) {
+        const json = await response.json();
+        if (response.ok) {
+          data = json;
+        } else {
+          error = {
+            message: json.message ?? json.error ?? "Request failed",
+            code: json.code,
+            status: response.status,
+            details: json.details,
+            requestId: response.headers.get("x-request-id") ?? void 0
+          };
+        }
+      } else if (!response.ok) {
+        error = {
+          message: `Request failed with status ${response.status}`,
+          status: response.status
+        };
+      }
+      const responseHeaders = {};
+      response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+      });
+      return {
+        data,
+        error,
+        status: response.status,
+        headers: responseHeaders
+      };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      const error = {
+        message: err instanceof Error ? err.name === "AbortError" ? "Request timed out" : err.message : "Unknown error",
+        code: err instanceof Error && err.name === "AbortError" ? "TIMEOUT" : "NETWORK_ERROR"
+      };
+      return {
+        data: null,
+        error,
+        status: 0,
+        headers: {}
+      };
+    }
+  }
+  /**
+   * Restore session from storage
+   */
+  async restoreSession() {
+    if (!this.config.persistSession) return;
+    try {
+      const sessionStr = await this.config.storage.getItem(
+        `vaif-session-${this.config.projectId}`
+      );
+      if (sessionStr) {
+        const session = JSON.parse(sessionStr);
+        if (session.accessToken && session.expiresAt > Date.now()) {
+          this.accessToken = session.accessToken;
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Log debug messages
+   */
+  debug(...args) {
+    if (this.config.debug) {
+      console.log("[VAIF]", ...args);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RealtimeChannel,
+  VaifAI,
+  VaifAuth,
+  VaifClient,
+  VaifDatabase,
+  VaifFunctions,
+  VaifRealtime,
+  VaifStorage,
+  VaifTypeGen,
+  createClient,
+  createTypeGen
+});