@8ux-co/eelzap 0.0.0-stage → 0.10.0

package/dist/index.cjs

@@ -0,0 +1,2055 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CollectionFieldsResource: () => CollectionFieldsResource,
+  CollectionSectionsResource: () => CollectionSectionsResource,
+  CollectionsResource: () => CollectionsResource,
+  CommentsResource: () => CommentsResource,
+  DocumentFieldsResource: () => DocumentFieldsResource,
+  DocumentSectionsResource: () => DocumentSectionsResource,
+  DocumentSeoResource: () => DocumentSeoResource,
+  DocumentValuesResource: () => DocumentValuesResource,
+  DocumentVersionsResource: () => DocumentVersionsResource,
+  DocumentsResource: () => DocumentsResource,
+  EelZapClient: () => EelZapClient,
+  EelZapError: () => EelZapError,
+  EelZapNetworkError: () => EelZapNetworkError,
+  ItemQueryBuilder: () => ItemQueryBuilder,
+  ItemSeoResource: () => ItemSeoResource,
+  ItemVersionsResource: () => ItemVersionsResource,
+  ItemsResource: () => ItemsResource,
+  MediaResource: () => MediaResource,
+  MemoryCacheAdapter: () => MemoryCacheAdapter,
+  PreviewTokensResource: () => PreviewTokensResource,
+  SiteResource: () => SiteResource,
+  SitesResource: () => SitesResource,
+  WEBHOOK_SIGNATURE_HEADER: () => WEBHOOK_SIGNATURE_HEADER,
+  WEBHOOK_TIMESTAMP_HEADER: () => WEBHOOK_TIMESTAMP_HEADER,
+  WEBHOOK_TOLERANCE_SECONDS: () => WEBHOOK_TOLERANCE_SECONDS,
+  cachedFetch: () => cachedFetch,
+  cleanStega: () => cleanStega,
+  createClient: () => createClient,
+  getMediaUrl: () => getMediaUrl,
+  hasStega: () => hasStega,
+  isEelZapError: () => isEelZapError,
+  verifyWebhookSignature: () => verifyWebhookSignature,
+  webhookChanges: () => webhookChanges
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/utils.ts
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+function isPreviewToken(apiKey) {
+  return apiKey.trim().startsWith("zpt_");
+}
+function previewParam(options) {
+  return options.preview ? options.stega === false ? { preview: 1, stega: 0 } : { preview: 1 } : {};
+}
+function markPreview(value) {
+  if (value && typeof value === "object") {
+    Object.defineProperty(value, /* @__PURE__ */ Symbol.for("eelzap.preview"), { value: true });
+  }
+  return value;
+}
+function isPreviewResult(value) {
+  return !!value && typeof value === "object" && value[/* @__PURE__ */ Symbol.for("eelzap.preview")] === true;
+}
+function newIdempotencyKey() {
+  const crypto = globalThis.crypto;
+  return crypto?.randomUUID ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function toArrayParam(values) {
+  return values && values.length > 0 ? values.join(",") : void 0;
+}
+function mergeRequestOptions(defaults, options) {
+  return {
+    ...defaults,
+    ...options
+  };
+}
+function cleanParams(params) {
+  return Object.fromEntries(
+    Object.entries(params).flatMap(([key, value]) => {
+      return value === void 0 ? [] : [[key, String(value)]];
+    })
+  );
+}
+function normalizeHeaderValue(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function isOperatorMap(value) {
+  return typeof value === "object" && !Array.isArray(value);
+}
+function serializeFilters(filters) {
+  if (!filters) {
+    return {};
+  }
+  return Object.entries(filters).reduce((acc, [field, value]) => {
+    if (!isOperatorMap(value)) {
+      acc[`filter[${field}]`] = String(value);
+      return acc;
+    }
+    for (const [operator, operatorValue] of Object.entries(value)) {
+      if (operatorValue === void 0) {
+        continue;
+      }
+      const serializedValue = Array.isArray(operatorValue) ? operatorValue.join(",") : String(operatorValue);
+      acc[`filter[${field}][${operator}]`] = serializedValue;
+    }
+    return acc;
+  }, {});
+}
+function maskApiKey(apiKey) {
+  if (apiKey.length <= 8) {
+    return "***";
+  }
+  return `${apiKey.slice(0, 4)}...${apiKey.slice(-4)}`;
+}
+
+// src/cache.ts
+var _store;
+var MemoryCacheAdapter = class {
+  constructor() {
+    __privateAdd(this, _store, /* @__PURE__ */ new Map());
+  }
+  get(key) {
+    return __privateGet(this, _store).get(key);
+  }
+  set(key, value) {
+    __privateGet(this, _store).set(key, value);
+  }
+  /** Returns the number of cached entries. */
+  get size() {
+    return __privateGet(this, _store).size;
+  }
+  /** Removes a specific key from the cache. */
+  delete(key) {
+    return __privateGet(this, _store).delete(key);
+  }
+  /** Removes all cached entries. */
+  clear() {
+    __privateGet(this, _store).clear();
+  }
+};
+_store = new WeakMap();
+async function cachedFetch(keyOrOptions, fetcher, adapter) {
+  const options = typeof keyOrOptions === "string" ? {
+    key: keyOrOptions,
+    fetcher,
+    adapter,
+    strategy: "network-first"
+  } : {
+    ...keyOrOptions,
+    strategy: keyOrOptions.strategy ?? "network-first"
+  };
+  if (options.strategy === "cache-first") {
+    const cached = await options.adapter.get(options.key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    return store(options.adapter, options.key, await options.fetcher());
+  }
+  try {
+    return await store(options.adapter, options.key, await options.fetcher());
+  } catch (error) {
+    const cached = await options.adapter.get(options.key);
+    if (cached !== void 0) {
+      return cached;
+    }
+    throw error;
+  }
+}
+async function store(adapter, key, result) {
+  if (!isPreviewResult(result)) await adapter.set(key, result);
+  return result;
+}
+
+// src/errors.ts
+var EelZapError = class extends Error {
+  constructor(code, message, status, details = []) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "status");
+    /** Per-field problems when the API refused the input; empty otherwise. */
+    __publicField(this, "details");
+    this.name = "EelZapError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+};
+var EelZapNetworkError = class extends EelZapError {
+  constructor(cause, message = "Network request failed.") {
+    super("NETWORK_ERROR", message, 0);
+    __publicField(this, "cause");
+    this.name = "EelZapNetworkError";
+    this.cause = cause;
+  }
+};
+function isEelZapError(error) {
+  return error instanceof EelZapError;
+}
+
+// src/paths.ts
+function trimSlashes(value) {
+  return value.replace(/^\/+|\/+$/g, "");
+}
+function buildResourcePath(...segments) {
+  const normalized = segments.map(trimSlashes).filter((segment) => segment.length > 0);
+  return `/${normalized.join("/")}`;
+}
+function normalizePathPrefix(pathPrefix) {
+  const trimmed = trimSlashes(pathPrefix);
+  return trimmed.length > 0 ? `${trimmed}/` : "";
+}
+
+// src/retry.ts
+function resolveRetry(retry) {
+  if (retry === false) return null;
+  const options = retry === true || retry === void 0 ? {} : retry;
+  const resolved = {
+    retries: options.retries ?? 3,
+    maxDelayMs: options.maxDelayMs ?? 6e4,
+    baseDelayMs: options.baseDelayMs ?? 500,
+    onRetry: options.onRetry
+  };
+  return resolved.retries > 0 ? resolved : null;
+}
+function isRepeatable(method, headers, body) {
+  if (method === "GET" || method === "HEAD") return true;
+  return headers.has("Idempotency-Key") && (body == null || typeof body === "string");
+}
+function parseRetryAfter(value, now) {
+  if (value === null) return null;
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return Number(trimmed) * 1e3;
+  const date = Date.parse(trimmed);
+  return Number.isNaN(date) ? null : Math.max(0, date - now);
+}
+function retryDelay(response, attempt, options, now = Date.now(), random = Math.random) {
+  if (attempt > options.retries) return null;
+  if (response.status !== 429 && response.status !== 503) return null;
+  const retryAfter = parseRetryAfter(response.headers.get("Retry-After"), now);
+  if (retryAfter !== null) {
+    if (retryAfter > options.maxDelayMs) return null;
+    return Math.min(options.maxDelayMs, retryAfter + Math.floor(random() * 1e3));
+  }
+  if (response.status === 503) return null;
+  const step = Math.min(options.maxDelayMs, options.baseDelayMs * 2 ** (attempt - 1));
+  return Math.floor(step / 2 + random() * (step / 2));
+}
+
+// src/http.ts
+var _config, _HttpClient_instances, request_fn, read_fn, withJsonBody_fn;
+var HttpClient = class {
+  constructor(config) {
+    __privateAdd(this, _HttpClient_instances);
+    __privateAdd(this, _config);
+    __privateSet(this, _config, config);
+  }
+  async get(path, options) {
+    return __privateMethod(this, _HttpClient_instances, request_fn).call(this, "GET", path, options);
+  }
+  async post(path, body, options) {
+    return __privateMethod(this, _HttpClient_instances, request_fn).call(this, "POST", path, __privateMethod(this, _HttpClient_instances, withJsonBody_fn).call(this, body, options));
+  }
+  async patch(path, body, options) {
+    return __privateMethod(this, _HttpClient_instances, request_fn).call(this, "PATCH", path, __privateMethod(this, _HttpClient_instances, withJsonBody_fn).call(this, body, options));
+  }
+  async put(path, body, options) {
+    return __privateMethod(this, _HttpClient_instances, request_fn).call(this, "PUT", path, __privateMethod(this, _HttpClient_instances, withJsonBody_fn).call(this, body, options));
+  }
+  async delete(path, body, options) {
+    return __privateMethod(this, _HttpClient_instances, request_fn).call(this, "DELETE", path, __privateMethod(this, _HttpClient_instances, withJsonBody_fn).call(this, body, options));
+  }
+  async upload(url, body, headers) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, __privateGet(this, _config).timeout);
+    try {
+      const response = await __privateGet(this, _config).fetch(url, {
+        method: "PUT",
+        body,
+        headers,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw await this.toEelZapError(response);
+      }
+    } catch (error) {
+      if (error instanceof EelZapError) {
+        throw error;
+      }
+      throw new EelZapNetworkError(
+        error,
+        error instanceof Error ? error.message : "Network request failed."
+      );
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async request(path, options) {
+    return this.get(path, options);
+  }
+  async toEelZapError(response) {
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (contentType.includes("application/json")) {
+      const payload = await response.json();
+      const code = payload.error?.code ?? "INTERNAL_ERROR";
+      const message = payload.error?.message ?? `Request failed with status ${String(response.status)}.`;
+      const status = payload.error?.status ?? response.status;
+      const details = Array.isArray(payload.error?.details) ? payload.error.details : [];
+      return new EelZapError(code, message, status, details);
+    }
+    return new EelZapError(
+      "INTERNAL_ERROR",
+      `Request failed with status ${String(response.status)}.`,
+      response.status
+    );
+  }
+};
+_config = new WeakMap();
+_HttpClient_instances = new WeakSet();
+request_fn = async function(method, path, options) {
+  const prefix = normalizePathPrefix(__privateGet(this, _config).pathPrefix);
+  const normalizedPath = path.replace(/^\/+/, "");
+  const url = new URL(`${prefix}${normalizedPath}`, __privateGet(this, _config).baseUrl);
+  for (const [key, value] of Object.entries(cleanParams(options?.params ?? {}))) {
+    url.searchParams.set(key, value);
+  }
+  const headers = new Headers(__privateGet(this, _config).defaultHeaders);
+  for (const [key, value] of new Headers(options?.headers).entries()) {
+    headers.set(key, value);
+  }
+  headers.set("Authorization", `Bearer ${__privateGet(this, _config).apiKey}`);
+  if (options?.contentType) {
+    headers.set("Content-Type", options.contentType);
+  } else if (!headers.has("Content-Type") && options?.body !== void 0) {
+    headers.set("Content-Type", "application/json");
+  }
+  const retry = __privateGet(this, _config).retry;
+  const repeatable = retry ? isRepeatable(method, headers, options?.body) : false;
+  for (let attempt = 1; ; attempt++) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, __privateGet(this, _config).timeout);
+    let delayMs;
+    let status;
+    try {
+      const response = await __privateGet(this, _config).fetch(url.toString(), {
+        method,
+        body: options?.body,
+        headers,
+        signal: controller.signal
+      });
+      delayMs = repeatable && retry ? retryDelay(response, attempt, retry) : null;
+      if (delayMs === null) {
+        return await __privateMethod(this, _HttpClient_instances, read_fn).call(this, url, response);
+      }
+      status = response.status;
+      await response.body?.cancel().catch(() => void 0);
+    } catch (error) {
+      if (error instanceof EelZapError) {
+        throw error;
+      }
+      throw new EelZapNetworkError(
+        error,
+        error instanceof Error ? error.message : "Network request failed."
+      );
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    retry?.onRetry?.({ attempt, delayMs, status, method, url: url.toString() });
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+};
+read_fn = async function(url, response) {
+  if (response.status === 304 || response.status === 204) {
+    return void 0;
+  }
+  if (!response.ok) {
+    throw await this.toEelZapError(response);
+  }
+  const data = await response.json();
+  return url.searchParams.get("preview") === "1" || isPreviewToken(__privateGet(this, _config).apiKey) ? markPreview(data) : data;
+};
+withJsonBody_fn = function(body, options) {
+  if (body === void 0) {
+    return options;
+  }
+  return {
+    ...options,
+    body: JSON.stringify(body),
+    contentType: "application/json"
+  };
+};
+
+// src/resources/resource-helpers.ts
+function normalizeFieldInput(input) {
+  if (input.label || !input.name) {
+    return input;
+  }
+  return {
+    ...input,
+    label: input.name
+  };
+}
+function toDeleteBody(options) {
+  if (!options?.deleteMediaIds || options.deleteMediaIds.length === 0) {
+    return void 0;
+  }
+  return {
+    deleteMediaIds: options.deleteMediaIds
+  };
+}
+function idempotent(options) {
+  return { headers: { "Idempotency-Key": options?.idempotencyKey ?? newIdempotencyKey() } };
+}
+
+// src/resources/collection-fields.ts
+var _http;
+var CollectionFieldsResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http);
+    __privateSet(this, _http, http);
+  }
+  /**
+   * Lists all fields in a collection.
+   */
+  async list(collectionKey) {
+    const response = await __privateGet(this, _http).get(
+      buildResourcePath("collections", collectionKey, "fields")
+    );
+    return response.fields;
+  }
+  /**
+   * Creates a field in a collection.
+   *
+   * Sends an `Idempotency-Key` (required of suite bearers): a fresh one per
+   * call, or `options.idempotencyKey` to make your own retry safe.
+   */
+  async create(collectionKey, input, options) {
+    const response = await __privateGet(this, _http).post(
+      buildResourcePath("collections", collectionKey, "fields"),
+      normalizeFieldInput(input),
+      idempotent(options)
+    );
+    return response.field;
+  }
+  /**
+   * Updates a field in a collection.
+   */
+  async update(collectionKey, fieldId, input) {
+    const response = await __privateGet(this, _http).patch(
+      buildResourcePath("collections", collectionKey, "fields", fieldId),
+      normalizeFieldInput(input)
+    );
+    return response.field;
+  }
+  /**
+   * Deletes a field from a collection.
+   */
+  async delete(collectionKey, fieldId) {
+    return __privateGet(this, _http).delete(
+      buildResourcePath("collections", collectionKey, "fields", fieldId)
+    );
+  }
+  /**
+   * Lists the collection's archived (soft-deleted) fields, most recently
+   * deleted first. Their values are kept, which is what makes `restore` work.
+   *
+   * `GET /collections/{collectionKey}/fields/deleted`. Secret key, or suite
+   * bearer with `zap:content:read`.
+   */
+  async listDeleted(collectionKey) {
+    const response = await __privateGet(this, _http).get(
+      buildResourcePath("collections", collectionKey, "fields", "deleted")
+    );
+    return response.fields;
+  }
+  /**
+   * Brings an archived field back with every value it held, at the end of the
+   * root list (outside any section).
+   *
+   * `POST /collections/{collectionKey}/fields/{fieldId}/restore`. Secret key,
+   * or suite bearer with `zap:schema:write` and the Zap ADMIN role.
+   */
+  async restore(collectionKey, fieldId) {
+    const response = await __privateGet(this, _http).post(
+      buildResourcePath("collections", collectionKey, "fields", fieldId, "restore")
+    );
+    return response.field;
+  }
+  /**
+   * Reorders collection fields.
+   */
+  async reorder(collectionKey, fieldIds) {
+    return __privateGet(this, _http).put(
+      buildResourcePath("collections", collectionKey, "fields", "reorder"),
+      { fieldIds }
+    );
+  }
+};
+_http = new WeakMap();
+
+// src/resources/collection-sections.ts
+var _http2;
+var CollectionSectionsResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http2);
+    __privateSet(this, _http2, http);
+  }
+  /**
+   * Lists all sections in a collection.
+   */
+  async list(collectionKey) {
+    const response = await __privateGet(this, _http2).get(
+      buildResourcePath("collections", collectionKey, "sections")
+    );
+    return response.sections;
+  }
+  /**
+   * Gets a single section from a collection.
+   */
+  async get(collectionKey, sectionId) {
+    const response = await __privateGet(this, _http2).get(
+      buildResourcePath("collections", collectionKey, "sections", sectionId)
+    );
+    return response.section;
+  }
+  /**
+   * Creates a section in a collection.
+   *
+   * Sends an `Idempotency-Key` (required of suite bearers): a fresh one per
+   * call, or `options.idempotencyKey` to make your own retry safe.
+   */
+  async create(collectionKey, input, options) {
+    const response = await __privateGet(this, _http2).post(
+      buildResourcePath("collections", collectionKey, "sections"),
+      input,
+      idempotent(options)
+    );
+    return response.section;
+  }
+  /**
+   * Updates a section in a collection.
+   */
+  async update(collectionKey, sectionId, input) {
+    const response = await __privateGet(this, _http2).patch(
+      buildResourcePath("collections", collectionKey, "sections", sectionId),
+      input
+    );
+    return response.section;
+  }
+  /**
+   * Deletes a section from a collection.
+   */
+  async delete(collectionKey, sectionId) {
+    return __privateGet(this, _http2).delete(
+      buildResourcePath("collections", collectionKey, "sections", sectionId)
+    );
+  }
+};
+_http2 = new WeakMap();
+
+// src/resources/collections.ts
+var _http3, _defaults;
+var CollectionsResource = class {
+  /**
+   * @internal
+   */
+  constructor(http, defaults) {
+    __publicField(this, "fields");
+    __publicField(this, "sections");
+    __privateAdd(this, _http3);
+    __privateAdd(this, _defaults);
+    __privateSet(this, _http3, http);
+    __privateSet(this, _defaults, defaults);
+    this.fields = new CollectionFieldsResource(http);
+    this.sections = new CollectionSectionsResource(http);
+  }
+  /**
+   * Lists all collections available to the current API key.
+   */
+  async list(options) {
+    return __privateGet(this, _http3).get(buildResourcePath("collections"), {
+      params: {
+        status: options?.status ?? __privateGet(this, _defaults).status
+      }
+    });
+  }
+  /**
+   * Retrieves the schema for a single collection.
+   */
+  async get(collectionKey, options) {
+    return __privateGet(this, _http3).get(buildResourcePath("collections", collectionKey), {
+      params: {
+        status: options?.status ?? __privateGet(this, _defaults).status
+      }
+    });
+  }
+  /**
+   * Creates a collection.
+   *
+   * Sends an `Idempotency-Key` (required of suite bearers): a fresh one per
+   * call, or `options.idempotencyKey` to make your own retry safe.
+   */
+  async create(input, options) {
+    const response = await __privateGet(this, _http3).post(
+      buildResourcePath("collections"),
+      input,
+      idempotent(options)
+    );
+    return response.collection;
+  }
+  /**
+   * Updates a collection.
+   */
+  async update(collectionKey, input) {
+    const response = await __privateGet(this, _http3).patch(
+      buildResourcePath("collections", collectionKey),
+      input
+    );
+    return response.collection;
+  }
+  /**
+   * Deletes a collection.
+   */
+  async delete(collectionKey, options) {
+    return __privateGet(this, _http3).delete(
+      buildResourcePath("collections", collectionKey),
+      toDeleteBody(options)
+    );
+  }
+};
+_http3 = new WeakMap();
+_defaults = new WeakMap();
+
+// src/resources/comments.ts
+var _http4;
+var CommentsResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http4);
+    __privateSet(this, _http4, http);
+  }
+  /**
+   * Lists the site's threads, newest first, optionally on one record (an
+   * entry by `collection` + `slug`, or a `document`). `counts` covers both
+   * statuses whatever `status` filters.
+   *
+   * `GET /comments`.
+   */
+  async list(options) {
+    return __privateGet(this, _http4).get("/comments", {
+      // Named one by one: the route's query is strict, so a stray key would be a 400.
+      params: {
+        collection: options?.collection,
+        slug: options?.slug,
+        document: options?.document,
+        isChangeRequest: options?.isChangeRequest,
+        status: options?.status,
+        resolution: options?.resolution,
+        pageUrl: options?.pageUrl,
+        assignee: options?.assignee,
+        page: options?.page,
+        pageSize: options?.pageSize
+      }
+    });
+  }
+  /**
+   * Retrieves a thread and its comments, oldest first.
+   *
+   * `GET /comments/{id}`.
+   */
+  async get(id) {
+    return __privateGet(this, _http4).get(buildResourcePath("comments", id));
+  }
+  /**
+   * Opens a thread with its first comment. Anchors and proposed values name
+   * fields by key. Sends an `Idempotency-Key`. 404 for an unknown record, 422
+   * `INVALID_ANCHOR` / `INVALID_PROPOSED_VALUE` / `ASSIGNEE_NO_SEAT`, 429
+   * `RATE_LIMITED`.
+   *
+   * `POST /comments`.
+   *
+   * @example
+   * ```ts
+   * await zap.comments.create({
+   *   collection: 'blog',
+   *   slug: 'hello-world',
+   *   isChangeRequest: true,
+   *   body: 'Shorter title?',
+   *   proposedValues: [{ fieldKey: 'title', value: 'Hello' }],
+   * })
+   * ```
+   */
+  async create(input, options) {
+    return __privateGet(this, _http4).post("/comments", input, idempotent(options));
+  }
+  /**
+   * Changes a thread: `status` (resolve, reopen), a change request's
+   * `resolution`, the `isChangeRequest` flag, the assignee, or the first
+   * comment's text. 409 `STATUS_CONFLICT`, `INVALID_TRANSITION`,
+   * `HAS_PROPOSAL`; 422 `NOT_A_CHANGE_REQUEST`, `HAS_LINKED_TASKS` (turning
+   * the flag off while a Swarm task is linked).
+   *
+   * `PATCH /comments/{id}`.
+   */
+  async update(id, input) {
+    return __privateGet(this, _http4).patch(buildResourcePath("comments", id), input);
+  }
+  /**
+   * Replies on a thread. Sends an `Idempotency-Key`.
+   *
+   * `POST /comments/{id}/replies`.
+   */
+  async reply(id, input, options) {
+    return __privateGet(this, _http4).post(
+      buildResourcePath("comments", id, "replies"),
+      input,
+      idempotent(options)
+    );
+  }
+  /**
+   * «Aplicar al borrador»: writes an open change request's proposed values
+   * into the record's draft and resolves it as APPLIED. 409 `NO_PROPOSAL` /
+   * `NOT_OPEN`.
+   *
+   * `POST /comments/{id}/apply`.
+   */
+  async apply(id) {
+    return __privateGet(this, _http4).post(buildResourcePath("comments", id, "apply"));
+  }
+  /**
+   * Writes proposed values straight into the record's draft, recorded as a
+   * change request already resolved as APPLIED; nobody is notified. 403 when
+   * the site has live editing off. Sends an `Idempotency-Key`.
+   *
+   * `POST /comments/save-to-draft`.
+   */
+  async saveToDraft(input, options) {
+    return __privateGet(this, _http4).post(
+      buildResourcePath("comments", "save-to-draft"),
+      input,
+      idempotent(options)
+    );
+  }
+  /**
+   * What the site's suggestion client shows on one page: the viewer, whether
+   * live editing is on, the field types of the records tagged there and the
+   * page's open threads. `refs` are `data-zap-ref` values (`collection/slug`
+   * or `doc:key`); at most 20 are read.
+   *
+   * `GET /comments/on-page`. Answers only the site's own suggestion client.
+   */
+  async onPage(url, refs = []) {
+    return __privateGet(this, _http4).get(buildResourcePath("comments", "on-page"), {
+      params: { url, refs: refs.length > 0 ? refs.join(",") : void 0 }
+    });
+  }
+};
+_http4 = new WeakMap();
+
+// src/resources/document-versions.ts
+var _http5;
+var DocumentVersionsResource = class {
+  /** @internal */
+  constructor(http) {
+    __privateAdd(this, _http5);
+    __privateSet(this, _http5, http);
+  }
+  /**
+   * Lists a document's versions, newest first.
+   */
+  async list(documentKey) {
+    return __privateGet(this, _http5).get(
+      buildResourcePath("documents", documentKey, "versions")
+    );
+  }
+  /**
+   * Gets one version with its snapshot (values and SEO).
+   */
+  async get(documentKey, versionId) {
+    const response = await __privateGet(this, _http5).get(
+      buildResourcePath("documents", documentKey, "versions", versionId)
+    );
+    return response.version;
+  }
+  /**
+   * Opens a draft from the document's live state. Fails with `DUPLICATE_KEY`
+   * (409) when the document already has one.
+   */
+  async createDraft(documentKey, input) {
+    const response = await __privateGet(this, _http5).post(
+      buildResourcePath("documents", documentKey, "versions"),
+      input
+    );
+    return response.version;
+  }
+  /**
+   * Stages values on the open draft without touching the live document.
+   * Fails with `VALIDATION_ERROR` (400) when there is no open draft.
+   */
+  async updateDraft(documentKey, input) {
+    const response = await __privateGet(this, _http5).put(
+      buildResourcePath("documents", documentKey, "versions", "draft"),
+      input
+    );
+    return response.version;
+  }
+  /**
+   * Discards the open draft. Fails with `NOT_FOUND` (404) when there is none.
+   */
+  async discardDraft(documentKey) {
+    await __privateGet(this, _http5).delete(
+      buildResourcePath("documents", documentKey, "versions", "draft")
+    );
+  }
+  /**
+   * Publishes the open draft: its values go live and it becomes the
+   * document's published version. Fails with `NOT_FOUND` (404) when there is
+   * no draft.
+   */
+  async publishDraft(documentKey) {
+    const response = await __privateGet(this, _http5).post(
+      buildResourcePath("documents", documentKey, "versions", "draft", "publish")
+    );
+    return response.version;
+  }
+  /**
+   * Restores a past version over the live document and records the restore
+   * as a NEW published version (history is never rewritten). Refused (409)
+   * for a draft version, or while the document has an open draft.
+   */
+  async rollback(documentKey, versionId) {
+    const response = await __privateGet(this, _http5).post(
+      buildResourcePath("documents", documentKey, "versions", versionId, "rollback")
+    );
+    return response.version;
+  }
+};
+_http5 = new WeakMap();
+
+// src/resources/document-fields.ts
+var _http6;
+var DocumentFieldsResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http6);
+    __privateSet(this, _http6, http);
+  }
+  /**
+   * Lists all fields in a document.
+   */
+  async list(documentKey) {
+    const response = await __privateGet(this, _http6).get(
+      buildResourcePath("documents", documentKey, "fields")
+    );
+    return response.fields;
+  }
+  /**
+   * Gets a single field in a document.
+   */
+  async get(documentKey, fieldId) {
+    const response = await __privateGet(this, _http6).get(
+      buildResourcePath("documents", documentKey, "fields", fieldId)
+    );
+    return response.field;
+  }
+  /**
+   * Creates a field in a document.
+   *
+   * Sends an `Idempotency-Key` (required of suite bearers): a fresh one per
+   * call, or `options.idempotencyKey` to make your own retry safe.
+   */
+  async create(documentKey, input, options) {
+    const response = await __privateGet(this, _http6).post(
+      buildResourcePath("documents", documentKey, "fields"),
+      normalizeFieldInput(input),
+      idempotent(options)
+    );
+    return response.field;
+  }
+  /**
+   * Updates a field in a document.
+   */
+  async update(documentKey, fieldId, input) {
+    const response = await __privateGet(this, _http6).patch(
+      buildResourcePath("documents", documentKey, "fields", fieldId),
+      normalizeFieldInput(input)
+    );
+    return response.field;
+  }
+  /**
+   * Deletes a field from a document.
+   */
+  async delete(documentKey, fieldId) {
+    return __privateGet(this, _http6).delete(
+      buildResourcePath("documents", documentKey, "fields", fieldId)
+    );
+  }
+  /**
+   * Lists the document's archived (soft-deleted) fields, most recently
+   * deleted first. Their values are kept, which is what makes `restore` work.
+   *
+   * `GET /documents/{documentKey}/fields/deleted`. Secret key, or suite bearer
+   * with `zap:content:read`.
+   */
+  async listDeleted(documentKey) {
+    const response = await __privateGet(this, _http6).get(
+      buildResourcePath("documents", documentKey, "fields", "deleted")
+    );
+    return response.fields;
+  }
+  /**
+   * Brings an archived field back with every value it held, at the end of the
+   * root list (outside any section).
+   *
+   * `POST /documents/{documentKey}/fields/{fieldId}/restore`. Secret key, or
+   * suite bearer with `zap:schema:write` and the Zap ADMIN role.
+   */
+  async restore(documentKey, fieldId) {
+    const response = await __privateGet(this, _http6).post(
+      buildResourcePath("documents", documentKey, "fields", fieldId, "restore")
+    );
+    return response.field;
+  }
+  /**
+   * Reorders document fields.
+   */
+  async reorder(documentKey, fieldIds) {
+    return __privateGet(this, _http6).post(
+      buildResourcePath("documents", documentKey, "fields", "reorder"),
+      { fieldIds }
+    );
+  }
+};
+_http6 = new WeakMap();
+
+// src/resources/document-sections.ts
+var _http7;
+var DocumentSectionsResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http7);
+    __privateSet(this, _http7, http);
+  }
+  /**
+   * Lists all sections in a document.
+   */
+  async list(documentKey) {
+    const response = await __privateGet(this, _http7).get(
+      buildResourcePath("documents", documentKey, "sections")
+    );
+    return response.sections;
+  }
+  /**
+   * Gets a single section from a document.
+   */
+  async get(documentKey, sectionId) {
+    const response = await __privateGet(this, _http7).get(
+      buildResourcePath("documents", documentKey, "sections", sectionId)
+    );
+    return response.section;
+  }
+  /**
+   * Creates a section in a document.
+   *
+   * Sends an `Idempotency-Key` (required of suite bearers): a fresh one per
+   * call, or `options.idempotencyKey` to make your own retry safe.
+   */
+  async create(documentKey, input, options) {
+    const response = await __privateGet(this, _http7).post(
+      buildResourcePath("documents", documentKey, "sections"),
+      input,
+      idempotent(options)
+    );
+    return response.section;
+  }
+  /**
+   * Updates a section in a document.
+   */
+  async update(documentKey, sectionId, input) {
+    const response = await __privateGet(this, _http7).patch(
+      buildResourcePath("documents", documentKey, "sections", sectionId),
+      input
+    );
+    return response.section;
+  }
+  /**
+   * Deletes a section from a document.
+   */
+  async delete(documentKey, sectionId) {
+    return __privateGet(this, _http7).delete(
+      buildResourcePath("documents", documentKey, "sections", sectionId)
+    );
+  }
+};
+_http7 = new WeakMap();
+
+// src/resources/document-seo.ts
+var _http8;
+var DocumentSeoResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http8);
+    __privateSet(this, _http8, http);
+  }
+  /**
+   * Gets SEO metadata for a document.
+   */
+  async get(documentKey, options) {
+    const response = await __privateGet(this, _http8).get(
+      buildResourcePath("documents", documentKey, "seo"),
+      {
+        params: {
+          locale: options?.locale
+        }
+      }
+    );
+    return response.seo;
+  }
+  /**
+   * Updates SEO metadata for a document.
+   */
+  async update(documentKey, input) {
+    const response = await __privateGet(this, _http8).put(
+      buildResourcePath("documents", documentKey, "seo"),
+      input
+    );
+    return response.seo;
+  }
+};
+_http8 = new WeakMap();
+
+// src/resources/document-values.ts
+var _http9;
+var DocumentValuesResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http9);
+    __privateSet(this, _http9, http);
+  }
+  /**
+   * Gets all document values.
+   */
+  async get(documentKey) {
+    const response = await __privateGet(this, _http9).get(
+      buildResourcePath("documents", documentKey, "values")
+    );
+    return response.values;
+  }
+  /**
+   * Updates document values by field key.
+   */
+  async update(documentKey, values, options) {
+    const response = await __privateGet(this, _http9).put(
+      buildResourcePath("documents", documentKey, "values"),
+      {
+        locale: options?.locale,
+        values
+      }
+    );
+    return response.values;
+  }
+};
+_http9 = new WeakMap();
+
+// src/resources/documents.ts
+var _http10, _defaults2;
+var DocumentsResource = class {
+  /**
+   * @internal
+   */
+  constructor(http, defaults) {
+    __publicField(this, "fields");
+    __publicField(this, "sections");
+    __publicField(this, "values");
+    __publicField(this, "seo");
+    __privateAdd(this, _http10);
+    __privateAdd(this, _defaults2);
+    __privateSet(this, _http10, http);
+    __privateSet(this, _defaults2, defaults);
+    this.fields = new DocumentFieldsResource(http);
+    this.sections = new DocumentSectionsResource(http);
+    this.values = new DocumentValuesResource(http);
+    this.seo = new DocumentSeoResource(http);
+  }
+  /**
+   * Lists all documents available to the current API key.
+   */
+  async list(options) {
+    const merged = mergeRequestOptions(__privateGet(this, _defaults2), options);
+    return __privateGet(this, _http10).get(buildResourcePath("documents"), {
+      params: {
+        locale: merged.locale,
+        status: merged.status,
+        ...previewParam(merged)
+      }
+    });
+  }
+  /**
+   * Retrieves a single document by key.
+   */
+  async get(documentKey, options) {
+    const merged = mergeRequestOptions(__privateGet(this, _defaults2), options);
+    return __privateGet(this, _http10).get(buildResourcePath("documents", documentKey), {
+      params: {
+        locale: merged.locale,
+        status: merged.status,
+        fields: toArrayParam(merged.fields),
+        ...previewParam(merged)
+      }
+    });
+  }
+  /**
+   * Creates a document.
+   *
+   * Sends an `Idempotency-Key` (required of suite bearers): a fresh one per
+   * call, or `options.idempotencyKey` to make your own retry safe.
+   */
+  async create(input, options) {
+    const response = await __privateGet(this, _http10).post(
+      buildResourcePath("documents"),
+      input,
+      idempotent(options)
+    );
+    return response.document;
+  }
+  /**
+   * Updates a document.
+   */
+  async update(documentKey, input) {
+    const response = await __privateGet(this, _http10).patch(
+      buildResourcePath("documents", documentKey),
+      input
+    );
+    return response.document;
+  }
+  /**
+   * Deletes a document.
+   */
+  async delete(documentKey, options) {
+    return __privateGet(this, _http10).delete(
+      buildResourcePath("documents", documentKey),
+      toDeleteBody(options)
+    );
+  }
+  /**
+   * Publishes a document.
+   */
+  async publish(documentKey) {
+    const response = await __privateGet(this, _http10).post(
+      buildResourcePath("documents", documentKey, "publish")
+    );
+    return response.document;
+  }
+  /**
+   * Unpublishes a document.
+   */
+  async unpublish(documentKey) {
+    const response = await __privateGet(this, _http10).post(
+      buildResourcePath("documents", documentKey, "unpublish")
+    );
+    return response.document;
+  }
+};
+_http10 = new WeakMap();
+_defaults2 = new WeakMap();
+
+// src/resources/item-versions.ts
+var _http11;
+var ItemVersionsResource = class {
+  /** @internal */
+  constructor(http) {
+    __privateAdd(this, _http11);
+    __privateSet(this, _http11, http);
+  }
+  /**
+   * Lists an item's versions, newest first.
+   */
+  async list(collectionKey, slug) {
+    return __privateGet(this, _http11).get(
+      buildResourcePath("collections", collectionKey, "items", slug, "versions")
+    );
+  }
+  /**
+   * Gets one version with its snapshot (values, SEO and slugs).
+   */
+  async get(collectionKey, slug, versionId) {
+    const response = await __privateGet(this, _http11).get(
+      buildResourcePath("collections", collectionKey, "items", slug, "versions", versionId)
+    );
+    return response.version;
+  }
+  /**
+   * Opens a draft from the item's live state. Fails with `DUPLICATE_KEY` (409)
+   * when the item already has one.
+   */
+  async createDraft(collectionKey, slug, input) {
+    const response = await __privateGet(this, _http11).post(
+      buildResourcePath("collections", collectionKey, "items", slug, "versions"),
+      input
+    );
+    return response.version;
+  }
+  /**
+   * Stages values (and optionally a new slug) on the open draft without
+   * touching the live item. Fails with `VALIDATION_ERROR` (400) when there is
+   * no open draft.
+   */
+  async updateDraft(collectionKey, slug, input) {
+    const response = await __privateGet(this, _http11).put(
+      buildResourcePath("collections", collectionKey, "items", slug, "versions", "draft"),
+      input
+    );
+    return response.version;
+  }
+  /**
+   * Discards the open draft. Fails with `NOT_FOUND` (404) when there is none.
+   */
+  async discardDraft(collectionKey, slug) {
+    await __privateGet(this, _http11).delete(
+      buildResourcePath("collections", collectionKey, "items", slug, "versions", "draft")
+    );
+  }
+  /**
+   * Publishes the open draft: its values go live and it becomes the item's
+   * published version. Fails with `NOT_FOUND` (404) when there is no draft.
+   */
+  async publishDraft(collectionKey, slug) {
+    const response = await __privateGet(this, _http11).post(
+      buildResourcePath(
+        "collections",
+        collectionKey,
+        "items",
+        slug,
+        "versions",
+        "draft",
+        "publish"
+      )
+    );
+    return response.version;
+  }
+  /**
+   * Restores a past version over the live item and records the restore as a
+   * NEW published version (history is never rewritten). Refused (409) for a
+   * draft version, or while the item has an open draft.
+   */
+  async rollback(collectionKey, slug, versionId) {
+    const response = await __privateGet(this, _http11).post(
+      buildResourcePath(
+        "collections",
+        collectionKey,
+        "items",
+        slug,
+        "versions",
+        versionId,
+        "rollback"
+      )
+    );
+    return response.version;
+  }
+};
+_http11 = new WeakMap();
+
+// src/query-builder.ts
+var _http12, _defaults3, _collectionKey, _options;
+var _ItemQueryBuilder = class _ItemQueryBuilder {
+  /**
+   * @internal
+   */
+  constructor(http, defaults, collectionKey, options = {}) {
+    __privateAdd(this, _http12);
+    __privateAdd(this, _defaults3);
+    __privateAdd(this, _collectionKey);
+    __privateAdd(this, _options);
+    __privateSet(this, _http12, http);
+    __privateSet(this, _defaults3, defaults);
+    __privateSet(this, _collectionKey, collectionKey);
+    __privateSet(this, _options, options);
+  }
+  /**
+   * Overrides the request locale.
+   */
+  locale(locale) {
+    return this.clone({ locale });
+  }
+  /**
+   * Overrides the delivery status filter.
+   */
+  status(status) {
+    return this.clone({ status });
+  }
+  /**
+   * Adds or replaces a field filter.
+   */
+  filter(field, value) {
+    return this.clone({
+      filter: {
+        ...__privateGet(this, _options).filter ?? {},
+        [field]: value
+      }
+    });
+  }
+  /**
+   * Sets the sort expression.
+   */
+  sort(sort) {
+    return this.clone({ sort });
+  }
+  /**
+   * Selects a sparse set of content fields.
+   */
+  fields(fields) {
+    return this.clone({ fields });
+  }
+  /**
+   * Sets the current page.
+   */
+  page(page) {
+    return this.clone({ page });
+  }
+  /**
+   * Sets the page size.
+   */
+  pageSize(pageSize) {
+    return this.clone({ pageSize });
+  }
+  /**
+   * Executes the built request.
+   */
+  async get() {
+    const resource = new ItemsResource(__privateGet(this, _http12), __privateGet(this, _defaults3));
+    return resource.list(__privateGet(this, _collectionKey), __privateGet(this, _options));
+  }
+  /**
+   * Returns the current request options as a plain object.
+   */
+  toJSON() {
+    return {
+      ...__privateGet(this, _options),
+      filter: __privateGet(this, _options).filter ? { ...__privateGet(this, _options).filter } : void 0,
+      fields: __privateGet(this, _options).fields ? [...__privateGet(this, _options).fields] : void 0
+    };
+  }
+  clone(partial) {
+    return new _ItemQueryBuilder(__privateGet(this, _http12), __privateGet(this, _defaults3), __privateGet(this, _collectionKey), {
+      ...__privateGet(this, _options),
+      ...partial
+    });
+  }
+};
+_http12 = new WeakMap();
+_defaults3 = new WeakMap();
+_collectionKey = new WeakMap();
+_options = new WeakMap();
+var ItemQueryBuilder = _ItemQueryBuilder;
+
+// src/resources/item-seo.ts
+var _http13;
+var ItemSeoResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http13);
+    __privateSet(this, _http13, http);
+  }
+  /**
+   * Gets SEO metadata for an item.
+   */
+  async get(collectionKey, slug, options) {
+    const response = await __privateGet(this, _http13).get(
+      buildResourcePath("collections", collectionKey, "items", slug, "seo"),
+      {
+        params: {
+          locale: options?.locale
+        }
+      }
+    );
+    return response.seo;
+  }
+  /**
+   * Updates SEO metadata for an item.
+   */
+  async update(collectionKey, slug, input) {
+    const response = await __privateGet(this, _http13).patch(
+      buildResourcePath("collections", collectionKey, "items", slug, "seo"),
+      input
+    );
+    return response.seo;
+  }
+};
+_http13 = new WeakMap();
+
+// src/resources/items.ts
+var _http14, _defaults4;
+var ItemsResource = class {
+  /**
+   * @internal
+   */
+  constructor(http, defaults) {
+    __publicField(this, "seo");
+    __privateAdd(this, _http14);
+    __privateAdd(this, _defaults4);
+    __privateSet(this, _http14, http);
+    __privateSet(this, _defaults4, defaults);
+    this.seo = new ItemSeoResource(http);
+  }
+  /**
+   * Lists items in a collection.
+   */
+  async list(collectionKey, options) {
+    const merged = mergeRequestOptions(__privateGet(this, _defaults4), options);
+    return __privateGet(this, _http14).get(
+      buildResourcePath("collections", collectionKey, "items"),
+      {
+        params: {
+          locale: merged.locale,
+          status: merged.status,
+          fields: toArrayParam(merged.fields),
+          page: merged.page,
+          pageSize: merged.pageSize,
+          sort: merged.sort,
+          ...serializeFilters(merged.filter),
+          ...previewParam(merged)
+        }
+      }
+    );
+  }
+  /**
+   * Retrieves a single item by slug.
+   */
+  async get(collectionKey, slug, options) {
+    const merged = mergeRequestOptions(__privateGet(this, _defaults4), options);
+    return __privateGet(this, _http14).get(
+      buildResourcePath("collections", collectionKey, "items", slug),
+      {
+        params: {
+          locale: merged.locale,
+          status: merged.status,
+          fields: toArrayParam(merged.fields),
+          ...previewParam(merged)
+        }
+      }
+    );
+  }
+  /**
+   * Starts a lazy fluent query builder for a collection.
+   */
+  collection(collectionKey) {
+    return new ItemQueryBuilder(__privateGet(this, _http14), __privateGet(this, _defaults4), collectionKey);
+  }
+  /**
+   * Creates an item in a collection.
+   *
+   * Sends an `Idempotency-Key` (required of suite bearers): a fresh one per
+   * call, or `options.idempotencyKey` to make your own retry safe.
+   */
+  async create(collectionKey, input, options) {
+    const response = await __privateGet(this, _http14).post(
+      buildResourcePath("collections", collectionKey, "items"),
+      input,
+      idempotent(options)
+    );
+    return response.item;
+  }
+  /**
+   * Updates an item by slug.
+   */
+  async update(collectionKey, slug, input) {
+    const response = await __privateGet(this, _http14).patch(
+      buildResourcePath("collections", collectionKey, "items", slug),
+      input
+    );
+    return response.item;
+  }
+  /**
+   * Deletes an item by slug.
+   */
+  async delete(collectionKey, slug, options) {
+    return __privateGet(this, _http14).delete(
+      buildResourcePath("collections", collectionKey, "items", slug),
+      toDeleteBody(options)
+    );
+  }
+  /**
+   * Publishes an item by slug.
+   */
+  async publish(collectionKey, slug) {
+    const response = await __privateGet(this, _http14).post(
+      buildResourcePath("collections", collectionKey, "items", slug, "publish")
+    );
+    return response.item;
+  }
+  /**
+   * Unpublishes an item by slug.
+   */
+  async unpublish(collectionKey, slug) {
+    const response = await __privateGet(this, _http14).post(
+      buildResourcePath("collections", collectionKey, "items", slug, "unpublish")
+    );
+    return response.item;
+  }
+};
+_http14 = new WeakMap();
+_defaults4 = new WeakMap();
+
+// src/resources/media.ts
+function isBlobFile(file) {
+  return typeof Blob !== "undefined" && file instanceof Blob;
+}
+function toUploadBody(file) {
+  if (isBlobFile(file)) {
+    return file;
+  }
+  if (ArrayBuffer.isView(file)) {
+    const bytes = file.buffer instanceof ArrayBuffer ? file.buffer.slice(file.byteOffset, file.byteOffset + file.byteLength) : new Uint8Array(file.buffer, file.byteOffset, file.byteLength).slice().buffer;
+    return new Blob([bytes]);
+  }
+  return file;
+}
+function getUploadSize(file) {
+  if (isBlobFile(file)) {
+    return file.size;
+  }
+  if (ArrayBuffer.isView(file)) {
+    return file.byteLength;
+  }
+  return file instanceof ArrayBuffer ? file.byteLength : 0;
+}
+var _http15;
+var MediaResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http15);
+    __privateSet(this, _http15, http);
+  }
+  /**
+   * Lists media for the current site.
+   */
+  async list(params) {
+    return __privateGet(this, _http15).get(buildResourcePath("media"), {
+      params: {
+        search: params?.search,
+        page: params?.page,
+        pageSize: params?.pageSize,
+        sort: params?.sort,
+        type: params?.type,
+        status: params?.status,
+        usage: params?.usage
+      }
+    });
+  }
+  /**
+   * Gets a single media item.
+   */
+  async get(id) {
+    return __privateGet(this, _http15).get(buildResourcePath("media", id));
+  }
+  /**
+   * Updates media metadata.
+   */
+  async update(id, input) {
+    const response = await __privateGet(this, _http15).patch(
+      buildResourcePath("media", id),
+      input
+    );
+    return response.media;
+  }
+  /**
+   * Deletes media.
+   */
+  async delete(id) {
+    return __privateGet(this, _http15).delete(buildResourcePath("media", id));
+  }
+  /**
+   * Publishes media.
+   */
+  async publish(id) {
+    const response = await __privateGet(this, _http15).post(
+      buildResourcePath("media", id, "publish")
+    );
+    return response.media;
+  }
+  /**
+   * Unpublishes media.
+   */
+  async unpublish(id) {
+    const response = await __privateGet(this, _http15).post(
+      buildResourcePath("media", id, "unpublish")
+    );
+    return response.media;
+  }
+  /**
+   * Requests a presigned upload URL.
+   */
+  async createUploadUrl(input) {
+    return __privateGet(this, _http15).post(buildResourcePath("media", "upload-url"), input);
+  }
+  /**
+   * Confirms a completed upload.
+   */
+  async confirmUpload(input) {
+    const response = await __privateGet(this, _http15).post(
+      buildResourcePath("media", "confirm"),
+      input
+    );
+    return response.media;
+  }
+  /**
+   * Fetches a file from a URL into the media library, server-side (SSRF
+   * guarded, type allowlist, size ceiling). The file starts private (`DRAFT`):
+   * the answer carries a 15-minute `signedUrl` and no `url` until `publish`.
+   *
+   * `POST /media/from-url`. Secret key, or suite bearer with
+   * `zap:media:write`. Sends an `Idempotency-Key` (required of suite bearers;
+   * a retry with the same key replays the first answer without downloading
+   * again). Server-side only: the API's general CORS does not allow that
+   * header from a browser.
+   */
+  async fromUrl(input, options) {
+    return __privateGet(this, _http15).post(
+      buildResourcePath("media", "from-url"),
+      input,
+      idempotent(options)
+    );
+  }
+  /**
+   * Uploads media using the public presigned URL flow.
+   */
+  async upload(input) {
+    const upload = await this.createUploadUrl({
+      filename: input.filename,
+      contentType: input.contentType,
+      size: getUploadSize(input.file),
+      width: input.width,
+      height: input.height
+    });
+    await __privateGet(this, _http15).upload(upload.uploadUrl, toUploadBody(input.file), {
+      "Content-Type": input.contentType
+    });
+    const media = await this.confirmUpload({
+      mediaId: upload.mediaId,
+      key: upload.key,
+      filename: input.filename,
+      contentType: input.contentType,
+      size: getUploadSize(input.file),
+      width: input.width,
+      height: input.height
+    });
+    const alt = normalizeHeaderValue(input.alt);
+    const title = normalizeHeaderValue(input.title);
+    const description = normalizeHeaderValue(input.description);
+    if (!alt && !title && !description) {
+      return media;
+    }
+    return this.update(media.id, {
+      alt: alt ?? null,
+      title: title ?? null,
+      description: description ?? null
+    });
+  }
+};
+_http15 = new WeakMap();
+
+// src/resources/preview-tokens.ts
+var _http16;
+var PreviewTokensResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http16);
+    __privateSet(this, _http16, http);
+  }
+  /**
+   * Checks that the client's preview token is live AND was minted for the
+   * site `siteApiKey` belongs to, before trusting it (what a draft-mode route
+   * does before turning draft mode on). Rejects with `EelZapError` 401 for an
+   * unknown, revoked or expired token, 403 `WRONG_SITE` for another site's.
+   *
+   * `GET /preview/token`. The client's `apiKey` must be the `zpt_` token
+   * itself (any other bearer is 403); `siteApiKey` is one of the site's own
+   * API keys (public or secret), sent as `X-Zap-Site-Api-Key`.
+   *
+   * @example
+   * ```ts
+   * const zap = createClient({ apiKey: token })
+   * const { site, expiresAt } = await zap.previewTokens.validate(process.env.ZAP_PUBLIC_KEY!)
+   * ```
+   */
+  async validate(siteApiKey) {
+    return __privateGet(this, _http16).get("/preview/token", {
+      headers: { "X-Zap-Site-Api-Key": siteApiKey }
+    });
+  }
+};
+_http16 = new WeakMap();
+
+// src/resources/site.ts
+var _http17;
+var SiteResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http17);
+    __privateSet(this, _http17, http);
+  }
+  /**
+   * Resolves the current site from the authenticated API key.
+   */
+  async get() {
+    return __privateGet(this, _http17).get(buildResourcePath("site"));
+  }
+  /**
+   * Sets the site's URL and «Otros dominios» (`PATCH /site`), under the same
+   * rules as the site's settings page, and resolves to the updated site.
+   * Server code only: it needs a `secret_` key or an ADMIN suite credential.
+   */
+  async update(input) {
+    return __privateGet(this, _http17).patch(buildResourcePath("site"), input);
+  }
+};
+_http17 = new WeakMap();
+
+// src/resources/sites.ts
+var _http18;
+var SitesResource = class {
+  /**
+   * @internal
+   */
+  constructor(http) {
+    __privateAdd(this, _http18);
+    __privateSet(this, _http18, http);
+  }
+  /**
+   * Lists the workspace's sites, newest first. Each one's `key` or `id` is a
+   * valid `X-Eel-Site` for every other call; this is how a suite client
+   * learns which sites it can address.
+   *
+   * `GET /sites`. Suite bearer only (`eel_sk_` / `eel_at_`), `zap:sites:read`;
+   * needs no `X-Eel-Site`. Site keys are refused: a site key is one site.
+   */
+  async list() {
+    const response = await __privateGet(this, _http18).get("/sites");
+    return response.sites;
+  }
+};
+_http18 = new WeakMap();
+
+// src/client.ts
+var _http19, _defaults5, _config2;
+var EelZapClient = class {
+  constructor(config) {
+    __publicField(this, "site");
+    __publicField(this, "sites");
+    __publicField(this, "collections");
+    __publicField(this, "items");
+    __publicField(this, "documents");
+    __publicField(this, "media");
+    __publicField(this, "itemVersions");
+    __publicField(this, "documentVersions");
+    __publicField(this, "previewTokens");
+    __publicField(this, "comments");
+    __privateAdd(this, _http19);
+    __privateAdd(this, _defaults5);
+    __privateAdd(this, _config2);
+    if (!config.apiKey.trim()) {
+      throw new TypeError("apiKey is required.");
+    }
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new TypeError("A fetch implementation is required.");
+    }
+    __privateSet(this, _defaults5, {
+      locale: config.locale,
+      status: config.status,
+      // A preview token only ever reads previews; say so on the wire too.
+      preview: config.preview ?? (isPreviewToken(config.apiKey) || void 0)
+    });
+    __privateSet(this, _config2, {
+      apiKey: config.apiKey,
+      baseUrl: normalizeBaseUrl(config.baseUrl ?? "https://api.eelzap.com"),
+      pathPrefix: config.pathPrefix ?? "/v1",
+      defaultHeaders: config.defaultHeaders,
+      timeout: config.timeout ?? 3e4
+    });
+    __privateSet(this, _http19, new HttpClient({
+      apiKey: __privateGet(this, _config2).apiKey,
+      baseUrl: __privateGet(this, _config2).baseUrl,
+      pathPrefix: __privateGet(this, _config2).pathPrefix,
+      fetch: fetchImpl,
+      defaultHeaders: __privateGet(this, _config2).defaultHeaders,
+      timeout: __privateGet(this, _config2).timeout,
+      retry: resolveRetry(config.retry)
+    }));
+    this.site = new SiteResource(__privateGet(this, _http19));
+    this.sites = new SitesResource(__privateGet(this, _http19));
+    this.collections = new CollectionsResource(__privateGet(this, _http19), __privateGet(this, _defaults5));
+    this.items = new ItemsResource(__privateGet(this, _http19), __privateGet(this, _defaults5));
+    this.documents = new DocumentsResource(__privateGet(this, _http19), __privateGet(this, _defaults5));
+    this.media = new MediaResource(__privateGet(this, _http19));
+    this.itemVersions = new ItemVersionsResource(__privateGet(this, _http19));
+    this.documentVersions = new DocumentVersionsResource(__privateGet(this, _http19));
+    this.previewTokens = new PreviewTokensResource(__privateGet(this, _http19));
+    this.comments = new CommentsResource(__privateGet(this, _http19));
+  }
+  /**
+   * Returns a masked string representation safe for logs.
+   */
+  toString() {
+    return `EelZapClient(baseUrl=${__privateGet(this, _config2).baseUrl}, pathPrefix=${__privateGet(this, _config2).pathPrefix}, apiKey=${maskApiKey(__privateGet(this, _config2).apiKey)})`;
+  }
+};
+_http19 = new WeakMap();
+_defaults5 = new WeakMap();
+_config2 = new WeakMap();
+function createClient(config) {
+  return new EelZapClient(config);
+}
+
+// src/media-url.ts
+function getMediaUrl(media) {
+  return media?.url ?? media?.signedUrl ?? null;
+}
+
+// src/stega.ts
+var PREFIX = "\u2060\u200D\u200C\u200C\u200D\u200D\u200C\u2060";
+var MARKER_RE = /⁠‍‌‌‍‍‌⁠(?:[​‌][​‌‍⁠]{3})*/g;
+function hasStega(value) {
+  return typeof value === "string" && value.includes(PREFIX);
+}
+function cleanString(text) {
+  return text.includes(PREFIX) ? text.replace(MARKER_RE, "") : text;
+}
+function cleanStega(value) {
+  if (typeof value === "string") return cleanString(value);
+  if (Array.isArray(value)) return value.map((item) => cleanStega(item));
+  if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) out[key] = cleanStega(item);
+    return out;
+  }
+  return value;
+}
+
+// src/webhook.ts
+var WEBHOOK_SIGNATURE_HEADER = "X-Eel-Signature";
+var WEBHOOK_TIMESTAMP_HEADER = "X-Eel-Timestamp";
+var WEBHOOK_TOLERANCE_SECONDS = 300;
+var SECRET_PREFIX = "whsec_";
+var SIGNATURE_PREFIX = "v1=";
+var HMAC_SHA256_HEX_LENGTH = 64;
+function readHeader(headers, name) {
+  if (typeof headers.get === "function") {
+    return headers.get(name);
+  }
+  const wanted = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== wanted || value === void 0) continue;
+    if (typeof value === "string") return value;
+    return value.length === 1 ? value[0] ?? null : null;
+  }
+  return null;
+}
+function hexToBytes(value) {
+  if (value.length !== HMAC_SHA256_HEX_LENGTH || !/^[0-9a-f]+$/i.test(value)) {
+    return null;
+  }
+  const bytes = new Uint8Array(value.length / 2);
+  for (let index = 0; index < bytes.length; index += 1) {
+    bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16);
+  }
+  return bytes;
+}
+function getSubtle() {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error(
+      "verifyWebhookSignature needs WebCrypto (globalThis.crypto.subtle). Node 18 does not expose it by default: use Node 20+, or set globalThis.crypto to node:crypto's webcrypto at startup."
+    );
+  }
+  return subtle;
+}
+async function verifyWebhookSignature(payload, headers, secret, options = {}) {
+  if (typeof payload !== "string" || typeof secret !== "string" || !headers || typeof headers !== "object") {
+    return false;
+  }
+  const key = secret.startsWith(SECRET_PREFIX) ? secret.slice(SECRET_PREFIX.length) : secret;
+  if (!key) {
+    return false;
+  }
+  const timestamp = readHeader(headers, WEBHOOK_TIMESTAMP_HEADER)?.trim();
+  if (!timestamp || !/^\d+$/.test(timestamp)) {
+    return false;
+  }
+  const nowSeconds = (options.now ?? /* @__PURE__ */ new Date()).getTime() / 1e3;
+  const tolerance = options.toleranceSeconds ?? WEBHOOK_TOLERANCE_SECONDS;
+  if (!(Math.abs(nowSeconds - Number(timestamp)) <= tolerance)) {
+    return false;
+  }
+  const signature = readHeader(headers, WEBHOOK_SIGNATURE_HEADER)?.trim();
+  if (!signature?.startsWith(SIGNATURE_PREFIX)) {
+    return false;
+  }
+  const signatureBytes = hexToBytes(signature.slice(SIGNATURE_PREFIX.length));
+  if (!signatureBytes) {
+    return false;
+  }
+  const subtle = getSubtle();
+  const encoder = new TextEncoder();
+  const hmacKey = await subtle.importKey(
+    "raw",
+    encoder.encode(key),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["verify"]
+  );
+  return subtle.verify("HMAC", hmacKey, signatureBytes, encoder.encode(`${timestamp}.${payload}`));
+}
+var CHANGE_ACTIONS = /* @__PURE__ */ new Set([
+  "created",
+  "updated",
+  "draft_updated",
+  "published",
+  "unpublished",
+  "deleted",
+  "rolled_back",
+  "uploaded"
+]);
+function webhookChanges(payload) {
+  const match = /^zap\.(item|document|media)\.([a-z_]+)$/.exec(payload.type);
+  if (!match || !CHANGE_ACTIONS.has(match[2])) {
+    return [];
+  }
+  const type = match[1];
+  const action = match[2];
+  if (type === "item") {
+    const data2 = payload.data;
+    return (data2.items ?? []).map((item) => ({
+      type,
+      action,
+      id: item.id,
+      resourceKey: item.slug,
+      collectionKey: data2.collection.key,
+      siteKey: data2.site.key
+    }));
+  }
+  if (type === "document") {
+    const data2 = payload.data;
+    return (data2.documents ?? []).map((document) => ({
+      type,
+      action,
+      id: document.id,
+      resourceKey: document.key,
+      siteKey: data2.site.key
+    }));
+  }
+  const data = payload.data;
+  return (data.media ?? []).map((media) => ({
+    type,
+    action,
+    id: media.id,
+    resourceKey: media.id,
+    siteKey: data.site.key
+  }));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectionFieldsResource,
+  CollectionSectionsResource,
+  CollectionsResource,
+  CommentsResource,
+  DocumentFieldsResource,
+  DocumentSectionsResource,
+  DocumentSeoResource,
+  DocumentValuesResource,
+  DocumentVersionsResource,
+  DocumentsResource,
+  EelZapClient,
+  EelZapError,
+  EelZapNetworkError,
+  ItemQueryBuilder,
+  ItemSeoResource,
+  ItemVersionsResource,
+  ItemsResource,
+  MediaResource,
+  MemoryCacheAdapter,
+  PreviewTokensResource,
+  SiteResource,
+  SitesResource,
+  WEBHOOK_SIGNATURE_HEADER,
+  WEBHOOK_TIMESTAMP_HEADER,
+  WEBHOOK_TOLERANCE_SECONDS,
+  cachedFetch,
+  cleanStega,
+  createClient,
+  getMediaUrl,
+  hasStega,
+  isEelZapError,
+  verifyWebhookSignature,
+  webhookChanges
+});
+//# sourceMappingURL=index.cjs.map