@plenary/client 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,352 @@
+/** Configuration for {@link createClient}. */
+interface ClientConfig {
+    /** CMS origin, e.g. "https://cms.example.com". No trailing `/api/v1`. */
+    baseUrl: string;
+    /** Site to read from; sent as `?site_key=`. */
+    siteKey: string;
+    /** Public delivery API key; sent as the `X-API-KEY` header. */
+    apiKey: string;
+    /** Default locale, always sent as `?locale=` (per CONTENT_API.md). */
+    locale: string;
+    /** Optional fetch implementation (defaults to global `fetch`). */
+    fetch?: typeof fetch;
+}
+/** A content entry. `data` is generic so consumers can type their fields. */
+interface Entry<TData = Record<string, unknown>> {
+    id: string;
+    site_key: string;
+    model_key: string;
+    slug: string | null;
+    locale: string | null;
+    title: string | null;
+    status: string;
+    published_at: string | null;
+    publish_at: string | null;
+    unpublish_at: string | null;
+    created_at: string;
+    updated_at: string;
+    /**
+     * Content folder placement. `folder_id` is the containing folder (null at the
+     * model root); `path` is that folder's directory path ("/" at the root), and
+     * excludes the entry's own slug. Shared across an entry's translations. Route
+     * on both `path` and `slug` — see the Directory Path section of CONTENT_API.md.
+     */
+    folder_id: string | null;
+    path: string;
+    /** Field values keyed by field key; a `blocks` field holds a component tree. */
+    data: TData;
+}
+/** Comparison operators supported by `where:` and filter trees. */
+interface WhereCondition {
+    $eq?: unknown;
+    $ne?: unknown;
+    $lt?: unknown;
+    $lte?: unknown;
+    $gt?: unknown;
+    $gte?: unknown;
+    /** Value is in the set. */
+    $in?: unknown[];
+    /** Value is not in the set. */
+    $nin?: unknown[];
+    /** Case-sensitive substring/pattern match. */
+    $like?: string;
+    /** Case-insensitive substring/pattern match. */
+    $ilike?: string;
+    /** Whether the value is null. */
+    $is_null?: boolean;
+}
+/**
+ * A flat `where:` map: field path → a bare value (shorthand for `$eq`) or a
+ * condition object. Field paths for user fields are prefixed `data.`; intrinsic
+ * properties (`slug`, `status`, …) are not. AND-combined by the server.
+ */
+type Where = Record<string, unknown | WhereCondition>;
+/** A filter tree for the `filters` argument — supports `$and`/`$or` to any depth. */
+interface FilterTree {
+    where: Record<string, unknown>;
+}
+type SortDirection = "asc" | "desc";
+/** Sort spec: field path → direction. Applied left-to-right (insertion order). */
+type Sort = Record<string, SortDirection>;
+/**
+ * Hydration spec: reference field path → `"*"` (all fields) or an explicit list
+ * of fields to expand.
+ */
+type Hydrate = Record<string, "*" | string[]>;
+/** Options shared by every read. */
+interface ReadOptions {
+    /** Override the client's default locale for this call. */
+    locale?: string;
+    /** Override the client's site for this call. */
+    siteKey?: string;
+    /** Expand reference fields. */
+    hydrate?: Hydrate;
+    /** Return only these fields. Mutually exclusive with `exclude`. */
+    include?: string[];
+    /** Omit these fields. Mutually exclusive with `include`. */
+    exclude?: string[];
+}
+/** Options for {@link PlenaryClient.listEntries}. */
+interface ListOptions extends ReadOptions {
+    /** Flat AND filter. Mutually exclusive with `filters`. */
+    where?: Where;
+    /** Filter tree (for `$or`/`$and`). Mutually exclusive with `where`. */
+    filters?: FilterTree;
+    sort?: Sort;
+    /** Max results (server default 100, max 500). */
+    limit?: number;
+    offset?: number;
+    /** Ask for the total match count, surfaced as `total`. */
+    count?: boolean;
+}
+/** Result of a list read. `total` is present only when `count: true` was set. */
+interface ListResult<TData = Record<string, unknown>> {
+    items: Entry<TData>[];
+    total?: number;
+}
+/** Field types a form model may contain (server allow-list; see docs/FORMS.md). */
+type PublicFormFieldType = "text" | "number" | "boolean" | "date" | "time" | "datetime" | "email" | "url" | "phone" | "select" | "multi_select" | "tags" | "object" | "list" | "json";
+/**
+ * One field of a render-safe form definition. `settings`, `ui`, and `validation`
+ * are omitted by the server when empty rather than shipped as `{}`.
+ */
+interface PublicFormField {
+    key: string;
+    name: string;
+    type: PublicFormFieldType;
+    required: boolean;
+    settings?: Record<string, unknown>;
+    ui?: Record<string, unknown>;
+    validation?: Record<string, unknown>;
+}
+/**
+ * The render-safe form definition from `GET /api/v1/forms/{form_key}` — the one
+ * model-shaped thing a public delivery key may read. Never includes ids,
+ * timestamps, site assignments, private fields, or hidden fields.
+ */
+interface PublicFormDefinition {
+    key: string;
+    name: string;
+    description?: string;
+    fields: PublicFormField[];
+    /** Anti-spam time-trap token; when present, echo it back on submit as `ts`. */
+    ts?: string;
+}
+/** Options for {@link PlenaryClient.submitForm}. */
+interface FormSubmitOptions {
+    /** Override the client's site for this call. */
+    siteKey?: string;
+    /**
+     * Honeypot value — the reserved `website` field a rendered form keeps hidden.
+     * Send it verbatim (normally the empty string); a non-empty value marks the
+     * entry as spam server-side.
+     */
+    website?: string;
+    /** Time-trap token from {@link PublicFormDefinition.ts}, echoed back verbatim. */
+    ts?: string;
+}
+/** Acknowledgement returned by {@link PlenaryClient.submitForm}. */
+interface FormSubmitResult {
+    ok: boolean;
+    id?: string;
+}
+/** One generated image variant. `url` is empty until the variant is ready. */
+interface MediaVariant {
+    status: string;
+    url?: string;
+}
+/**
+ * A media item's detail, from `GET /api/v1/media/{media_id}`. URLs are
+ * installation-relative paths (e.g. `/media/{id}/original.png`).
+ */
+interface MediaDetail {
+    media_id: string;
+    media_type: string;
+    mime_type: string;
+    file_name: string;
+    label: string;
+    description: string;
+    original_url: string;
+    thumb_status?: string;
+    thumb_url?: string;
+    width?: number;
+    height?: number;
+    aspect_ratio?: number;
+    variants?: Record<string, MediaVariant>;
+}
+
+/** The content client returned by {@link createClient}. */
+interface PlenaryClient {
+    /** Fetch a singleton model's entry. */
+    getSingleton<TData = Record<string, unknown>>(modelKey: string, opts?: ReadOptions): Promise<Entry<TData>>;
+    /** Fetch one entry of a collection/page by slug or UUID. */
+    getEntry<TData = Record<string, unknown>>(modelKey: string, slugOrId: string, opts?: ReadOptions): Promise<Entry<TData>>;
+    /** List entries of a collection/page model. */
+    listEntries<TData = Record<string, unknown>>(modelKey: string, opts?: ListOptions): Promise<ListResult<TData>>;
+    /**
+     * Fetch a form's render-safe definition — the field list a renderer needs,
+     * readable with a public delivery key.
+     */
+    getForm(formKey: string): Promise<PublicFormDefinition>;
+    /** Submit a public form. */
+    submitForm(formKey: string, data: Record<string, unknown>, opts?: FormSubmitOptions): Promise<FormSubmitResult>;
+    /**
+     * Fetch a media item's detail (URLs + variants). Requires a key that may read
+     * media; a public delivery key cannot, so this is used in authoring/preview
+     * contexts or by sites configured with a media-capable key.
+     */
+    getMedia(mediaId: string): Promise<MediaDetail>;
+}
+declare function createClient(config: ClientConfig): PlenaryClient;
+
+/** Base context every request carries: which site and locale. */
+interface QueryBase {
+    siteKey: string;
+    locale: string;
+}
+/** Builds the query for a single-entry read (get / singleton). */
+declare function buildReadParams(base: QueryBase, opts?: ReadOptions): URLSearchParams;
+/** Builds the query for a list read, including filters, sort, and pagination. */
+declare function buildListParams(base: QueryBase, opts?: ListOptions): URLSearchParams;
+
+/** Base error for a non-2xx response from the CMS. */
+declare class PlenaryError extends Error {
+    readonly status: number;
+    /** The server's i18n error code (e.g. `entry_query_limit_exceeded`), if any. */
+    readonly code: string;
+    /** Interpolation variables the server attached to the code. */
+    readonly vars?: Record<string, unknown>;
+    constructor(status: number, code: string, vars?: Record<string, unknown>);
+}
+/** A 404 — model or entry not found (or hidden by a private model). */
+declare class PlenaryNotFoundError extends PlenaryError {
+    constructor(code: string, vars?: Record<string, unknown>);
+}
+/** A 400/422 — malformed query or invalid input. */
+declare class PlenaryValidationError extends PlenaryError {
+    constructor(status: number, code: string, vars?: Record<string, unknown>);
+}
+/** A 403 — the key may not read the requested site/resource. */
+declare class PlenaryForbiddenError extends PlenaryError {
+    constructor(code: string, vars?: Record<string, unknown>);
+}
+/** Builds the right error subclass from a failed response's status and body. */
+declare function errorFromResponse(status: number, body: unknown): PlenaryError;
+
+/**
+ * Webhook consumer helpers: the payload types Plenary POSTs (docs/WEBHOOKS.md)
+ * and framework-neutral verification/parsing. Plenary does not sign requests
+ * yet; verification is a shared-secret comparison against a header or query
+ * parameter. When HMAC signing ships, it slots in here without changing the
+ * call sites.
+ */
+/** The five entry lifecycle events a content-model webhook can subscribe to. */
+type EntryWebhookEvent = "entry.created" | "entry.updated" | "entry.published" | "entry.unpublished" | "entry.deleted";
+declare const ENTRY_WEBHOOK_EVENTS: readonly EntryWebhookEvent[];
+/** The event carried by the console's Test button. The body is otherwise an
+ * ordinary entry or form payload, built from the model's most recent entry. */
+declare const WEBHOOK_TEST_EVENT = "webhook.test";
+/** Who caused the event. `label` survives the actor's deletion. */
+interface WebhookActor {
+    type: "user" | "api_key" | "system";
+    id?: string;
+    label: string;
+}
+/** The entry's identity. Field selection never touches these. */
+interface WebhookEntryRef {
+    id: string;
+    site_key?: string;
+    locale?: string;
+    slug?: string;
+    /** Directory path of the entry's folder ("/" at the model root). Does NOT
+     * include the entry's own slug — join them to build a URL. */
+    path?: string;
+    status?: string;
+    created_at?: string;
+    updated_at?: string;
+    published_at?: string;
+}
+/** A form entry's identity: no slug, locale, path, or publish state. */
+interface WebhookFormEntryRef {
+    id: string;
+    site_key?: string;
+    status?: string;
+    created_at?: string;
+    source?: {
+        ip?: string;
+        user_agent?: string;
+        referer?: string;
+    };
+}
+/** Payload for every `entry.*` event (and entry-shaped `webhook.test`). */
+interface EntryWebhookPayload<TData = Record<string, unknown>> {
+    event: EntryWebhookEvent | typeof WEBHOOK_TEST_EVENT;
+    delivery_id: string;
+    occurred_at: string;
+    webhook: {
+        id: string;
+        name?: string;
+    };
+    model: {
+        id: string;
+        key?: string;
+    };
+    entry: WebhookEntryRef;
+    actor: WebhookActor;
+    /** Paths that differ from the previous revision. Always present; empty for
+     * `entry.created` and `entry.deleted`. */
+    changed: string[];
+    revision_id?: string;
+    /** Field values per the webhook's field selection; absent for "no field data". */
+    data?: TData;
+}
+/** Payload for `form.submitted` (and form-shaped `webhook.test`). */
+interface FormWebhookPayload<TData = Record<string, unknown>> {
+    event: "form.submitted" | typeof WEBHOOK_TEST_EVENT;
+    delivery_id: string;
+    occurred_at: string;
+    webhook: {
+        id: string;
+        name?: string;
+    };
+    form: {
+        id: string;
+        key?: string;
+    };
+    form_entry: WebhookFormEntryRef;
+    data?: TData;
+}
+type WebhookPayload = EntryWebhookPayload | FormWebhookPayload;
+declare function isEntryWebhookPayload(p: WebhookPayload): p is EntryWebhookPayload;
+declare function isFormWebhookPayload(p: WebhookPayload): p is FormWebhookPayload;
+/** A request that is not a valid webhook delivery. `status` is the HTTP status
+ * an endpoint should answer with — 4xx makes the delivery fail fast in the
+ * console's delivery log instead of being retried for seven hours. */
+declare class PlenaryWebhookError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** Constant-time comparison of a provided secret against the expected one. */
+declare function verifyWebhookSecret(provided: string | null | undefined, secret: string): boolean;
+/** Shape-checks a parsed JSON body and types it. Throws {@link PlenaryWebhookError}
+ * (400) for anything that is not a Plenary webhook payload. */
+declare function parseWebhookPayload(body: unknown): WebhookPayload;
+/** Options for {@link parseWebhookRequest}. */
+interface ParseWebhookOptions {
+    /** The shared secret configured on the webhook (as a secret header or query
+     * parameter in the console). */
+    secret: string;
+    /** Header the secret arrives in. Default `x-plenary-secret`. */
+    secretHeader?: string;
+    /** Query parameter checked when the header is absent. Default `secret`. */
+    secretQuery?: string;
+}
+/**
+ * Verifies and parses a webhook delivery from a Fetch-API `Request`:
+ * POST only, secret in the configured header or query parameter, JSON body of
+ * one of the two payload shapes. Throws {@link PlenaryWebhookError} with the
+ * status the endpoint should answer (405, 401, or 400).
+ */
+declare function parseWebhookRequest(request: Request, options: ParseWebhookOptions): Promise<WebhookPayload>;
+
+export { type ClientConfig, ENTRY_WEBHOOK_EVENTS, type Entry, type EntryWebhookEvent, type EntryWebhookPayload, type FilterTree, type FormSubmitOptions, type FormSubmitResult, type FormWebhookPayload, type Hydrate, type ListOptions, type ListResult, type MediaDetail, type MediaVariant, type ParseWebhookOptions, type PlenaryClient, PlenaryError, PlenaryForbiddenError, PlenaryNotFoundError, PlenaryValidationError, PlenaryWebhookError, type PublicFormDefinition, type PublicFormField, type PublicFormFieldType, type QueryBase, type ReadOptions, type Sort, type SortDirection, WEBHOOK_TEST_EVENT, type WebhookActor, type WebhookEntryRef, type WebhookFormEntryRef, type WebhookPayload, type Where, type WhereCondition, buildListParams, buildReadParams, createClient, errorFromResponse, isEntryWebhookPayload, isFormWebhookPayload, parseWebhookPayload, parseWebhookRequest, verifyWebhookSecret };

