@bettercms-ai/sdk 1.6.0

package/dist/index.js

@@ -0,0 +1,1507 @@
+// src/errors.ts
+var ErrorCodes = {
+  CONTENT_NOT_FOUND: "CONTENT_NOT_FOUND",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  RATE_LIMITED: "RATE_LIMITED",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  ADMIN_NOT_IMPLEMENTED: "ADMIN_NOT_IMPLEMENTED"
+};
+function statusToCode(status) {
+  if (status === 404) return ErrorCodes.CONTENT_NOT_FOUND;
+  if (status === 401) return ErrorCodes.UNAUTHORIZED;
+  if (status === 403) return ErrorCodes.FORBIDDEN;
+  if (status === 429) return ErrorCodes.RATE_LIMITED;
+  if (status >= 500) return ErrorCodes.INTERNAL_ERROR;
+  if (status === 422) return ErrorCodes.VALIDATION_ERROR;
+  return ErrorCodes.INTERNAL_ERROR;
+}
+var BetterCMSError = class _BetterCMSError extends Error {
+  status;
+  code;
+  /**
+   * Raw machine-readable `code` from the response body (e.g. "PROJECT_DELETED"),
+   * when the API supplies one. Distinct from `code` (which is derived from the
+   * HTTP status), this lets callers branch on a specific server condition that
+   * shares a status with others (e.g. 409 slug-conflict vs 409 project-deleted).
+   */
+  bodyCode;
+  constructor(message, status, code, bodyCode) {
+    super(message);
+    this.name = "BetterCMSError";
+    this.status = status;
+    this.code = code;
+    this.bodyCode = bodyCode;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _BetterCMSError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      code: this.code,
+      bodyCode: this.bodyCode
+    };
+  }
+  /**
+   * Factory — creates a BetterCMSError from a failed fetch Response. Reads the
+   * body's `message` (or `error`) for the human message and `code` for a
+   * machine-readable condition the SDK surfaces as `bodyCode`.
+   */
+  static async from(res) {
+    let message = res.statusText || "An error occurred";
+    let bodyCode;
+    try {
+      const body = await res.json();
+      if (body?.message) message = body.message;
+      else if (body?.error) message = body.error;
+      if (body?.code) bodyCode = body.code;
+    } catch {
+    }
+    return new _BetterCMSError(message, res.status, statusToCode(res.status), bodyCode);
+  }
+};
+
+// src/methods/getContent.ts
+async function getContent(client, slug) {
+  const data = await client.fetchJSON(client.url(slug));
+  return data.data;
+}
+
+// src/methods/listContent.ts
+async function listContent(client, opts) {
+  const params2 = new URLSearchParams({
+    page: String(opts?.page ?? 1),
+    perPage: String(opts?.perPage ?? 20)
+  });
+  const data = await client.fetchJSON(
+    `${client.url("")}?${params2}`
+  );
+  return data.data;
+}
+
+// src/methods/listContentAll.ts
+function listContentAll(client, opts) {
+  const perPage = opts?.perPage ?? 100;
+  return {
+    /**
+     * Async iterator — yields Content items page by page.
+     */
+    async *[Symbol.asyncIterator]() {
+      let page = opts?.page ?? 1;
+      while (true) {
+        if (page > 100) {
+          throw new Error(
+            "listContentAll: exceeded 100 pages \u2014 possible infinite loop"
+          );
+        }
+        const params2 = new URLSearchParams({
+          page: String(page),
+          perPage: String(perPage)
+        });
+        const result = await client.fetchJSON(
+          `${client.url("")}?${params2}`
+        );
+        const pageData = result.data;
+        if (!pageData?.items?.length) break;
+        for (const item of pageData.items) {
+          yield item;
+        }
+        if (!pageData?.hasNextPage) break;
+        page++;
+      }
+    },
+    /**
+     * Convenience: collect all items into an array, optionally limited.
+     */
+    async all(options) {
+      const items = [];
+      for await (const item of this) {
+        items.push(item);
+        if (options?.limit && items.length >= options.limit) break;
+      }
+      return items;
+    }
+  };
+}
+
+// src/delivery-client.ts
+var BetterCMSDeliveryClient = class {
+  workspace;
+  baseUrl;
+  apiKey;
+  constructor(opts) {
+    this.workspace = opts.workspace;
+    this.baseUrl = opts.baseUrl;
+    this.apiKey = opts.apiKey;
+  }
+  getContent(slug) {
+    return getContent(this, slug);
+  }
+  listContent(opts) {
+    return listContent(this, opts);
+  }
+  listContentAll(opts) {
+    return listContentAll(this, opts);
+  }
+  /** Build the full URL for a content path. */
+  url(path) {
+    return `${this.baseUrl}/${this.workspace}/content/${path}`;
+  }
+  /** Build request headers, including auth if provided. */
+  headers() {
+    const headers = { "Content-Type": "application/json" };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Generic fetch helper — wraps a request with network-error handling
+   * and throws a typed BetterCMSError on non-OK responses.
+   */
+  async fetchJSON(url) {
+    let res;
+    try {
+      res = await globalThis.fetch(url, { headers: this.headers() });
+    } catch (err) {
+      throw new BetterCMSError(
+        `Network error: ${err instanceof Error ? err.message : String(err)}`,
+        0,
+        "NETWORK_ERROR"
+      );
+    }
+    if (!res.ok) {
+      throw await BetterCMSError.from(res);
+    }
+    return await res.json();
+  }
+};
+
+// src/methods/webhooks.ts
+function addWebhookMethods(client) {
+  return {
+    /**
+     * List webhooks for a project.
+     */
+    list: async (options) => {
+      const params2 = new URLSearchParams();
+      if (options?.page) params2.set("page", String(options.page));
+      if (options?.limit) params2.set("limit", String(options.limit));
+      return client.fetchJSON(
+        client.url(`/webhooks?${params2}`),
+        { method: "GET" }
+      );
+    },
+    /**
+     * Create a new webhook. Returns the webhook with secret (shown once).
+     */
+    create: async (input) => {
+      return client.fetchJSON(
+        client.url("/webhooks"),
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        }
+      );
+    },
+    /**
+     * Get a single webhook.
+     */
+    get: async (webhookId) => {
+      return client.fetchJSON(
+        client.url(`/webhooks/${webhookId}`),
+        { method: "GET" }
+      );
+    },
+    /**
+     * Update a webhook.
+     */
+    update: async (webhookId, input) => {
+      return client.fetchJSON(
+        client.url(`/webhooks/${webhookId}`),
+        {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(input)
+        }
+      );
+    },
+    /**
+     * Delete a webhook.
+     */
+    delete: async (webhookId) => {
+      return client.fetchJSON(
+        client.url(`/webhooks/${webhookId}`),
+        { method: "DELETE" }
+      );
+    },
+    /**
+     * Test a webhook delivery.
+     */
+    test: async (webhookId, event) => {
+      return client.fetchJSON(
+        client.url(`/webhooks/${webhookId}/test`),
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ event: event ?? "content.publish" })
+        }
+      );
+    }
+  };
+}
+
+// src/admin-client.ts
+var DEFAULT_BASE_URL = "https://api.bettercms.ai/v1";
+var DEFAULT_TIMEOUT = 1e4;
+var RETRY_STATUSES = [429, 503];
+var RETRY_DELAYS = [1e3, 2e3, 4e3];
+var BetterCMSAdminClient = class extends BetterCMSDeliveryClient {
+  timeout;
+  _token;
+  constructor(options) {
+    super({
+      workspace: "",
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL
+    });
+    this._token = options.token;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  }
+  headers() {
+    return {
+      ...super.headers(),
+      Authorization: `Bearer ${this._token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * Admin fetchJSON with retry (429, 503) and per-request timeout (AbortController).
+   * Each retry gets a fresh timeout.
+   */
+  async fetchJSON(url, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= 3; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      let nonRetryable = false;
+      try {
+        const res = await globalThis.fetch(url, {
+          ...init,
+          headers: { ...this.headers(), ...init?.headers ?? {} },
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (res.ok) {
+          return res.json();
+        }
+        const shouldRetry = attempt < 3 && RETRY_STATUSES.includes(res.status);
+        if (!shouldRetry) {
+          nonRetryable = true;
+          throw await BetterCMSError.from(res);
+        }
+        await sleep(RETRY_DELAYS[attempt] ?? 0);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new BetterCMSError("Request timeout", 408, "NETWORK_ERROR");
+        }
+        if (nonRetryable) {
+          throw err;
+        }
+        lastError = err;
+        if (attempt < 3) {
+          await sleep(RETRY_DELAYS[attempt] ?? 0);
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError ?? new BetterCMSError("Unreachable", 0, "NETWORK_ERROR");
+  }
+  /** Build the admin API URL. */
+  url(path) {
+    return `${this.baseUrl}${path}`;
+  }
+  /** Webhook management methods. */
+  webhooks() {
+    return addWebhookMethods(this);
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/methods/management/content.ts
+async function listModels(client) {
+  const res = await client.fetchJSON(
+    client.url("/management/content/models"),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function getModel(client, id) {
+  const res = await client.fetchJSON(
+    client.url(`/management/content/models/${id}`),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function listManagedPages(client) {
+  const res = await client.fetchJSON(
+    client.url("/management/pages"),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function createManagedPage(client, input) {
+  const res = await client.fetchJSON(
+    client.url("/management/pages"),
+    { method: "POST", body: JSON.stringify(input) }
+  );
+  return res.data;
+}
+async function addPageFields(client, id, input) {
+  const res = await client.fetchJSON(
+    client.url(`/management/pages/${id}`),
+    { method: "PATCH", body: JSON.stringify(input) }
+  );
+  return res.data;
+}
+async function getManagedPage(client, id) {
+  const res = await client.fetchJSON(
+    client.url(`/management/pages/${id}`),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function setPageContent(client, id, input) {
+  const res = await client.fetchJSON(
+    client.url(`/management/pages/${id}/content`),
+    { method: "PUT", body: JSON.stringify(input) }
+  );
+  return res.data;
+}
+async function addModelFields(client, id, input) {
+  const res = await client.fetchJSON(
+    client.url(`/management/content/models/${id}/fields`),
+    { method: "POST", body: JSON.stringify(input) }
+  );
+  return res.data;
+}
+async function listEntries(client, filter) {
+  const q = new URLSearchParams();
+  if (filter?.modelId) q.set("modelId", filter.modelId);
+  if (filter?.pageId) q.set("pageId", filter.pageId);
+  if (filter?.status) q.set("status", filter.status);
+  const qs3 = q.toString();
+  const res = await client.fetchJSON(
+    client.url(`/management/content/entries${qs3 ? `?${qs3}` : ""}`),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function getEntry(client, id) {
+  const res = await client.fetchJSON(
+    client.url(`/management/content/entries/${id}`),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function createModel(client, input) {
+  const res = await client.fetchJSON(
+    client.url("/management/content/models"),
+    { method: "POST", body: JSON.stringify(input) }
+  );
+  return res.data;
+}
+async function updateModel(client, id, input) {
+  const res = await client.fetchJSON(
+    client.url(`/management/content/models/${id}`),
+    { method: "PATCH", body: JSON.stringify(input) }
+  );
+  return res.data;
+}
+async function createEntry(client, input) {
+  const res = await client.fetchJSON(
+    client.url("/management/content/entries"),
+    { method: "POST", body: JSON.stringify(input) }
+  );
+  return res.data;
+}
+async function updateEntry(client, id, input, opts) {
+  const headers = {};
+  if (opts?.ifMatch !== void 0) headers["If-Match"] = `W/"${opts.ifMatch}"`;
+  const res = await client.fetchJSON(
+    client.url(`/management/content/entries/${id}`),
+    { method: "PATCH", body: JSON.stringify(input), headers }
+  );
+  return res.data;
+}
+async function deleteManagedPage(client, id) {
+  const res = await client.fetchJSON(
+    client.url(`/management/pages/${id}`),
+    { method: "DELETE" }
+  );
+  return res.data;
+}
+async function deleteEntry(client, id) {
+  const res = await client.fetchJSON(
+    client.url(`/management/content/entries/${id}`),
+    { method: "DELETE" }
+  );
+  return res.data;
+}
+async function deleteModel(client, id) {
+  const res = await client.fetchJSON(
+    client.url(`/management/content/models/${id}`),
+    { method: "DELETE" }
+  );
+  return res.data;
+}
+
+// src/methods/management/media.ts
+var MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  avif: "image/avif",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  pdf: "application/pdf"
+};
+function basenameOf(p) {
+  const clean = p.split(/[?#]/)[0] ?? p;
+  const seg = clean.split(/[\\/]/).pop();
+  return seg && seg.length > 0 ? seg : "asset";
+}
+function mimeFromName(name) {
+  const ext = name.split(".").pop()?.toLowerCase() ?? "";
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+var MAX_REDIRECTS = 5;
+function isPrivateIp(ip) {
+  const addr = ip.trim().toLowerCase();
+  const mapped = addr.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  const v4 = mapped ? mapped[1] : addr;
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(v4)) {
+    const o = v4.split(".").map((n) => Number(n));
+    if (o.some((n) => Number.isNaN(n) || n < 0 || n > 255)) return true;
+    const [a, b] = o;
+    if (a === 0 || a === 127) return true;
+    if (a === 10) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 169 && b === 254) return true;
+    if (a === 100 && b >= 64 && b <= 127) return true;
+    if (a >= 224) return true;
+    return false;
+  }
+  if (addr === "::" || addr === "::1") return true;
+  if (addr.startsWith("fe80") || addr.startsWith("fe9") || addr.startsWith("fea") || addr.startsWith("feb")) return true;
+  if (/^f[cd]/.test(addr)) return true;
+  return false;
+}
+async function assertPublicHttpUrl(raw) {
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    throw new Error(`Invalid URL: ${raw}`);
+  }
+  if (u.protocol !== "http:" && u.protocol !== "https:") {
+    throw new Error(`Refusing non-http(s) URL scheme: ${u.protocol}`);
+  }
+  const host = u.hostname.replace(/^\[|\]$/g, "");
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(host) || host.includes(":")) {
+    if (isPrivateIp(host)) throw new Error(`Refusing private/loopback address: ${host}`);
+    return u;
+  }
+  const { lookup } = await import("dns/promises");
+  const records = await lookup(host, { all: true });
+  if (records.length === 0) throw new Error(`Could not resolve host: ${host}`);
+  for (const r of records) {
+    if (isPrivateIp(r.address)) {
+      throw new Error(`Host ${host} resolves to a private/loopback address (${r.address}); refusing`);
+    }
+  }
+  return u;
+}
+async function safeFetch(raw) {
+  let target = raw;
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    await assertPublicHttpUrl(target);
+    const res = await globalThis.fetch(target, { redirect: "manual" });
+    if (res.status >= 300 && res.status < 400) {
+      const loc = res.headers.get("location");
+      if (!loc) return res;
+      target = new URL(loc, target).toString();
+      continue;
+    }
+    return res;
+  }
+  throw new Error(`Too many redirects ingesting ${raw}`);
+}
+async function uploadAsset(client, input) {
+  let bytes;
+  let mime;
+  let filename;
+  if (input.localPath) {
+    if (input.localPath.includes("..") || /(^|[\\/])~($|[\\/])/.test(input.localPath)) {
+      throw new Error(`Refusing localPath with traversal or home-dir reference: ${input.localPath}`);
+    }
+    const { readFile } = await import("fs/promises");
+    const buf = await readFile(input.localPath);
+    bytes = new Uint8Array(buf);
+    filename = input.filename ?? basenameOf(input.localPath);
+    mime = mimeFromName(filename);
+  } else if (input.url) {
+    const res = await safeFetch(input.url);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch ${input.url}: ${res.status}`);
+    }
+    bytes = new Uint8Array(await res.arrayBuffer());
+    filename = input.filename ?? basenameOf(input.url);
+    mime = res.headers.get("content-type")?.split(";")[0]?.trim() || mimeFromName(filename);
+  } else {
+    throw new Error("uploadAsset requires either localPath or url");
+  }
+  const params2 = new URLSearchParams({ filename });
+  if (input.altText) params2.set("altText", input.altText);
+  if (input.caption) params2.set("caption", input.caption);
+  if (input.folderId) params2.set("folderId", input.folderId);
+  const { data } = await client.fetchJSON(
+    client.url(`/management/media?${params2.toString()}`),
+    {
+      method: "POST",
+      headers: { "Content-Type": mime },
+      body: bytes
+    }
+  );
+  return data;
+}
+
+// src/methods/management/forms.ts
+async function listForms(client) {
+  const res = await client.fetchJSON(
+    client.url("/management/forms"),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function getForm(client, id) {
+  const res = await client.fetchJSON(
+    client.url(`/management/forms/${id}`),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function createForm(client, input) {
+  const res = await client.fetchJSON(client.url("/management/forms"), {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  return res.data;
+}
+async function updateForm(client, id, input) {
+  const res = await client.fetchJSON(client.url(`/management/forms/${id}`), {
+    method: "PATCH",
+    body: JSON.stringify(input)
+  });
+  return res.data;
+}
+
+// src/methods/management/components.ts
+async function listComponents(client) {
+  const res = await client.fetchJSON(
+    client.url("/management/components"),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function getComponent(client, id) {
+  const res = await client.fetchJSON(
+    client.url(`/management/components/${id}`),
+    { method: "GET" }
+  );
+  return res.data;
+}
+async function createComponent(client, input) {
+  const res = await client.fetchJSON(client.url("/management/components"), {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  return res.data;
+}
+async function updateComponent(client, id, input) {
+  const res = await client.fetchJSON(
+    client.url(`/management/components/${id}`),
+    { method: "PATCH", body: JSON.stringify(input) }
+  );
+  return res.data;
+}
+
+// src/management-client.ts
+var DEFAULT_BASE_URL2 = "https://api.bettercms.ai/v1";
+var DEFAULT_TIMEOUT2 = 1e4;
+var RETRY_STATUSES2 = [429, 503];
+var RETRY_DELAYS2 = [1e3, 2e3, 4e3];
+var BetterCMSManagementClient = class extends BetterCMSDeliveryClient {
+  timeout;
+  _apiKey;
+  constructor(options) {
+    super({ workspace: "", baseUrl: options.baseUrl ?? DEFAULT_BASE_URL2 });
+    this._apiKey = options.apiKey;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT2;
+  }
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      "X-API-Key": this._apiKey
+    };
+  }
+  /** Management API URL: baseUrl + path (path is workspace-scoped via the key). */
+  url(path) {
+    return `${this.baseUrl}${path}`;
+  }
+  /** fetchJSON with retry (429, 503) + per-request timeout (mirrors the admin client). */
+  async fetchJSON(url, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= 3; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      let nonRetryable = false;
+      try {
+        const res = await globalThis.fetch(url, {
+          ...init,
+          headers: { ...this.headers(), ...init?.headers ?? {} },
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (res.ok) {
+          return res.json();
+        }
+        const shouldRetry = attempt < 3 && RETRY_STATUSES2.includes(res.status);
+        if (!shouldRetry) {
+          nonRetryable = true;
+          throw await BetterCMSError.from(res);
+        }
+        await sleep2(RETRY_DELAYS2[attempt] ?? 0);
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new BetterCMSError("Request timeout", 408, "NETWORK_ERROR");
+        }
+        if (nonRetryable) throw err;
+        lastError = err;
+        if (attempt < 3) {
+          await sleep2(RETRY_DELAYS2[attempt] ?? 0);
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError ?? new BetterCMSError("Unreachable", 0, "NETWORK_ERROR");
+  }
+  // ── Schema authoring ──────────────────────────────────────────────────────
+  listModels() {
+    return listModels(this);
+  }
+  getModel(id) {
+    return getModel(this, id);
+  }
+  createModel(input) {
+    return createModel(this, input);
+  }
+  updateModel(id, input) {
+    return updateModel(this, id, input);
+  }
+  // ── Page authoring (page-first: singleton + dynamic) ──────────────────────
+  listPages() {
+    return listManagedPages(this);
+  }
+  /** Get one page by id INCLUDING its field schema + pageType. */
+  getPage(id) {
+    return getManagedPage(this, id);
+  }
+  createPage(input) {
+    return createManagedPage(this, input);
+  }
+  /** Append fields to an existing page (additive — the API rejects existing keys). */
+  addPageFields(id, input) {
+    return addPageFields(this, id, input);
+  }
+  /** Set a page's field VALUES — singleton pages get/update their one entry. */
+  setPageContent(id, input) {
+    return setPageContent(this, id, input);
+  }
+  // ── Schema authoring (additive field append) ──────────────────────────────
+  /** Append fields to a content model (additive — rejects existing keys). */
+  addModelFields(id, input) {
+    return addModelFields(this, id, input);
+  }
+  // ── Content authoring ─────────────────────────────────────────────────────
+  createEntry(input) {
+    return createEntry(this, input);
+  }
+  updateEntry(id, input, opts) {
+    return updateEntry(this, id, input, opts);
+  }
+  // ── Delete (soft-delete, reversible, audit-logged) ─────────────────────────
+  /** Soft-delete a page and its content entries. */
+  deletePage(id) {
+    return deleteManagedPage(this, id);
+  }
+  /** Soft-delete a single content entry. */
+  deleteEntry(id) {
+    return deleteEntry(this, id);
+  }
+  /** Soft-delete a content model and its entries. */
+  deleteModel(id) {
+    return deleteModel(this, id);
+  }
+  /** List content entries (incl. drafts), optionally filtered by model/page/status. */
+  listEntries(filter) {
+    return listEntries(this, filter);
+  }
+  /** Get one content entry by id INCLUDING its data (incl. drafts). */
+  getEntry(id) {
+    return getEntry(this, id);
+  }
+  // ── Media (P2): upload an asset from a local path or URL, get its CDN URL ──
+  uploadAsset(input) {
+    return uploadAsset(this, input);
+  }
+  // ── Forms (read-only): discover dashboard-built forms to embed into site code ──
+  /** List forms in the key's project (or workspace-level). */
+  listForms() {
+    return listForms(this);
+  }
+  /** Get one form by id INCLUDING its field schema + settings. */
+  getForm(id) {
+    return getForm(this, id);
+  }
+  /** Create a form in the key's project. */
+  createForm(input) {
+    return createForm(this, input);
+  }
+  /** Update a form by id (passing `fields` replaces the array). */
+  updateForm(id, input) {
+    return updateForm(this, id, input);
+  }
+  // ── Components: discover + author reusable symbols ──
+  listComponents() {
+    return listComponents(this);
+  }
+  getComponent(id) {
+    return getComponent(this, id);
+  }
+  createComponent(input) {
+    return createComponent(this, input);
+  }
+  updateComponent(id, input) {
+    return updateComponent(this, id, input);
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/auth.ts
+var AUTH_BASE_URL = "https://api.bettercms.ai/api/v1/auth";
+var AUTH_URL = "https://api.bettercms.ai/api/auth";
+async function authFetch(url, body) {
+  const res = await globalThis.fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw await BetterCMSError.from(res);
+  }
+  return res.json();
+}
+async function signIn(input) {
+  const data = await authFetch(`${AUTH_BASE_URL}/sign-in`, input);
+  return buildAuthResult(data);
+}
+async function signUp(input) {
+  const data = await authFetch(`${AUTH_BASE_URL}/sign-up`, input);
+  return buildAuthResult(data);
+}
+async function signInWithGoogle(options) {
+  const res = await globalThis.fetch(`${AUTH_URL}/sign-in/social`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      provider: "google",
+      callbackURL: options?.callbackURL,
+      idToken: options?.idToken,
+      disableRedirect: !!options?.idToken
+    })
+  });
+  if (!res.ok) {
+    throw await BetterCMSError.from(res);
+  }
+  const data = await res.json();
+  if (options?.idToken) {
+    return { ...buildAuthResult(data), url: data.url, redirect: data.redirect };
+  }
+  return { ...buildAuthResult(data), url: data.url, redirect: data.redirect };
+}
+async function signInWithGithub(options) {
+  const res = await globalThis.fetch(`${AUTH_URL}/sign-in/social`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      provider: "github",
+      callbackURL: options?.callbackURL,
+      idToken: options?.idToken,
+      disableRedirect: !!options?.idToken
+    })
+  });
+  if (!res.ok) {
+    throw await BetterCMSError.from(res);
+  }
+  const data = await res.json();
+  if (options?.idToken) {
+    return { ...buildAuthResult(data), url: data.url, redirect: data.redirect };
+  }
+  return { ...buildAuthResult(data), url: data.url, redirect: data.redirect };
+}
+function buildAuthResult(data) {
+  const admin = new BetterCMSAdminClient({ token: data.token });
+  return {
+    token: data.token,
+    user: data.user,
+    session: data.session,
+    admin,
+    signOut: async () => {
+      await globalThis.fetch(`${AUTH_BASE_URL}/sign-out`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${data.token}` }
+      });
+    }
+  };
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL3 = "https://api.bettercms.ai/v1";
+var BetterCMS = {
+  /**
+   * Returns a client for fetching published content.
+   * `apiKey` is optional — public content works without one.
+   */
+  site(options) {
+    return new BetterCMSDeliveryClient({
+      workspace: options.workspace,
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL3
+    });
+  },
+  /**
+   * Returns a typed client for admin CRUD operations.
+   * Requires a BetterAuth session Bearer token.
+   */
+  admin(options) {
+    return new BetterCMSAdminClient(options);
+  },
+  /**
+   * Returns a typed client for the Management API (programmatic schema + content
+   * authoring). Requires a content:manage scoped API key.
+   */
+  management(options) {
+    return new BetterCMSManagementClient(options);
+  },
+  /**
+   * Sign in with email + password. Returns a session ready for API calls.
+   */
+  async auth(options) {
+    return signIn(options);
+  },
+  /**
+   * Sign up with email + password + name. Returns a session ready for API calls.
+   */
+  async signUp(options) {
+    return signUp(options);
+  }
+};
+
+// src/read-client.ts
+var RETRY_STATUSES3 = [429, 503];
+var RETRY_DELAYS3 = [250, 750, 1500];
+var DEFAULT_TIMEOUT3 = 1e4;
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+function qs(params2) {
+  const sp = new URLSearchParams();
+  for (const [k, v] of Object.entries(params2)) {
+    if (v !== void 0 && v !== "") sp.set(k, String(v));
+  }
+  const s = sp.toString();
+  return s ? `?${s}` : "";
+}
+function unwrap(json) {
+  if (json && typeof json === "object") {
+    const o = json;
+    const isPayload = "id" in o || "slug" in o || "items" in o;
+    if (!isPayload && "data" in o) return o.data;
+  }
+  return json;
+}
+function createClient(options) {
+  const apiUrl = options.apiUrl.replace(/\/+$/, "");
+  const { workspace, apiKey, perspective = "published", previewToken } = options;
+  const defaultProjectId = options.projectId;
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT3;
+  const base = `${apiUrl}/api/v1/delivery/${workspace}`;
+  const headers = () => {
+    const h = { "Content-Type": "application/json" };
+    if (apiKey) h["X-API-Key"] = apiKey;
+    return h;
+  };
+  async function fetchJSON(url) {
+    let lastError;
+    for (let attempt = 0; attempt <= RETRY_DELAYS3.length; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const res = await globalThis.fetch(url, {
+          headers: headers(),
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (res.ok) return await res.json();
+        const retryable = attempt < RETRY_DELAYS3.length && RETRY_STATUSES3.includes(res.status);
+        if (!retryable) throw await BetterCMSError.from(res);
+        await sleep3(RETRY_DELAYS3[attempt] ?? 0);
+      } catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new BetterCMSError("Request timeout", 408, "NETWORK_ERROR");
+        }
+        if (err instanceof BetterCMSError) throw err;
+        lastError = err;
+        if (attempt < RETRY_DELAYS3.length) {
+          await sleep3(RETRY_DELAYS3[attempt] ?? 0);
+          continue;
+        }
+        throw new BetterCMSError(
+          `Network error: ${err instanceof Error ? err.message : String(err)}`,
+          0,
+          "NETWORK_ERROR"
+        );
+      }
+    }
+    throw lastError ?? new BetterCMSError("Unreachable", 0, "NETWORK_ERROR");
+  }
+  const draft = perspective === "drafts";
+  return {
+    perspective,
+    async getEntry(slug, opts) {
+      const query = qs({
+        depth: opts?.depth,
+        select: opts?.select?.join(",")
+      });
+      const url = draft && previewToken ? `${apiUrl}/api/v1/preview/${encodeURIComponent(slug)}${qs({
+        token: previewToken,
+        depth: opts?.depth,
+        select: opts?.select?.join(","),
+        stega: options.stega ? "1" : void 0
+      })}` : `${base}/content-entries/${encodeURIComponent(slug)}${query}`;
+      return unwrap(await fetchJSON(url));
+    },
+    async listEntries(opts) {
+      const url = `${base}/content-entries${qs({
+        model: opts?.model,
+        page: opts?.page,
+        perPage: opts?.perPage,
+        depth: opts?.depth,
+        select: opts?.select?.join(",")
+      })}`;
+      return unwrap(await fetchJSON(url));
+    },
+    async getPage(slug) {
+      let page = 1;
+      for (; ; ) {
+        const list = await this.listPages({ page, perPage: 100 });
+        const found = list.items.find((p) => p.slug === slug);
+        if (found) return found;
+        if (!list.hasNextPage) return null;
+        page += 1;
+      }
+    },
+    async listPages(opts) {
+      const url = `${base}/pages${qs({
+        page: opts?.page,
+        perPage: opts?.perPage
+      })}`;
+      return unwrap(await fetchJSON(url));
+    },
+    async listForms(opts) {
+      const url = `${base}/forms${qs({
+        projectId: opts?.projectId ?? defaultProjectId
+      })}`;
+      return unwrap(
+        await fetchJSON(url)
+      );
+    },
+    tag(resource, id) {
+      return id ? `bcms:${workspace}:${resource}:${id}` : `bcms:${workspace}:${resource}`;
+    }
+  };
+}
+
+// src/stega.ts
+var ZERO = "\u200B";
+var ONE = "\u200C";
+var START = "\u2060";
+var END = "\u2061";
+var FRAME = new RegExp(`${START}([${ZERO}${ONE}]*)${END}`);
+function toBits(s) {
+  const bytes = new TextEncoder().encode(s);
+  let out = "";
+  for (const b of bytes) {
+    for (let i = 7; i >= 0; i--) out += b >> i & 1 ? ONE : ZERO;
+  }
+  return out;
+}
+function fromBits(bits) {
+  const bytes = [];
+  for (let i = 0; i + 8 <= bits.length; i += 8) {
+    let b = 0;
+    for (let j = 0; j < 8; j++) b = b << 1 | (bits[i + j] === ONE ? 1 : 0);
+    bytes.push(b);
+  }
+  return new TextDecoder().decode(new Uint8Array(bytes));
+}
+function encodeStega(clean, payload) {
+  return `${clean}${START}${toBits(JSON.stringify(payload))}${END}`;
+}
+function decodeStega(value) {
+  const m = value.match(FRAME);
+  if (!m || m[1] == null) return null;
+  try {
+    const payload = JSON.parse(fromBits(m[1]));
+    return { clean: value.replace(FRAME, ""), payload };
+  } catch {
+    return null;
+  }
+}
+function stripStega(value) {
+  return value.replace(FRAME, "");
+}
+
+// src/seo.ts
+function jsonLdNodes(schema) {
+  if (!schema) return [];
+  const arr = Array.isArray(schema) ? schema : [schema];
+  return arr.filter((node) => node && Object.keys(node).length > 0);
+}
+function resolveSeo(page, defaults = {}) {
+  const meta = page.metaJson ?? {};
+  const title = page.metaTitle || page.title || "";
+  const description = page.metaDescription || defaults.metaDescription || "";
+  const ogImage = meta.og?.image || defaults.og?.image || defaults.ogImage || "";
+  const ogTitle = meta.og?.title || title;
+  const ogDescription = meta.og?.description || description;
+  const twImage = meta.twitter?.image || ogImage;
+  const canonical = meta.canonical || "";
+  return {
+    title,
+    description,
+    canonical,
+    og: {
+      title: ogTitle,
+      description: ogDescription,
+      type: meta.og?.type || defaults.og?.type || "website",
+      image: ogImage,
+      url: canonical
+    },
+    twitter: {
+      card: meta.twitter?.card || defaults.twitter?.card || (twImage ? "summary_large_image" : "summary"),
+      title: meta.twitter?.title || ogTitle,
+      description: meta.twitter?.description || ogDescription,
+      image: twImage,
+      site: defaults.twitterHandle || ""
+    },
+    jsonLd: [...jsonLdNodes(defaults.siteSchema), ...jsonLdNodes(meta.schema)]
+  };
+}
+
+// src/search.ts
+var DEFAULT_BASE_URL4 = "https://api.bettercms.ai";
+async function search(opts) {
+  const q = opts.q.trim();
+  if (!q) return [];
+  const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL4).replace(/\/+$/, "");
+  const doFetch = opts.fetchImpl ?? globalThis.fetch;
+  const params2 = new URLSearchParams({ project: opts.project, q });
+  if (opts.limit) params2.set("limit", String(opts.limit));
+  try {
+    const res = await doFetch(`${baseUrl}/api/v1/delivery/search?${params2}`, { signal: opts.signal });
+    if (!res.ok) return [];
+    const json = await res.json().catch(() => ({}));
+    return json.hits ?? [];
+  } catch {
+    return [];
+  }
+}
+
+// src/index.ts
+import { default as default2, imageUrl } from "@bettercms-ai/image-url";
+
+// src/methods/admin/pages.ts
+function params(opts) {
+  const p = new URLSearchParams();
+  if (opts?.page != null) p.set("page", String(opts.page));
+  if (opts?.limit != null) p.set("limit", String(opts.limit));
+  return p.toString() ? `?${p}` : "";
+}
+async function listPages(client, opts) {
+  const res = await client.fetchJSON(
+    client.url(`/pages${params(opts)}`)
+  );
+  return res.data;
+}
+async function getPage(client, id) {
+  const res = await client.fetchJSON(client.url(`/pages/${id}`));
+  return res.data;
+}
+async function createPage(client, data) {
+  const res = await client.fetchJSON(client.url("/pages"), {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+  return res.data;
+}
+async function updatePage(client, id, data) {
+  const res = await client.fetchJSON(client.url(`/pages/${id}`), {
+    method: "PATCH",
+    body: JSON.stringify(data)
+  });
+  return res.data;
+}
+async function deletePage(client, id) {
+  await client.fetchJSON(client.url(`/pages/${id}`), { method: "DELETE" });
+}
+async function publishPage(client, id) {
+  const res = await client.fetchJSON(client.url(`/pages/${id}/publish`), {
+    method: "POST"
+  });
+  return res.data;
+}
+
+// src/methods/admin/media.ts
+async function listMedia(client, opts) {
+  const p = new URLSearchParams();
+  if (opts?.page != null) p.set("page", String(opts.page));
+  if (opts?.limit != null) p.set("limit", String(opts.limit));
+  const qs3 = p.toString() ? `?${p}` : "";
+  const res = await client.fetchJSON(
+    client.url(`/media${qs3}`)
+  );
+  return res.data;
+}
+async function getMedia(client, id) {
+  const res = await client.fetchJSON(client.url(`/media/${id}`));
+  return res.data;
+}
+async function uploadMedia(client, file, metadata) {
+  const formData = new FormData();
+  formData.append("file", file);
+  if (metadata?.alt) formData.append("alt", metadata.alt);
+  if (metadata?.caption) formData.append("caption", metadata.caption);
+  const res = await client.fetchJSON(client.url("/media"), {
+    method: "POST",
+    body: formData
+  });
+  return res.data;
+}
+async function deleteMedia(client, id) {
+  await client.fetchJSON(client.url(`/media/${id}`), { method: "DELETE" });
+}
+
+// src/methods/admin/forms.ts
+async function listForms2(client, opts) {
+  const p = new URLSearchParams();
+  if (opts?.page != null) p.set("page", String(opts.page));
+  if (opts?.limit != null) p.set("limit", String(opts.limit));
+  const qs3 = p.toString() ? `?${p}` : "";
+  const res = await client.fetchJSON(
+    client.url(`/forms${qs3}`)
+  );
+  return res.data;
+}
+async function getForm2(client, id) {
+  const res = await client.fetchJSON(client.url(`/forms/${id}`));
+  return res.data;
+}
+async function createForm2(client, data) {
+  const res = await client.fetchJSON(client.url("/forms"), {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+  return res.data;
+}
+async function updateForm2(client, id, data) {
+  const res = await client.fetchJSON(client.url(`/forms/${id}`), {
+    method: "PATCH",
+    body: JSON.stringify(data)
+  });
+  return res.data;
+}
+async function deleteForm(client, id) {
+  await client.fetchJSON(client.url(`/forms/${id}`), { method: "DELETE" });
+}
+
+// src/methods/admin/submissions.ts
+async function listSubmissions(client, opts) {
+  const p = new URLSearchParams();
+  if (opts?.page != null) p.set("page", String(opts.page));
+  if (opts?.limit != null) p.set("limit", String(opts.limit));
+  const qs3 = p.toString() ? `?${p}` : "";
+  const res = await client.fetchJSON(
+    client.url(`/submissions${qs3}`)
+  );
+  return res.data;
+}
+async function getSubmission(client, id) {
+  const res = await client.fetchJSON(client.url(`/submissions/${id}`));
+  return res.data;
+}
+async function deleteSubmission(client, id) {
+  await client.fetchJSON(client.url(`/submissions/${id}`), { method: "DELETE" });
+}
+
+// src/methods/admin/workspaces.ts
+async function listWorkspaces(client) {
+  const res = await client.fetchJSON(client.url("/workspaces"));
+  return res.data;
+}
+async function getWorkspace(client, id) {
+  const res = await client.fetchJSON(client.url(`/workspaces/${id}`));
+  return res.data;
+}
+async function createWorkspace(client, data) {
+  const res = await client.fetchJSON(client.url("/workspaces"), {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+  return res.data;
+}
+async function updateWorkspace(client, id, data) {
+  const res = await client.fetchJSON(client.url(`/workspaces/${id}`), {
+    method: "PATCH",
+    body: JSON.stringify(data)
+  });
+  return res.data;
+}
+async function deleteWorkspace(client, id) {
+  await client.fetchJSON(client.url(`/workspaces/${id}`), { method: "DELETE" });
+}
+
+// src/methods/admin/api-keys.ts
+async function listApiKeys(client) {
+  const res = await client.fetchJSON(client.url("/api-keys"));
+  return res.data;
+}
+async function createApiKey(client, data) {
+  const res = await client.fetchJSON(client.url("/api-keys"), {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+  return res.data;
+}
+async function updateApiKey(client, id, data) {
+  const res = await client.fetchJSON(client.url(`/api-keys/${id}`), {
+    method: "PATCH",
+    body: JSON.stringify(data)
+  });
+  return res.data;
+}
+async function regenerateApiKey(client, id) {
+  const res = await client.fetchJSON(client.url(`/api-keys/${id}/regenerate`), {
+    method: "POST"
+  });
+  return res.data;
+}
+async function getApiKeyUsage(client, id) {
+  const res = await client.fetchJSON(client.url(`/api-keys/${id}/usage`));
+  return res.data;
+}
+async function revokeApiKey(client, id) {
+  await client.fetchJSON(client.url(`/api-keys/${id}`), { method: "DELETE" });
+}
+
+// src/methods/admin/members.ts
+function qs2(opts) {
+  const p = new URLSearchParams();
+  if (opts?.page != null) p.set("page", String(opts.page));
+  if (opts?.limit != null) p.set("limit", String(opts.limit));
+  return p.toString() ? `?${p}` : "";
+}
+async function listMembers(client, workspaceId, opts) {
+  const res = await client.fetchJSON(
+    client.url(`/workspaces/${workspaceId}/members${qs2(opts)}`)
+  );
+  return res.data;
+}
+async function getMember(client, workspaceId, memberId) {
+  const res = await client.fetchJSON(
+    client.url(`/workspaces/${workspaceId}/members/${memberId}`)
+  );
+  return res.data;
+}
+async function inviteMember(client, workspaceId, data) {
+  const res = await client.fetchJSON(
+    client.url(`/workspaces/${workspaceId}/members/invite`),
+    { method: "POST", body: JSON.stringify(data) }
+  );
+  return res.data;
+}
+async function updateMemberRole(client, workspaceId, memberId, role) {
+  const res = await client.fetchJSON(
+    client.url(`/workspaces/${workspaceId}/members/${memberId}`),
+    { method: "PATCH", body: JSON.stringify({ role }) }
+  );
+  return res.data;
+}
+async function removeMember(client, workspaceId, memberId) {
+  await client.fetchJSON(
+    client.url(`/workspaces/${workspaceId}/members/${memberId}`),
+    { method: "DELETE" }
+  );
+}
+
+// src/forms.ts
+var DEFAULT_BASE_URL5 = "https://api.bettercms.ai";
+function shouldShowField(field, values) {
+  if (!field.showIf) return true;
+  return String(values[field.showIf.field] ?? "") === field.showIf.equals;
+}
+function formInitialValues(form, prefill = {}) {
+  const values = {};
+  for (const field of form.fields) {
+    if (field.type === "checkbox" || field.type === "consent") {
+      values[field.key] = false;
+    } else {
+      values[field.key] = prefill[field.key] ?? field.defaultValue ?? "";
+    }
+  }
+  return values;
+}
+async function submitForm(opts) {
+  const baseUrl = (opts.baseUrl ?? DEFAULT_BASE_URL5).replace(/\/+$/, "");
+  const doFetch = opts.fetchImpl ?? globalThis.fetch;
+  const body = { data: opts.data };
+  if (opts.turnstileToken) body["cf-turnstile-response"] = opts.turnstileToken;
+  let res;
+  try {
+    res = await doFetch(`${baseUrl}/api/v1/forms/public/${opts.formId}/submissions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    throw new BetterCMSError(
+      `Network error: ${err instanceof Error ? err.message : String(err)}`,
+      0,
+      ErrorCodes.NETWORK_ERROR
+    );
+  }
+  if (!res.ok) {
+    const error = await BetterCMSError.from(res.clone());
+    const body2 = await res.json().catch(() => ({}));
+    if (body2.errors) error.fieldErrors = body2.errors;
+    throw error;
+  }
+  const json = await res.json().catch(() => ({}));
+  return { id: String(json.id ?? "") };
+}
+
+// src/index.ts
+import { isBlock, getBlockType } from "@bettercms-ai/types";
+export {
+  BetterCMSError as BCMSClientError,
+  ErrorCodes as BCMSErrorCodes,
+  BetterCMS,
+  BetterCMSAdminClient,
+  BetterCMSDeliveryClient,
+  BetterCMSError,
+  BetterCMSManagementClient,
+  ErrorCodes,
+  addModelFields,
+  addPageFields,
+  createApiKey,
+  createClient,
+  createEntry,
+  createForm2 as createForm,
+  createManagedPage,
+  createModel,
+  createPage,
+  createWorkspace,
+  decodeStega,
+  deleteForm,
+  deleteMedia,
+  deletePage,
+  deleteSubmission,
+  deleteWorkspace,
+  encodeStega,
+  formInitialValues,
+  getApiKeyUsage,
+  getBlockType,
+  getEntry,
+  getForm2 as getForm,
+  getManagedPage,
+  getMedia,
+  getMember,
+  getModel,
+  getPage,
+  getSubmission,
+  getWorkspace,
+  imageUrl,
+  default2 as imageUrlBuilder,
+  inviteMember,
+  isBlock,
+  listApiKeys,
+  listEntries,
+  listForms2 as listForms,
+  listManagedPages,
+  listMedia,
+  listMembers,
+  listModels,
+  listPages,
+  listSubmissions,
+  listWorkspaces,
+  publishPage,
+  regenerateApiKey,
+  removeMember,
+  resolveSeo,
+  revokeApiKey,
+  search,
+  setPageContent,
+  shouldShowField,
+  signIn,
+  signInWithGithub,
+  signInWithGoogle,
+  signUp,
+  stripStega,
+  submitForm,
+  updateApiKey,
+  updateEntry,
+  updateForm2 as updateForm,
+  updateMemberRole,
+  updateModel,
+  updatePage,
+  updateWorkspace,
+  uploadMedia
+};
+//# sourceMappingURL=index.js.map