@giaeulate/baas-sdk 1.1.0 → 1.1.1

package/dist/index.js

@@ -1,1672 +0,0 @@
-// src/http-client.ts
-var HttpClient = class {
-  url;
-  apiKey = "";
-  token = null;
-  environment = "prod";
-  _onForceLogout = null;
-  constructor(url, apiKey) {
-    let baseUrl = url || (typeof window !== "undefined" ? window.location.origin : "http://localhost:8080");
-    this.url = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-    if (apiKey) this.apiKey = apiKey;
-    this.token = this.cleanValue(localStorage.getItem("baas_token"));
-  }
-  /**
-   * Set the auth token manually (e.g. restoring from SecureStore in React Native).
-   * Persists to both the in-memory property and localStorage so getDynamicToken() works.
-   */
-  setToken(token) {
-    this.token = token;
-    if (token) {
-      localStorage.setItem("baas_token", token);
-    } else {
-      localStorage.removeItem("baas_token");
-    }
-  }
-  /**
-   * Register a callback invoked on forced logout (401).
-   * Use this in React Native instead of the default window.location redirect.
-   */
-  onForceLogout(callback) {
-    this._onForceLogout = callback;
-  }
-  cleanValue(val) {
-    if (!val || val === "null" || val === "undefined") return null;
-    return val.trim();
-  }
-  /**
-   * Public header generator for adapters
-   */
-  getHeaders(contentType = "application/json") {
-    const dynamicToken = this.getDynamicToken();
-    const headers = {
-      "apikey": this.apiKey
-    };
-    if (contentType) {
-      headers["Content-Type"] = contentType;
-    }
-    if (dynamicToken) {
-      headers["Authorization"] = `Bearer ${dynamicToken}`;
-    }
-    if (this.environment && this.environment !== "prod") {
-      headers["X-Environment"] = this.environment;
-    }
-    return headers;
-  }
-  getDynamicToken() {
-    return this.cleanValue(this.token || localStorage.getItem("baas_token"));
-  }
-  /**
-   * Core HTTP request method - DRY principle
-   */
-  async request(endpoint, options = {}) {
-    const { method = "GET", body, headers: customHeaders, skipAuth = false } = options;
-    const headers = { ...this.getHeaders(), ...customHeaders };
-    const fetchOptions = {
-      method,
-      headers
-    };
-    if (body !== void 0) {
-      fetchOptions.body = JSON.stringify(body);
-    }
-    const res = await fetch(`${this.url}${endpoint}`, fetchOptions);
-    if (res.status === 204) {
-      return { success: true };
-    }
-    const data = await res.json().catch(() => null);
-    if (!res.ok) {
-      if (res.status === 401 && !skipAuth) {
-        this.forceLogout();
-      }
-      if (res.status === 403 && data?.error === "ip_not_allowed") {
-        this.handleIPBlocked(data.ip);
-      }
-      return { error: data?.error || `Request failed: ${res.status}`, ...data };
-    }
-    return data;
-  }
-  get(endpoint) {
-    return this.request(endpoint);
-  }
-  post(endpoint, body) {
-    return this.request(endpoint, { method: "POST", body });
-  }
-  put(endpoint, body) {
-    return this.request(endpoint, { method: "PUT", body });
-  }
-  patch(endpoint, body) {
-    return this.request(endpoint, { method: "PATCH", body });
-  }
-  delete(endpoint) {
-    return this.request(endpoint, { method: "DELETE" });
-  }
-  setEnvironment(env) {
-    this.environment = env;
-  }
-  getEnvironment() {
-    return this.environment;
-  }
-  logout() {
-    this.token = null;
-    localStorage.removeItem("baas_token");
-  }
-  forceLogout() {
-    this.logout();
-    if (this._onForceLogout) {
-      this._onForceLogout();
-      return;
-    }
-    if (typeof window !== "undefined" && window.location && window.location.search !== void 0) {
-      if (!window.location.search.includes("expired")) {
-        window.location.href = "/authentication/login?reason=expired";
-      }
-    }
-  }
-  handleIPBlocked(ip) {
-    if (typeof window !== "undefined") {
-      const params = ip ? `?ip=${encodeURIComponent(ip)}` : "";
-      if (!window.location.pathname.includes("/blocked")) {
-        window.location.href = `/blocked${params}`;
-      }
-    }
-  }
-};
-
-// src/query-builder.ts
-var QueryBuilder = class {
-  table;
-  url;
-  client;
-  queryParams = new URLSearchParams();
-  // @ts-ignore - used for future filter improvements
-  filters = [];
-  constructor(table, url, client) {
-    this.table = table;
-    this.url = url;
-    this.client = client;
-  }
-  select(columns = "*") {
-    this.queryParams.set("select", columns);
-    return this;
-  }
-  eq(column, value) {
-    this.queryParams.set(column, `eq.${value}`);
-    return this;
-  }
-  neq(column, value) {
-    this.queryParams.set(column, `neq.${value}`);
-    return this;
-  }
-  gt(column, value) {
-    this.queryParams.set(column, `gt.${value}`);
-    return this;
-  }
-  gte(column, value) {
-    this.queryParams.set(column, `gte.${value}`);
-    return this;
-  }
-  lt(column, value) {
-    this.queryParams.set(column, `lt.${value}`);
-    return this;
-  }
-  lte(column, value) {
-    this.queryParams.set(column, `lte.${value}`);
-    return this;
-  }
-  like(column, value) {
-    this.queryParams.set(column, `like.${value}`);
-    return this;
-  }
-  ilike(column, value) {
-    this.queryParams.set(column, `ilike.${value}`);
-    return this;
-  }
-  is(column, value) {
-    this.queryParams.set(column, `is.${value}`);
-    return this;
-  }
-  in(column, values) {
-    this.queryParams.set(column, `in.(${values.join(",")})`);
-    return this;
-  }
-  not(column, operator, value) {
-    this.queryParams.set(column, `not.${operator}.${value}`);
-    return this;
-  }
-  or(filters) {
-    this.queryParams.set("or", `(${filters})`);
-    return this;
-  }
-  order(column, { ascending = true } = {}) {
-    this.queryParams.set("order", `${column}.${ascending ? "asc" : "desc"}`);
-    return this;
-  }
-  limit(count) {
-    this.queryParams.set("limit", count.toString());
-    return this;
-  }
-  offset(count) {
-    this.queryParams.set("offset", count.toString());
-    return this;
-  }
-  async get() {
-    const res = await fetch(`${this.url}/api/v1/data/${this.table}?${this.queryParams.toString()}`, {
-      headers: this.getHeaders()
-    });
-    return await this.handleResponse(res);
-  }
-  async insert(data) {
-    const res = await fetch(`${this.url}/api/v1/data/${this.table}`, {
-      method: "POST",
-      headers: this.getHeaders(),
-      body: JSON.stringify(data)
-    });
-    return await this.handleResponse(res);
-  }
-  async update(id, data) {
-    const res = await fetch(`${this.url}/api/v1/data/${this.table}/${id}`, {
-      method: "PATCH",
-      headers: this.getHeaders(),
-      body: JSON.stringify(data)
-    });
-    return await this.handleResponse(res);
-  }
-  async delete(id) {
-    const res = await fetch(`${this.url}/api/v1/data/${this.table}/${id}`, {
-      method: "DELETE",
-      headers: this.getHeaders()
-    });
-    if (res.status === 204) return { success: true };
-    return await this.handleResponse(res);
-  }
-  getHeaders() {
-    return this.client.getHeaders();
-  }
-  async handleResponse(res) {
-    const text = await res.text();
-    let data = null;
-    try {
-      data = text ? JSON.parse(text) : null;
-    } catch {
-    }
-    if (!res.ok) {
-      if (res.status === 401) {
-        this.client.forceLogout();
-      }
-      return { data: null, error: data?.error || "Request failed", status: res.status };
-    }
-    return { data, error: null, status: res.status };
-  }
-};
-
-// src/modules/auth.ts
-function createAuthModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  return {
-    async login(email, password) {
-      const res = await fetch(`${client.url}/api/login`, {
-        method: "POST",
-        headers: client.getHeaders(),
-        body: JSON.stringify({ email, password })
-      });
-      const contentType = res.headers.get("content-type");
-      if (!contentType?.includes("application/json")) {
-        throw new Error(`Login failed: Server returned ${res.status}. Please check your connection.`);
-      }
-      const data = await res.json().catch(() => {
-        throw new Error(`Login failed: Invalid JSON response (status ${res.status})`);
-      });
-      if (!res.ok) {
-        throw new Error(data?.error || `Login failed: ${res.status}`);
-      }
-      if (data.token) {
-        client.token = data.token;
-        localStorage.setItem("baas_token", data.token);
-      }
-      return data;
-    },
-    async logout() {
-      try {
-        await post("/api/logout");
-      } finally {
-        client.token = null;
-        localStorage.removeItem("baas_token");
-      }
-    },
-    async verifyMFA(mfaToken, code) {
-      const data = await post("/api/mfa/finalize", { mfa_token: mfaToken, code });
-      if (data.token) {
-        client.token = data.token;
-        localStorage.setItem("baas_token", data.token);
-      }
-      return data;
-    },
-    async verifyMFAWithRecoveryCode(mfaToken, recoveryCode) {
-      const data = await post("/api/mfa/finalize", { mfa_token: mfaToken, recovery_code: recoveryCode });
-      if (data.token) {
-        client.token = data.token;
-        localStorage.setItem("baas_token", data.token);
-      }
-      return data;
-    },
-    async setupMFA() {
-      return post("/api/mfa/setup");
-    },
-    async enableMFA(secret, code, recoveryCodes) {
-      const body = { secret, code };
-      if (recoveryCodes) {
-        body.recovery_codes = recoveryCodes;
-      }
-      return post("/api/mfa/enable", body);
-    },
-    async disableMFA(code) {
-      return post("/api/mfa/disable", { code });
-    },
-    async getProfile() {
-      return get("/api/profile");
-    },
-    async register(email, password) {
-      const data = await post("/api/register", { email, password });
-      if (data.error) {
-        throw new Error(data.error);
-      }
-      return data;
-    },
-    async forgotPassword(email) {
-      return post("/api/auth/forgot-password", { email });
-    },
-    async resetPassword(token, newPassword) {
-      return post("/api/auth/reset-password", { token, new_password: newPassword });
-    },
-    async validateResetToken(token) {
-      return get(`/api/auth/validate-reset-token?token=${token}`);
-    },
-    async verifyEmail(token) {
-      return post("/api/auth/verify-email", { token });
-    },
-    async requestEmailVerification() {
-      return post("/api/auth/request-verification");
-    },
-    async getAuthProviders() {
-      return get("/api/auth/providers");
-    },
-    async getAuthProvider(provider) {
-      return get(`/api/auth/providers/${provider}`);
-    },
-    async configureAuthProvider(provider, clientID, clientSecret, enabled) {
-      return post("/api/auth/providers", {
-        provider,
-        client_id: clientID,
-        client_secret: clientSecret,
-        enabled
-      });
-    }
-  };
-}
-
-// src/modules/users.ts
-function createUsersModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const put = (endpoint, body) => client.put(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async list(limit = 20, offset = 0) {
-      return get(`/api/users?limit=${limit}&offset=${offset}`);
-    },
-    async update(id, updates) {
-      return put(`/api/users/${id}`, updates);
-    },
-    async delete(id) {
-      return del(`/api/users/${id}`);
-    }
-  };
-}
-
-// src/modules/database.ts
-function createDatabaseModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const patch = (endpoint, body) => client.patch(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    // Schemas
-    async getSchemas(options) {
-      const params = new URLSearchParams();
-      if (options?.search) params.append("search", options.search);
-      if (options?.limit) params.append("limit", options.limit.toString());
-      if (options?.offset) params.append("offset", options.offset.toString());
-      const query = params.toString();
-      return get(`/api/schemas${query ? `?${query}` : ""}`);
-    },
-    async getSchema(name) {
-      return get(`/api/schemas/${name}`);
-    },
-    async saveSchemas(data) {
-      return post("/api/schemas", data);
-    },
-    // Tables
-    async createTable(tableName, definition) {
-      return post("/api/schemas/tables", { table_name: tableName, definition });
-    },
-    async dropTable(tableName) {
-      return del(`/api/schemas/tables/${tableName}`);
-    },
-    async renameTable(tableName, newName) {
-      return post(`/api/schemas/tables/${tableName}/rename`, { new_name: newName });
-    },
-    // Columns
-    async addColumn(tableName, column) {
-      return post(`/api/schemas/tables/${tableName}/columns`, column);
-    },
-    async dropColumn(tableName, columnName) {
-      return del(`/api/schemas/tables/${tableName}/columns/${columnName}`);
-    },
-    async modifyColumn(tableName, columnName, changes) {
-      return patch(`/api/schemas/tables/${tableName}/columns/${columnName}`, changes);
-    },
-    async renameColumn(tableName, columnName, newName) {
-      return post(`/api/schemas/tables/${tableName}/columns/${columnName}/rename`, { new_name: newName });
-    },
-    async setColumnDefault(tableName, columnName, defaultValue) {
-      return patch(`/api/schemas/tables/${tableName}/columns/${columnName}/default`, { default_value: defaultValue });
-    },
-    // Foreign Keys
-    async addForeignKey(tableName, fk) {
-      return post(`/api/schemas/tables/${tableName}/foreign-keys`, fk);
-    },
-    async listForeignKeys(tableName) {
-      return get(`/api/schemas/tables/${tableName}/foreign-keys`);
-    },
-    async dropForeignKey(tableName, constraintName) {
-      return del(`/api/schemas/tables/${tableName}/foreign-keys/${constraintName}`);
-    },
-    // Constraints
-    async addUniqueConstraint(tableName, columnName) {
-      return post(`/api/schemas/tables/${tableName}/constraints/unique`, { column: columnName });
-    },
-    async dropConstraint(tableName, constraintName) {
-      return del(`/api/schemas/tables/${tableName}/constraints/${constraintName}`);
-    },
-    // Data operations
-    async raw(query) {
-      return post("/api/v1/sql", { query });
-    },
-    async queryData(tableName, options) {
-      const params = new URLSearchParams();
-      if (options.page) params.append("page", options.page.toString());
-      if (options.limit) params.append("limit", options.limit.toString());
-      if (options.filters && options.filters.length > 0) {
-        params.append("filters", JSON.stringify(options.filters));
-      }
-      return get(`/api/v1/data/${tableName}/query?${params.toString()}`);
-    },
-    async downloadExport(tableName, format, filters) {
-      const params = new URLSearchParams();
-      if (filters && filters.length > 0) {
-        params.append("filters", JSON.stringify(filters));
-      }
-      const res = await fetch(`${client.url}/api/v1/export/${tableName}/${format}?${params.toString()}`, {
-        headers: client.getHeaders()
-      });
-      if (!res.ok) {
-        const data = await res.json();
-        return { error: data.error || `Export failed: ${res.status}` };
-      }
-      const blob = await res.blob();
-      const url = window.URL.createObjectURL(blob);
-      const a = document.createElement("a");
-      a.href = url;
-      a.download = `${tableName}_${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.${format === "backup" ? "dump" : format}`;
-      document.body.appendChild(a);
-      a.click();
-      window.URL.revokeObjectURL(url);
-      document.body.removeChild(a);
-      return { success: true };
-    }
-  };
-}
-
-// src/modules/storage.ts
-function createStorageModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  async function uploadFile(fileOrTable, fileOrBucketId) {
-    let file;
-    let bucketId;
-    if (fileOrTable instanceof File) {
-      file = fileOrTable;
-      bucketId = typeof fileOrBucketId === "string" ? fileOrBucketId : void 0;
-    } else {
-      file = fileOrBucketId;
-      bucketId = void 0;
-    }
-    const formData = new FormData();
-    formData.append("file", file);
-    if (bucketId) {
-      formData.append("bucket_id", bucketId);
-    }
-    const headers = client.getHeaders("");
-    const res = await fetch(`${client.url}/api/storage/upload`, {
-      method: "POST",
-      headers,
-      body: formData
-    });
-    if (!res.ok) {
-      if (res.status === 401) client.forceLogout();
-      const err = await res.json().catch(() => ({ error: `Upload failed: ${res.status}` }));
-      throw new Error(err.error ?? `Upload failed: ${res.status}`);
-    }
-    return res.json();
-  }
-  return {
-    upload: uploadFile,
-    async listFiles() {
-      return get("/api/storage/files");
-    },
-    async getFile(fileId) {
-      return get(`/api/storage/files/${fileId}`);
-    },
-    async deleteFile(fileId) {
-      return del(`/api/storage/files/${fileId}`);
-    },
-    async createBucket(name, isPublic = false) {
-      return post("/api/storage/buckets", { name, is_public: isPublic });
-    },
-    async listBuckets() {
-      return get("/api/storage/buckets");
-    },
-    async getBucket(bucketId) {
-      return get(`/api/storage/buckets/${bucketId}`);
-    },
-    async deleteBucket(bucketId) {
-      return del(`/api/storage/buckets/${bucketId}`);
-    },
-    async listBucketFiles(bucketId) {
-      return get(`/api/storage/buckets/${bucketId}/files`);
-    }
-  };
-}
-
-// src/modules/backups.ts
-function createBackupsModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async create(options) {
-      return post("/api/backups", options || {});
-    },
-    async list() {
-      return get("/api/backups");
-    },
-    async get(backupId) {
-      return get(`/api/backups/${backupId}`);
-    },
-    async restore(backupId) {
-      return post(`/api/backups/${backupId}/restore`, {});
-    },
-    async delete(backupId) {
-      return del(`/api/backups/${backupId}`);
-    },
-    getDownloadUrl(backupId) {
-      const token = client.getDynamicToken();
-      return `${client.url}/api/backups/${backupId}/download?access_token=${token}&apikey=${client.apiKey}`;
-    },
-    async listTables() {
-      return get("/api/backups/tables");
-    },
-    async importFile(formData) {
-      const headers = client.getHeaders();
-      delete headers["Content-Type"];
-      const res = await fetch(`${client.url}/api/import`, {
-        method: "POST",
-        headers,
-        body: formData
-      });
-      const data = await res.json();
-      if (!res.ok && res.status === 401) client.forceLogout();
-      return data;
-    }
-  };
-}
-
-// src/modules/migrations.ts
-function createMigrationsModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async create(input) {
-      return post("/api/migrations", input);
-    },
-    async list() {
-      return get("/api/migrations");
-    },
-    async get(id) {
-      return get(`/api/migrations/${id}`);
-    },
-    async apply(id) {
-      return post(`/api/migrations/${id}/apply`, {});
-    },
-    async rollback(id) {
-      return post(`/api/migrations/${id}/rollback`, {});
-    },
-    async delete(id) {
-      return del(`/api/migrations/${id}`);
-    },
-    async generate(tableName, changes) {
-      return post("/api/migrations/generate", { table_name: tableName, changes });
-    }
-  };
-}
-
-// src/modules/functions.ts
-function createFunctionsModule(client) {
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const get = (endpoint) => client.get(endpoint);
-  const del = (endpoint) => client.delete(endpoint);
-  const put = (endpoint, body) => client.put(endpoint, body);
-  return {
-    async invoke(id, data = {}) {
-      return post(`/api/functions/${id}/execute`, data);
-    },
-    async get(id) {
-      return get(`/api/functions/${id}`);
-    },
-    async list() {
-      return get("/api/functions");
-    },
-    async create(name, code, options) {
-      return post("/api/functions", { name, code, ...options });
-    },
-    async delete(id) {
-      return del(`/api/functions/${id}`);
-    },
-    async update(id, code, options) {
-      return put(`/api/functions/${id}`, { code, ...options });
-    },
-    async executeCode(code, options) {
-      return post("/api/functions/execute", { code, ...options });
-    },
-    async listHooks() {
-      return get("/api/hooks");
-    },
-    async createHook(data) {
-      return post("/api/hooks", data);
-    },
-    async deleteHook(id) {
-      return del(`/api/hooks/${id}`);
-    }
-  };
-}
-
-// src/modules/jobs.ts
-function createJobsModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const put = (endpoint, body) => client.put(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async create(input) {
-      return post("/api/jobs", input);
-    },
-    async list() {
-      return get("/api/jobs");
-    },
-    async get(id) {
-      return get(`/api/jobs/${id}`);
-    },
-    async update(id, input) {
-      return put(`/api/jobs/${id}`, input);
-    },
-    async delete(id) {
-      return del(`/api/jobs/${id}`);
-    },
-    async toggle(id, enabled) {
-      return post(`/api/jobs/${id}/toggle`, { enabled });
-    },
-    async runNow(id) {
-      return post(`/api/jobs/${id}/run`);
-    },
-    async getExecutions(id, limit) {
-      const params = new URLSearchParams();
-      if (limit) params.set("limit", limit.toString());
-      return get(`/api/jobs/${id}/executions?${params.toString()}`);
-    }
-  };
-}
-
-// src/modules/env-vars.ts
-function createEnvVarsModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const put = (endpoint, body) => client.put(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async create(input) {
-      return post("/api/env-vars", input);
-    },
-    async list() {
-      return get("/api/env-vars");
-    },
-    async get(id) {
-      return get(`/api/env-vars/${id}`);
-    },
-    async update(id, value) {
-      return put(`/api/env-vars/${id}`, { value });
-    },
-    async delete(id) {
-      return del(`/api/env-vars/${id}`);
-    }
-  };
-}
-
-// src/modules/email.ts
-function createEmailModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const put = (endpoint, body) => client.put(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async send(input) {
-      return post("/api/email/send", input);
-    },
-    async getConfig() {
-      return get("/api/email/config");
-    },
-    async saveConfig(config) {
-      return post("/api/email/config", config);
-    },
-    async createTemplate(template) {
-      return post("/api/email/templates", template);
-    },
-    async listTemplates() {
-      return get("/api/email/templates");
-    },
-    async getTemplate(id) {
-      return get(`/api/email/templates/${id}`);
-    },
-    async updateTemplate(id, template) {
-      return put(`/api/email/templates/${id}`, template);
-    },
-    async deleteTemplate(id) {
-      return del(`/api/email/templates/${id}`);
-    },
-    async getLogs(options) {
-      const params = new URLSearchParams();
-      if (options?.limit) params.set("limit", options.limit.toString());
-      if (options?.offset) params.set("offset", options.offset.toString());
-      return get(`/api/email/logs?${params.toString()}`);
-    }
-  };
-}
-
-// src/modules/search.ts
-function createSearchModule(client) {
-  const post = (endpoint, body) => client.post(endpoint, body);
-  return {
-    async search(query, options) {
-      return post("/api/search", {
-        query,
-        tables: options?.tables,
-        columns: options?.columns,
-        limit: options?.limit,
-        offset: options?.offset
-      });
-    },
-    async createIndex(table, columns) {
-      return post("/api/search/index", { table, columns });
-    }
-  };
-}
-
-// src/modules/graphql.ts
-function createGraphQLModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  return {
-    async query(query, variables) {
-      return post("/api/graphql", { query, variables });
-    },
-    async getSchema() {
-      return get("/api/graphql/schema");
-    },
-    getPlaygroundUrl() {
-      return `${client.url}/api/graphql/playground`;
-    }
-  };
-}
-
-// src/modules/metrics.ts
-function createMetricsModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  return {
-    async getDashboardStats() {
-      return get("/api/metrics/dashboard");
-    },
-    async getRequestLogs(options) {
-      const params = new URLSearchParams();
-      if (options?.limit) params.set("limit", options.limit.toString());
-      if (options?.offset) params.set("offset", options.offset.toString());
-      if (options?.method) params.set("method", options.method);
-      if (options?.status) params.set("status", options.status);
-      if (options?.path) params.set("path", options.path);
-      return get(`/api/metrics/requests?${params.toString()}`);
-    },
-    async getApplicationLogs(options) {
-      const params = new URLSearchParams();
-      if (options?.limit) params.set("limit", options.limit.toString());
-      if (options?.offset) params.set("offset", options.offset.toString());
-      if (options?.level) params.set("level", options.level);
-      if (options?.source) params.set("source", options.source);
-      if (options?.search) params.set("search", options.search);
-      return get(`/api/metrics/logs?${params.toString()}`);
-    },
-    async getTimeseries(metric, options) {
-      const params = new URLSearchParams({ metric });
-      if (options?.interval) params.set("interval", options.interval);
-      if (options?.start) params.set("start", options.start);
-      if (options?.end) params.set("end", options.end);
-      return get(`/api/metrics/timeseries?${params.toString()}`);
-    }
-  };
-}
-
-// src/modules/audit.ts
-function createAuditModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  return {
-    async list(options) {
-      const params = new URLSearchParams();
-      if (options?.limit) params.set("limit", options.limit.toString());
-      if (options?.offset) params.set("offset", options.offset.toString());
-      if (options?.action) params.set("action", options.action);
-      if (options?.user_id) params.set("user_id", options.user_id);
-      if (options?.method) params.set("method", options.method);
-      if (options?.path) params.set("path", options.path);
-      if (options?.status_code) params.set("status_code", options.status_code.toString());
-      if (options?.start_date) params.set("start_date", options.start_date);
-      if (options?.end_date) params.set("end_date", options.end_date);
-      return get(`/api/audit/logs?${params.toString()}`);
-    },
-    async getActions() {
-      return get("/api/audit/actions");
-    }
-  };
-}
-
-// src/modules/webhooks.ts
-function createWebhooksModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const put = (endpoint, body) => client.put(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async list() {
-      return get("/api/webhooks");
-    },
-    async get(id) {
-      return get(`/api/webhooks/${id}`);
-    },
-    async create(input) {
-      return post("/api/webhooks", input);
-    },
-    async update(id, input) {
-      return put(`/api/webhooks/${id}`, input);
-    },
-    async delete(id) {
-      return del(`/api/webhooks/${id}`);
-    },
-    async test(id) {
-      return post(`/api/webhooks/${id}/test`);
-    }
-  };
-}
-
-// src/modules/log-drains.ts
-function createLogDrainsModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const put = (endpoint, body) => client.put(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async create(input) {
-      return post("/api/log-drains", input);
-    },
-    async list() {
-      return get("/api/log-drains");
-    },
-    async get(id) {
-      return get(`/api/log-drains/${id}`);
-    },
-    async update(id, input) {
-      return put(`/api/log-drains/${id}`, input);
-    },
-    async delete(id) {
-      return del(`/api/log-drains/${id}`);
-    },
-    async toggle(id, enabled) {
-      return post(`/api/log-drains/${id}/toggle`, { enabled });
-    },
-    async test(id) {
-      return post(`/api/log-drains/${id}/test`);
-    }
-  };
-}
-
-// src/modules/branches.ts
-function createBranchesModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async create(input) {
-      return post("/api/branches", input);
-    },
-    async list() {
-      return get("/api/branches");
-    },
-    async get(id) {
-      return get(`/api/branches/${id}`);
-    },
-    async delete(id) {
-      return del(`/api/branches/${id}`);
-    },
-    async merge(id, targetBranchId) {
-      return post(`/api/branches/${id}/merge`, { target_branch_id: targetBranchId });
-    },
-    async reset(id) {
-      return post(`/api/branches/${id}/reset`);
-    }
-  };
-}
-
-// src/realtime.ts
-var RealtimeService = class {
-  constructor(url, apiKey, tokenProvider, wsConstructor = typeof WebSocket !== "undefined" ? WebSocket : null) {
-    this.url = url;
-    this.apiKey = apiKey;
-    this.tokenProvider = tokenProvider;
-    this.wsConstructor = wsConstructor;
-  }
-  socket = null;
-  subscribers = /* @__PURE__ */ new Map();
-  reconnectAttempts = 0;
-  maxReconnectAttempts = 5;
-  reconnectInterval = 3e3;
-  /**
-   * Initialize the WebSocket connection
-   */
-  connect() {
-    if (this.socket?.readyState === WebSocket.OPEN) return Promise.resolve();
-    return new Promise((resolve, reject) => {
-      const token = this.tokenProvider();
-      if (!token) {
-        reject(new Error("Missing authentication token for Realtime connection"));
-        return;
-      }
-      const wsUrl = this.url.replace(/^http/, "ws") + "/api/ws";
-      const fullUrl = this.apiKey ? `${wsUrl}?apikey=${this.apiKey}&token=${token}` : `${wsUrl}?token=${token}`;
-      if (!this.wsConstructor) {
-        reject(new Error("WebSocket constructor not provided or available in this environment"));
-        return;
-      }
-      const socket = new this.wsConstructor(fullUrl);
-      this.socket = socket;
-      socket.onopen = () => {
-        console.log("BaaS Realtime: Connected");
-        this.reconnectAttempts = 0;
-        resolve();
-      };
-      socket.onmessage = (event) => {
-        try {
-          const payload = JSON.parse(event.data);
-          this.handleEvent(payload);
-        } catch (err) {
-          console.error("BaaS Realtime: Failed to parse message", err);
-        }
-      };
-      socket.onerror = (error) => {
-        console.error("BaaS Realtime: WebSocket Error", error);
-        reject(error);
-      };
-      socket.onclose = () => {
-        console.log("BaaS Realtime: Disconnected");
-        this.socket = null;
-        this.attemptReconnect();
-      };
-    });
-  }
-  /**
-   * Subscribe to changes on a specific table
-   */
-  async subscribe(table, action, callback) {
-    await this.connect();
-    if (!this.subscribers.has(table)) {
-      this.subscribers.set(table, /* @__PURE__ */ new Set());
-    }
-    const sub = { action, callback };
-    this.subscribers.get(table).add(sub);
-    return {
-      unsubscribe: () => {
-        const tableSubs = this.subscribers.get(table);
-        if (tableSubs) {
-          tableSubs.delete(sub);
-          if (tableSubs.size === 0) {
-            this.subscribers.delete(table);
-          }
-        }
-      }
-    };
-  }
-  /**
-   * Handle incoming CDC events from the server
-   */
-  handleEvent(payload) {
-    const tableSubs = this.subscribers.get(payload.table);
-    if (tableSubs) {
-      for (const sub of tableSubs) {
-        if (sub.action === "*" || sub.action.toLowerCase() === payload.action.toLowerCase()) {
-          sub.callback(payload);
-        }
-      }
-    }
-    const wildcardSubs = this.subscribers.get("*");
-    if (wildcardSubs) {
-      for (const sub of wildcardSubs) {
-        if (sub.action === "*" || sub.action.toLowerCase() === payload.action.toLowerCase()) {
-          sub.callback(payload);
-        }
-      }
-    }
-  }
-  /**
-   * Attempt to reconnect on connection loss
-   */
-  attemptReconnect() {
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
-      this.reconnectAttempts++;
-      console.log(`BaaS Realtime: Attempting reconnect ${this.reconnectAttempts}/${this.maxReconnectAttempts}...`);
-      setTimeout(() => this.connect(), this.reconnectInterval);
-    } else {
-      console.error("BaaS Realtime: Max reconnect attempts reached");
-    }
-  }
-  /**
-   * Close the connection
-   */
-  disconnect() {
-    if (this.socket) {
-      this.socket.onclose = null;
-      this.socket.close();
-      this.socket = null;
-    }
-  }
-  /** @internal - For testing only */
-  get _socket() {
-    return this.socket;
-  }
-};
-
-// src/modules/realtime.ts
-function createRealtimeModule(client) {
-  const service = new RealtimeService(
-    client.url,
-    client.apiKey,
-    () => client.getDynamicToken(),
-    typeof WebSocket !== "undefined" ? WebSocket : void 0
-  );
-  return {
-    async subscribe(table, action, callback) {
-      return service.subscribe(table, action, callback);
-    }
-  };
-}
-
-// src/modules/api-keys.ts
-function createApiKeysModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async create(name, permissions, expiresAt) {
-      return post("/api/api-keys", { name, permissions, expires_at: expiresAt });
-    },
-    async list() {
-      return get("/api/api-keys");
-    },
-    async revoke(keyId) {
-      return post(`/api/api-keys/${keyId}/revoke`, {});
-    },
-    async delete(keyId) {
-      return del(`/api/api-keys/${keyId}`);
-    },
-    async getInstanceToken() {
-      return get("/api/api-keys/instance");
-    },
-    async regenerateInstanceToken() {
-      return post("/api/api-keys/instance/regenerate", {});
-    }
-  };
-}
-
-// src/modules/environments.ts
-function createEnvironmentsModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  return {
-    async status() {
-      return get("/api/environments/status");
-    },
-    async init() {
-      return post("/api/environments/init");
-    },
-    async promote() {
-      return post("/api/environments/promote");
-    },
-    async revert() {
-      return post("/api/environments/revert");
-    },
-    setActive(env) {
-      client.setEnvironment(env);
-    },
-    getActive() {
-      return client.getEnvironment();
-    }
-  };
-}
-
-// src/modules/cors-origins.ts
-function createCorsOriginsModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async list() {
-      return get("/api/cors-origins");
-    },
-    async create(origin, description) {
-      return post("/api/cors-origins", { origin, description: description || "" });
-    },
-    async delete(id) {
-      return del(`/api/cors-origins/${id}`);
-    }
-  };
-}
-
-// src/modules/policies.ts
-function createPoliciesModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async create(input) {
-      return post("/api/policies", input);
-    },
-    async list() {
-      return get("/api/policies");
-    },
-    async delete(id) {
-      return del(`/api/policies/${id}`);
-    }
-  };
-}
-
-// src/modules/ip-whitelist.ts
-function createIPWhitelistModule(client) {
-  const get = (endpoint) => client.get(endpoint);
-  const post = (endpoint, body) => client.post(endpoint, body);
-  const del = (endpoint) => client.delete(endpoint);
-  return {
-    async list() {
-      return get("/api/ip-whitelist");
-    },
-    async create(ipAddress, description) {
-      return post("/api/ip-whitelist", { ip_address: ipAddress, description: description || "" });
-    },
-    async delete(id) {
-      return del(`/api/ip-whitelist/${id}`);
-    }
-  };
-}
-
-// src/client.ts
-var BaasClient = class extends HttpClient {
-  // Feature modules
-  auth;
-  users;
-  database;
-  storage;
-  backups;
-  migrations;
-  functions;
-  jobs;
-  envVars;
-  email;
-  searchService;
-  graphqlService;
-  metrics;
-  audit;
-  webhooks;
-  logDrains;
-  branches;
-  realtime;
-  apiKeys;
-  environments;
-  corsOrigins;
-  policies;
-  ipWhitelist;
-  constructor(url, apiKey) {
-    super(url, apiKey);
-    this.auth = createAuthModule(this);
-    this.users = createUsersModule(this);
-    this.database = createDatabaseModule(this);
-    this.storage = createStorageModule(this);
-    this.backups = createBackupsModule(this);
-    this.migrations = createMigrationsModule(this);
-    this.functions = createFunctionsModule(this);
-    this.jobs = createJobsModule(this);
-    this.envVars = createEnvVarsModule(this);
-    this.email = createEmailModule(this);
-    this.searchService = createSearchModule(this);
-    this.graphqlService = createGraphQLModule(this);
-    this.metrics = createMetricsModule(this);
-    this.audit = createAuditModule(this);
-    this.webhooks = createWebhooksModule(this);
-    this.logDrains = createLogDrainsModule(this);
-    this.branches = createBranchesModule(this);
-    this.realtime = createRealtimeModule(this);
-    this.apiKeys = createApiKeysModule(this);
-    this.environments = createEnvironmentsModule(this);
-    this.corsOrigins = createCorsOriginsModule(this);
-    this.policies = createPoliciesModule(this);
-    this.ipWhitelist = createIPWhitelistModule(this);
-  }
-  /**
-   * Create a query builder for fluent data queries
-   */
-  from(table) {
-    return new QueryBuilder(table, this.url, this);
-  }
-  // ============================================
-  // BACKWARD COMPATIBILITY METHODS
-  // These delegate to the appropriate modules
-  // ============================================
-  // Auth shortcuts
-  async login(email, password) {
-    return this.auth.login(email, password);
-  }
-  async verifyMFA(mfaToken, code) {
-    return this.auth.verifyMFA(mfaToken, code);
-  }
-  async getProfile() {
-    return this.auth.getProfile();
-  }
-  async register(email, password) {
-    return this.auth.register(email, password);
-  }
-  async forgotPassword(email) {
-    return this.auth.forgotPassword(email);
-  }
-  async resetPassword(token, newPassword) {
-    return this.auth.resetPassword(token, newPassword);
-  }
-  async validateResetToken(token) {
-    return this.auth.validateResetToken(token);
-  }
-  async verifyEmail(token) {
-    return this.auth.verifyEmail(token);
-  }
-  async requestEmailVerification() {
-    return this.auth.requestEmailVerification();
-  }
-  async getAuthProviders() {
-    return this.auth.getAuthProviders();
-  }
-  async getAuthProvider(provider) {
-    return this.auth.getAuthProvider(provider);
-  }
-  async configureAuthProvider(provider, clientID, clientSecret, enabled) {
-    return this.auth.configureAuthProvider(provider, clientID, clientSecret, enabled);
-  }
-  // Users shortcuts
-  async listUsers(limit = 20, offset = 0) {
-    return this.users.list(limit, offset);
-  }
-  async updateUser(id, updates) {
-    return this.users.update(id, updates);
-  }
-  async deleteUser(id) {
-    return this.users.delete(id);
-  }
-  // Database shortcuts
-  async raw(query) {
-    return this.database.raw(query);
-  }
-  async getSchemas(options) {
-    return this.database.getSchemas(options);
-  }
-  async getSchema(name) {
-    return this.database.getSchema(name);
-  }
-  async createTable(tableName, definition) {
-    return this.database.createTable(tableName, definition);
-  }
-  async dropTable(tableName) {
-    return this.database.dropTable(tableName);
-  }
-  async renameTable(tableName, newName) {
-    return this.database.renameTable(tableName, newName);
-  }
-  async addColumn(tableName, column) {
-    return this.database.addColumn(tableName, column);
-  }
-  async dropColumn(tableName, columnName) {
-    return this.database.dropColumn(tableName, columnName);
-  }
-  async modifyColumn(tableName, columnName, changes) {
-    return this.database.modifyColumn(tableName, columnName, changes);
-  }
-  async renameColumn(tableName, columnName, newName) {
-    return this.database.renameColumn(tableName, columnName, newName);
-  }
-  async setColumnDefault(tableName, columnName, defaultValue) {
-    return this.database.setColumnDefault(tableName, columnName, defaultValue);
-  }
-  async addForeignKey(tableName, fk) {
-    return this.database.addForeignKey(tableName, fk);
-  }
-  async listForeignKeys(tableName) {
-    return this.database.listForeignKeys(tableName);
-  }
-  async dropForeignKey(tableName, constraintName) {
-    return this.database.dropForeignKey(tableName, constraintName);
-  }
-  async addUniqueConstraint(tableName, columnName) {
-    return this.database.addUniqueConstraint(tableName, columnName);
-  }
-  async dropConstraint(tableName, constraintName) {
-    return this.database.dropConstraint(tableName, constraintName);
-  }
-  async queryData(tableName, options) {
-    return this.database.queryData(tableName, options);
-  }
-  async downloadExport(tableName, format, filters) {
-    return this.database.downloadExport(tableName, format, filters);
-  }
-  // Storage shortcuts
-  async upload(file, bucketId) {
-    return this.storage.upload(file, bucketId);
-  }
-  async listStorageFiles() {
-    return this.storage.listFiles();
-  }
-  async getStorageFile(fileId) {
-    return this.storage.getFile(fileId);
-  }
-  async deleteStorageFile(fileId) {
-    return this.storage.deleteFile(fileId);
-  }
-  async createStorageBucket(name, isPublic) {
-    return this.storage.createBucket(name, isPublic);
-  }
-  async listStorageBuckets() {
-    return this.storage.listBuckets();
-  }
-  async getStorageBucket(bucketId) {
-    return this.storage.getBucket(bucketId);
-  }
-  async deleteStorageBucket(bucketId) {
-    return this.storage.deleteBucket(bucketId);
-  }
-  async listStorageBucketFiles(bucketId) {
-    return this.storage.listBucketFiles(bucketId);
-  }
-  // Functions shortcuts
-  async invokeFunction(id, data) {
-    return this.functions.invoke(id, data);
-  }
-  // API Keys shortcuts
-  async createApiKey(name, permissions, expiresAt) {
-    return this.apiKeys.create(name, permissions, expiresAt);
-  }
-  async listApiKeys() {
-    return this.apiKeys.list();
-  }
-  async revokeApiKey(keyId) {
-    return this.apiKeys.revoke(keyId);
-  }
-  async deleteApiKey(keyId) {
-    return this.apiKeys.delete(keyId);
-  }
-  async getInstanceToken() {
-    return this.apiKeys.getInstanceToken();
-  }
-  async regenerateInstanceToken() {
-    return this.apiKeys.regenerateInstanceToken();
-  }
-  // Backups shortcuts
-  async createBackup(options) {
-    return this.backups.create(options);
-  }
-  async listBackups() {
-    return this.backups.list();
-  }
-  async getBackup(backupId) {
-    return this.backups.get(backupId);
-  }
-  async restoreBackup(backupId) {
-    return this.backups.restore(backupId);
-  }
-  async deleteBackup(backupId) {
-    return this.backups.delete(backupId);
-  }
-  getBackupDownloadUrl(backupId) {
-    return this.backups.getDownloadUrl(backupId);
-  }
-  async listBackupTables() {
-    return this.backups.listTables();
-  }
-  async importFile(formData) {
-    return this.backups.importFile(formData);
-  }
-  // Search shortcuts
-  async search(query, options) {
-    return this.searchService.search(query, options);
-  }
-  async createSearchIndex(table, columns) {
-    return this.searchService.createIndex(table, columns);
-  }
-  // GraphQL shortcuts
-  async graphql(query, variables) {
-    return this.graphqlService.query(query, variables);
-  }
-  getGraphQLPlaygroundUrl() {
-    return this.graphqlService.getPlaygroundUrl();
-  }
-  // Migrations shortcuts
-  async createMigration(input) {
-    return this.migrations.create(input);
-  }
-  async listMigrations() {
-    return this.migrations.list();
-  }
-  async getMigration(id) {
-    return this.migrations.get(id);
-  }
-  async applyMigration(id) {
-    return this.migrations.apply(id);
-  }
-  async rollbackMigration(id) {
-    return this.migrations.rollback(id);
-  }
-  async deleteMigration(id) {
-    return this.migrations.delete(id);
-  }
-  async generateMigration(tableName, changes) {
-    return this.migrations.generate(tableName, changes);
-  }
-  // Email shortcuts
-  async sendEmail(input) {
-    return this.email.send(input);
-  }
-  async getEmailConfig() {
-    return this.email.getConfig();
-  }
-  async saveEmailConfig(config) {
-    return this.email.saveConfig(config);
-  }
-  async createEmailTemplate(template) {
-    return this.email.createTemplate(template);
-  }
-  async listEmailTemplates() {
-    return this.email.listTemplates();
-  }
-  async getEmailTemplate(id) {
-    return this.email.getTemplate(id);
-  }
-  async updateEmailTemplate(id, template) {
-    return this.email.updateTemplate(id, template);
-  }
-  async deleteEmailTemplate(id) {
-    return this.email.deleteTemplate(id);
-  }
-  async getEmailLogs(options) {
-    return this.email.getLogs(options);
-  }
-  // Metrics shortcuts
-  async getDashboardStats() {
-    return this.metrics.getDashboardStats();
-  }
-  async getRequestLogs(options) {
-    return this.metrics.getRequestLogs(options);
-  }
-  async getApplicationLogs(options) {
-    return this.metrics.getApplicationLogs(options);
-  }
-  async getMetricTimeseries(metric, options) {
-    return this.metrics.getTimeseries(metric, options);
-  }
-  // Jobs shortcuts
-  async createJob(input) {
-    return this.jobs.create(input);
-  }
-  async listJobs() {
-    return this.jobs.list();
-  }
-  async getJob(id) {
-    return this.jobs.get(id);
-  }
-  async updateJob(id, input) {
-    return this.jobs.update(id, input);
-  }
-  async deleteJob(id) {
-    return this.jobs.delete(id);
-  }
-  async toggleJob(id, enabled) {
-    return this.jobs.toggle(id, enabled);
-  }
-  async runJobNow(id) {
-    return this.jobs.runNow(id);
-  }
-  async getJobExecutions(id, limit) {
-    return this.jobs.getExecutions(id, limit);
-  }
-  // Env Vars shortcuts
-  async createEnvVar(input) {
-    return this.envVars.create(input);
-  }
-  async listEnvVars() {
-    return this.envVars.list();
-  }
-  async getEnvVar(id) {
-    return this.envVars.get(id);
-  }
-  async updateEnvVar(id, value) {
-    return this.envVars.update(id, value);
-  }
-  async deleteEnvVar(id) {
-    return this.envVars.delete(id);
-  }
-  // Branches shortcuts
-  async createBranch(input) {
-    return this.branches.create(input);
-  }
-  async listBranches() {
-    return this.branches.list();
-  }
-  async getBranch(id) {
-    return this.branches.get(id);
-  }
-  async deleteBranch(id) {
-    return this.branches.delete(id);
-  }
-  async mergeBranch(id, targetBranchId) {
-    return this.branches.merge(id, targetBranchId);
-  }
-  async resetBranch(id) {
-    return this.branches.reset(id);
-  }
-  // Log Drains shortcuts
-  async createLogDrain(input) {
-    return this.logDrains.create(input);
-  }
-  async listLogDrains() {
-    return this.logDrains.list();
-  }
-  async getLogDrain(id) {
-    return this.logDrains.get(id);
-  }
-  async updateLogDrain(id, input) {
-    return this.logDrains.update(id, input);
-  }
-  async deleteLogDrain(id) {
-    return this.logDrains.delete(id);
-  }
-  async toggleLogDrain(id, enabled) {
-    return this.logDrains.toggle(id, enabled);
-  }
-  async testLogDrain(id) {
-    return this.logDrains.test(id);
-  }
-  // Webhooks shortcuts
-  async listWebhooks() {
-    return this.webhooks.list();
-  }
-  async getWebhook(id) {
-    return this.webhooks.get(id);
-  }
-  async createWebhook(input) {
-    return this.webhooks.create(input);
-  }
-  async updateWebhook(id, input) {
-    return this.webhooks.update(id, input);
-  }
-  async deleteWebhook(id) {
-    return this.webhooks.delete(id);
-  }
-  async testWebhook(id) {
-    return this.webhooks.test(id);
-  }
-  // Audit shortcuts
-  async listAuditLogs(options) {
-    return this.audit.list(options);
-  }
-  async getAuditActions() {
-    return this.audit.getActions();
-  }
-  // Realtime shortcuts
-  subscribe(table, action, callback) {
-    return this.realtime.subscribe(table, action, callback);
-  }
-  // Environment shortcuts
-  async getEnvironmentStatus() {
-    return this.environments.status();
-  }
-  async initTestEnvironment() {
-    return this.environments.init();
-  }
-  async promoteTestToProd() {
-    return this.environments.promote();
-  }
-  async revertTestEnvironment() {
-    return this.environments.revert();
-  }
-  // CORS Origins shortcuts
-  async listCorsOrigins() {
-    return this.corsOrigins.list();
-  }
-  async addCorsOrigin(origin, description) {
-    return this.corsOrigins.create(origin, description);
-  }
-  async deleteCorsOrigin(id) {
-    return this.corsOrigins.delete(id);
-  }
-  // Policies shortcuts
-  async listPolicies() {
-    return this.policies.list();
-  }
-  async createPolicy(input) {
-    return this.policies.create(input);
-  }
-  async deletePolicy(id) {
-    return this.policies.delete(id);
-  }
-  // IP Whitelist shortcuts
-  async listIPWhitelist() {
-    return this.ipWhitelist.list();
-  }
-  async addIPWhitelistEntry(ipAddress, description) {
-    return this.ipWhitelist.create(ipAddress, description);
-  }
-  async deleteIPWhitelistEntry(id) {
-    return this.ipWhitelist.delete(id);
-  }
-};
-export {
-  BaasClient,
-  HttpClient,
-  QueryBuilder
-};