package/dist/index.js

@@ -0,0 +1,292 @@
+// src/query.ts
+var OPERATORS = /* @__PURE__ */ new Set([
+  "$eq",
+  "$ne",
+  "$lt",
+  "$lte",
+  "$gt",
+  "$gte",
+  "$in",
+  "$nin",
+  "$like",
+  "$ilike",
+  "$is_null"
+]);
+function isCondition(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((k) => OPERATORS.has(k));
+}
+function encodeOperatorValue(op, value) {
+  if (op === "$in" || op === "$nin") {
+    return Array.isArray(value) ? value.map(String).join(",") : String(value);
+  }
+  if (op === "$is_null") {
+    return String(Boolean(value));
+  }
+  return String(value);
+}
+function appendWhere(params, where) {
+  for (const [field, value] of Object.entries(where)) {
+    if (isCondition(value)) {
+      for (const [op, opValue] of Object.entries(value)) {
+        params.append(`where:${field}.${op}`, encodeOperatorValue(op, opValue));
+      }
+    } else {
+      params.append(`where:${field}`, String(value));
+    }
+  }
+}
+function appendSort(params, sort) {
+  for (const [field, dir] of Object.entries(sort)) {
+    params.append(`sort:${field}`, dir);
+  }
+}
+function appendHydrate(params, hydrate) {
+  for (const [field, spec] of Object.entries(hydrate)) {
+    params.append(`hydrate:${field}`, spec === "*" ? "*" : spec.join(","));
+  }
+}
+function appendCommon(params, base, opts) {
+  params.set("site_key", opts.siteKey ?? base.siteKey);
+  params.set("locale", opts.locale ?? base.locale);
+  if (opts.include && opts.exclude) {
+    throw new Error("plenary: `include` and `exclude` are mutually exclusive");
+  }
+  if (opts.include?.length) params.set("include", opts.include.join(","));
+  if (opts.exclude?.length) params.set("exclude", opts.exclude.join(","));
+  if (opts.hydrate) appendHydrate(params, opts.hydrate);
+}
+function buildReadParams(base, opts = {}) {
+  const params = new URLSearchParams();
+  appendCommon(params, base, opts);
+  return params;
+}
+function buildListParams(base, opts = {}) {
+  const params = new URLSearchParams();
+  appendCommon(params, base, opts);
+  if (opts.where && opts.filters) {
+    throw new Error("plenary: `where` and `filters` are mutually exclusive");
+  }
+  if (opts.filters) {
+    params.set("filters", JSON.stringify(opts.filters));
+  } else if (opts.where) {
+    appendWhere(params, opts.where);
+  }
+  if (opts.sort) appendSort(params, opts.sort);
+  if (opts.limit !== void 0) params.set("limit", String(opts.limit));
+  if (opts.offset !== void 0) params.set("offset", String(opts.offset));
+  if (opts.count) params.set("count", "true");
+  return params;
+}
+
+// src/errors.ts
+var PlenaryError = class extends Error {
+  status;
+  /** The server's i18n error code (e.g. `entry_query_limit_exceeded`), if any. */
+  code;
+  /** Interpolation variables the server attached to the code. */
+  vars;
+  constructor(status, code, vars) {
+    super(`Plenary request failed (${status}): ${code}`);
+    this.name = "PlenaryError";
+    this.status = status;
+    this.code = code;
+    this.vars = vars;
+  }
+};
+var PlenaryNotFoundError = class extends PlenaryError {
+  constructor(code, vars) {
+    super(404, code, vars);
+    this.name = "PlenaryNotFoundError";
+  }
+};
+var PlenaryValidationError = class extends PlenaryError {
+  constructor(status, code, vars) {
+    super(status, code, vars);
+    this.name = "PlenaryValidationError";
+  }
+};
+var PlenaryForbiddenError = class extends PlenaryError {
+  constructor(code, vars) {
+    super(403, code, vars);
+    this.name = "PlenaryForbiddenError";
+  }
+};
+function errorFromResponse(status, body) {
+  const parsed = body;
+  const code = parsed?.error?.code ?? `http_${status}`;
+  const vars = parsed?.error?.vars;
+  switch (status) {
+    case 404:
+      return new PlenaryNotFoundError(code, vars);
+    case 403:
+      return new PlenaryForbiddenError(code, vars);
+    case 400:
+    case 422:
+      return new PlenaryValidationError(status, code, vars);
+    default:
+      return new PlenaryError(status, code, vars);
+  }
+}
+
+// src/client.ts
+function joinUrl(baseUrl, path) {
+  return `${baseUrl.replace(/\/+$/, "")}${path}`;
+}
+function createClient(config) {
+  const base = { siteKey: config.siteKey, locale: config.locale };
+  const doFetch = config.fetch ?? globalThis.fetch;
+  async function request(method, path, params, body) {
+    const url = `${joinUrl(config.baseUrl, path)}?${params.toString()}`;
+    const headers = { "X-API-KEY": config.apiKey };
+    if (body !== void 0) headers["Content-Type"] = "application/json";
+    const response = await doFetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    const parsed = response.status === 204 ? null : await response.json().catch(() => null);
+    if (!response.ok) {
+      throw errorFromResponse(response.status, parsed);
+    }
+    return { data: parsed, response };
+  }
+  return {
+    async getSingleton(modelKey, opts = {}) {
+      const params = buildReadParams(base, opts);
+      const { data } = await request(
+        "GET",
+        `/api/v1/content/${encodeURIComponent(modelKey)}`,
+        params
+      );
+      return data;
+    },
+    async getEntry(modelKey, slugOrId, opts = {}) {
+      const params = buildReadParams(base, opts);
+      const { data } = await request(
+        "GET",
+        `/api/v1/content/${encodeURIComponent(modelKey)}/${encodeURIComponent(slugOrId)}`,
+        params
+      );
+      return data;
+    },
+    async listEntries(modelKey, opts = {}) {
+      const params = buildListParams(base, opts);
+      const { data, response } = await request(
+        "GET",
+        `/api/v1/content/${encodeURIComponent(modelKey)}`,
+        params
+      );
+      const result = { items: data };
+      const total = response.headers.get("X-Total-Count");
+      if (total !== null) result.total = Number(total);
+      return result;
+    },
+    async getForm(formKey) {
+      const { data } = await request(
+        "GET",
+        `/api/v1/forms/${encodeURIComponent(formKey)}`,
+        new URLSearchParams()
+      );
+      return data;
+    },
+    async submitForm(formKey, data, opts = {}) {
+      const params = new URLSearchParams();
+      params.set("site_key", opts.siteKey ?? base.siteKey);
+      const body = { data };
+      if (opts.website !== void 0) body.website = opts.website;
+      if (opts.ts !== void 0) body.ts = opts.ts;
+      const { data: result } = await request(
+        "POST",
+        `/api/v1/forms/${encodeURIComponent(formKey)}/entries`,
+        params,
+        body
+      );
+      return result;
+    },
+    async getMedia(mediaId) {
+      const { data } = await request(
+        "GET",
+        `/api/v1/media/${encodeURIComponent(mediaId)}`,
+        new URLSearchParams()
+      );
+      return data;
+    }
+  };
+}
+
+// src/webhook.ts
+var ENTRY_WEBHOOK_EVENTS = [
+  "entry.created",
+  "entry.updated",
+  "entry.published",
+  "entry.unpublished",
+  "entry.deleted"
+];
+var WEBHOOK_TEST_EVENT = "webhook.test";
+function isEntryWebhookPayload(p) {
+  return "entry" in p;
+}
+function isFormWebhookPayload(p) {
+  return "form_entry" in p;
+}
+var PlenaryWebhookError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "PlenaryWebhookError";
+    this.status = status;
+  }
+};
+function verifyWebhookSecret(provided, secret) {
+  if (typeof provided !== "string") return false;
+  const enc = new TextEncoder();
+  const a = enc.encode(provided);
+  const b = enc.encode(secret);
+  let diff = a.length ^ b.length;
+  const len = Math.max(a.length, b.length);
+  for (let i = 0; i < len; i++) diff |= (a[i] ?? 0) ^ (b[i] ?? 0);
+  return diff === 0;
+}
+function parseWebhookPayload(body) {
+  const p = body;
+  if (p === null || typeof p !== "object" || typeof p["event"] !== "string" || typeof p["delivery_id"] !== "string" || !("entry" in p || "form_entry" in p)) {
+    throw new PlenaryWebhookError(400, "Not a Plenary webhook payload");
+  }
+  return p;
+}
+async function parseWebhookRequest(request, options) {
+  if (request.method !== "POST") {
+    throw new PlenaryWebhookError(405, "Method not allowed");
+  }
+  const header = options.secretHeader ?? "x-plenary-secret";
+  const query = options.secretQuery ?? "secret";
+  const provided = request.headers.get(header) ?? new URL(request.url).searchParams.get(query);
+  if (!verifyWebhookSecret(provided, options.secret)) {
+    throw new PlenaryWebhookError(401, "Invalid webhook secret");
+  }
+  const body = await request.json().catch(() => {
+    throw new PlenaryWebhookError(400, "Body is not valid JSON");
+  });
+  return parseWebhookPayload(body);
+}
+export {
+  ENTRY_WEBHOOK_EVENTS,
+  PlenaryError,
+  PlenaryForbiddenError,
+  PlenaryNotFoundError,
+  PlenaryValidationError,
+  PlenaryWebhookError,
+  WEBHOOK_TEST_EVENT,
+  buildListParams,
+  buildReadParams,
+  createClient,
+  errorFromResponse,
+  isEntryWebhookPayload,
+  isFormWebhookPayload,
+  parseWebhookPayload,
+  parseWebhookRequest,
+  verifyWebhookSecret
+};
+//# sourceMappingURL=index.js.map