smartletter 0.0.0-stage → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,2925 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Resend: () => Smartletter,
+  Smartletter: () => Smartletter,
+  WebhookVerificationError: () => WebhookVerificationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/case.ts
+function toWire(value, tree) {
+  if (!tree || value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item) => toWire(item, tree));
+  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return value;
+  const out = {};
+  for (const [key, v] of Object.entries(value)) {
+    const node = tree[key];
+    out[node ? node.wire : key] = node ? toWire(v, node.items ?? node.props) : v;
+  }
+  return out;
+}
+
+// src/client.ts
+var UNRESOLVED_MESSAGE = "Unable to fetch data. The request could not be resolved.";
+var DEFAULT_BASE_URL = "https://api.smartletter.ai";
+function env(name) {
+  return typeof process !== "undefined" ? process.env?.[name] || void 0 : void 0;
+}
+function camel(snake) {
+  return snake.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function applicationError(message, statusCode) {
+  return { name: "application_error", message, statusCode };
+}
+function isEmptyObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+var Client = class {
+  key;
+  baseUrl;
+  userAgent;
+  constructor(key, options = {}) {
+    const resendKey = env("RESEND_API_KEY");
+    const resolved = key || env("SMARTLETTER_API_KEY") || (resendKey && /^(sl_|re_)/.test(resendKey) ? resendKey : void 0);
+    if (!resolved) {
+      throw new Error(
+        'Missing API key. Pass it to the constructor `new Smartletter("sl_123")` or set SMARTLETTER_API_KEY.'
+      );
+    }
+    if (resolved.startsWith("re_")) {
+      throw new Error("This is a Resend key (re_\u2026). Create a Smartletter key (sl_\u2026) in Settings \u2192 API keys.");
+    }
+    this.key = resolved;
+    this.baseUrl = (options.baseUrl || env("SMARTLETTER_BASE_URL") || DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.userAgent = options.userAgent ?? `smartletter-node/${"1.1.0"}`;
+  }
+  async call(op, args, options = {}) {
+    const headers = new Headers(options.headers);
+    headers.set("Authorization", `Bearer ${this.key}`);
+    headers.set("User-Agent", this.userAgent);
+    if (options.idempotencyKey) headers.set("Idempotency-Key", options.idempotencyKey);
+    let path = op.path;
+    let rest = args;
+    if (op.pathParams.length > 0 && !Array.isArray(args)) {
+      const copy = { ...args ?? {} };
+      for (const wireName of op.pathParams) {
+        const name = camel(wireName);
+        const value = copy[name] ?? copy[wireName];
+        if (value === void 0 || value === null || value === "") {
+          return {
+            data: null,
+            error: { name: "missing_required_field", statusCode: null, message: `Missing \`${name}\` field.` },
+            headers: null
+          };
+        }
+        path = path.replace(`{${wireName}}`, encodeURIComponent(String(value)));
+        delete copy[name];
+        delete copy[wireName];
+      }
+      rest = copy;
+    }
+    let url = `${this.baseUrl}${path}`;
+    let body;
+    if (op.rawBody) {
+      body = args;
+      if (body !== void 0) headers.set("Content-Type", "application/octet-stream");
+    } else if (op.method === "GET") {
+      const params = new URLSearchParams();
+      const wire = toWire(rest, op.query) ?? {};
+      for (const [k, v] of Object.entries(wire)) {
+        if (v === void 0 || v === null) continue;
+        params.set(k, String(v));
+      }
+      const qs = params.toString();
+      if (qs) url += `?${qs}`;
+    } else if (rest !== void 0 && !isEmptyObject(rest)) {
+      const wire = op.bodyIsArray && Array.isArray(rest) ? rest.map((i) => toWire(i, op.body)) : toWire(rest, op.body);
+      body = JSON.stringify(wire);
+      headers.set("Content-Type", "application/json");
+    }
+    const unresolved = {
+      data: null,
+      error: applicationError(UNRESOLVED_MESSAGE, null),
+      headers: null
+    };
+    let response;
+    try {
+      response = await fetch(url, { method: op.method, headers, body, signal: options.signal });
+    } catch {
+      return unresolved;
+    }
+    const responseHeaders = Object.fromEntries(response.headers);
+    if (!response.ok) {
+      let text2;
+      try {
+        text2 = await response.text();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : response.statusText;
+        return { data: null, error: applicationError(message, response.status), headers: responseHeaders };
+      }
+      try {
+        return { data: null, error: JSON.parse(text2), headers: responseHeaders };
+      } catch {
+        return {
+          data: null,
+          error: applicationError(
+            "Internal server error. We are unable to process your request right now, please try again later.",
+            response.status
+          ),
+          headers: responseHeaders
+        };
+      }
+    }
+    let text;
+    try {
+      text = await response.text();
+    } catch {
+      return unresolved;
+    }
+    if (op.responseType === "text") return { data: text, error: null, headers: responseHeaders };
+    if (text === "") return { data: null, error: null, headers: responseHeaders };
+    try {
+      return { data: JSON.parse(text), error: null, headers: responseHeaders };
+    } catch {
+      return { ...unresolved, headers: responseHeaders };
+    }
+  }
+};
+
+// src/generated/operations.ts
+var OPERATIONS = {
+  "emails.send": {
+    id: "emails.send",
+    method: "POST",
+    path: "/emails",
+    pathParams: [],
+    paginated: false,
+    idempotent: true,
+    body: {
+      from: {
+        wire: "from"
+      },
+      to: {
+        wire: "to"
+      },
+      subject: {
+        wire: "subject"
+      },
+      template: {
+        wire: "template",
+        props: {
+          id: {
+            wire: "id"
+          },
+          variables: {
+            wire: "variables"
+          }
+        }
+      },
+      html: {
+        wire: "html"
+      },
+      text: {
+        wire: "text"
+      },
+      cc: {
+        wire: "cc"
+      },
+      bcc: {
+        wire: "bcc"
+      },
+      replyTo: {
+        wire: "reply_to"
+      },
+      headers: {
+        wire: "headers"
+      },
+      tags: {
+        wire: "tags",
+        items: {
+          name: {
+            wire: "name"
+          },
+          value: {
+            wire: "value"
+          }
+        }
+      },
+      scheduledAt: {
+        wire: "scheduled_at"
+      },
+      topicId: {
+        wire: "topic_id"
+      },
+      attachments: {
+        wire: "attachments",
+        items: {
+          content: {
+            wire: "content"
+          },
+          path: {
+            wire: "path"
+          },
+          filename: {
+            wire: "filename"
+          },
+          contentType: {
+            wire: "content_type"
+          },
+          contentId: {
+            wire: "content_id"
+          }
+        }
+      }
+    }
+  },
+  "batch.send": {
+    id: "batch.send",
+    method: "POST",
+    path: "/emails/batch",
+    pathParams: [],
+    paginated: false,
+    idempotent: true,
+    bodyIsArray: true,
+    body: {
+      from: {
+        wire: "from"
+      },
+      to: {
+        wire: "to"
+      },
+      subject: {
+        wire: "subject"
+      },
+      template: {
+        wire: "template",
+        props: {
+          id: {
+            wire: "id"
+          },
+          variables: {
+            wire: "variables"
+          }
+        }
+      },
+      html: {
+        wire: "html"
+      },
+      text: {
+        wire: "text"
+      },
+      cc: {
+        wire: "cc"
+      },
+      bcc: {
+        wire: "bcc"
+      },
+      replyTo: {
+        wire: "reply_to"
+      },
+      headers: {
+        wire: "headers"
+      },
+      tags: {
+        wire: "tags",
+        items: {
+          name: {
+            wire: "name"
+          },
+          value: {
+            wire: "value"
+          }
+        }
+      },
+      scheduledAt: {
+        wire: "scheduled_at"
+      },
+      topicId: {
+        wire: "topic_id"
+      }
+    }
+  },
+  "emails.list": {
+    id: "emails.list",
+    method: "GET",
+    path: "/emails",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "emails.get": {
+    id: "emails.get",
+    method: "GET",
+    path: "/emails/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "emails.update": {
+    id: "emails.update",
+    method: "PATCH",
+    path: "/emails/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      scheduledAt: {
+        wire: "scheduled_at"
+      }
+    }
+  },
+  "emails.cancel": {
+    id: "emails.cancel",
+    method: "POST",
+    path: "/emails/{id}/cancel",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "templates.create": {
+    id: "templates.create",
+    method: "POST",
+    path: "/templates",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      alias: {
+        wire: "alias"
+      },
+      from: {
+        wire: "from"
+      },
+      subject: {
+        wire: "subject"
+      },
+      replyTo: {
+        wire: "reply_to"
+      },
+      html: {
+        wire: "html"
+      },
+      text: {
+        wire: "text"
+      },
+      variables: {
+        wire: "variables",
+        items: {
+          key: {
+            wire: "key"
+          },
+          type: {
+            wire: "type"
+          },
+          fallbackValue: {
+            wire: "fallback_value"
+          },
+          required: {
+            wire: "required"
+          }
+        }
+      }
+    }
+  },
+  "templates.list": {
+    id: "templates.list",
+    method: "GET",
+    path: "/templates",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "templates.get": {
+    id: "templates.get",
+    method: "GET",
+    path: "/templates/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "templates.update": {
+    id: "templates.update",
+    method: "PATCH",
+    path: "/templates/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      alias: {
+        wire: "alias"
+      },
+      from: {
+        wire: "from"
+      },
+      subject: {
+        wire: "subject"
+      },
+      replyTo: {
+        wire: "reply_to"
+      },
+      html: {
+        wire: "html"
+      },
+      text: {
+        wire: "text"
+      },
+      variables: {
+        wire: "variables",
+        items: {
+          key: {
+            wire: "key"
+          },
+          type: {
+            wire: "type"
+          },
+          fallbackValue: {
+            wire: "fallback_value"
+          },
+          required: {
+            wire: "required"
+          }
+        }
+      },
+      changeNote: {
+        wire: "change_note"
+      }
+    }
+  },
+  "templates.remove": {
+    id: "templates.remove",
+    method: "DELETE",
+    path: "/templates/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "templates.publish": {
+    id: "templates.publish",
+    method: "POST",
+    path: "/templates/{id}/publish",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      versionId: {
+        wire: "version_id"
+      }
+    }
+  },
+  "templates.duplicate": {
+    id: "templates.duplicate",
+    method: "POST",
+    path: "/templates/{id}/duplicate",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "templates.versions": {
+    id: "templates.versions",
+    method: "GET",
+    path: "/templates/{id}/versions",
+    pathParams: ["id"],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "newsletters.list": {
+    id: "newsletters.list",
+    method: "GET",
+    path: "/newsletters",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      },
+      status: {
+        wire: "status"
+      }
+    }
+  },
+  "newsletters.create": {
+    id: "newsletters.create",
+    method: "POST",
+    path: "/newsletters",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      subject: {
+        wire: "subject"
+      },
+      preheader: {
+        wire: "preheader"
+      },
+      segmentId: {
+        wire: "segment_id"
+      },
+      topicId: {
+        wire: "topic_id"
+      },
+      markdown: {
+        wire: "markdown"
+      },
+      html: {
+        wire: "html"
+      },
+      blocks: {
+        wire: "blocks",
+        items: {
+          kind: {
+            wire: "kind"
+          },
+          level: {
+            wire: "level"
+          },
+          text: {
+            wire: "text"
+          },
+          ordered: {
+            wire: "ordered"
+          },
+          items: {
+            wire: "items"
+          },
+          url: {
+            wire: "url"
+          },
+          alt: {
+            wire: "alt"
+          },
+          label: {
+            wire: "label"
+          },
+          title: {
+            wire: "title"
+          },
+          imageUrl: {
+            wire: "imageUrl"
+          },
+          price: {
+            wire: "price"
+          },
+          description: {
+            wire: "description"
+          },
+          ctaLabel: {
+            wire: "ctaLabel"
+          },
+          html: {
+            wire: "html"
+          },
+          columns: {
+            wire: "columns"
+          }
+        }
+      },
+      audienceFilterId: {
+        wire: "audience_filter_id"
+      },
+      abTest: {
+        wire: "ab_test",
+        props: {
+          variants: {
+            wire: "variants",
+            items: {
+              subject: {
+                wire: "subject"
+              },
+              preheader: {
+                wire: "preheader"
+              }
+            }
+          },
+          samplePct: {
+            wire: "sample_pct"
+          },
+          metric: {
+            wire: "metric"
+          },
+          waitHours: {
+            wire: "wait_hours"
+          },
+          winnerMode: {
+            wire: "winner_mode"
+          }
+        }
+      }
+    }
+  },
+  "newsletters.get": {
+    id: "newsletters.get",
+    method: "GET",
+    path: "/newsletters/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.update": {
+    id: "newsletters.update",
+    method: "PATCH",
+    path: "/newsletters/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      subject: {
+        wire: "subject"
+      },
+      preheader: {
+        wire: "preheader"
+      },
+      topicId: {
+        wire: "topic_id"
+      },
+      markdown: {
+        wire: "markdown"
+      },
+      html: {
+        wire: "html"
+      },
+      blocks: {
+        wire: "blocks",
+        items: {
+          kind: {
+            wire: "kind"
+          },
+          level: {
+            wire: "level"
+          },
+          text: {
+            wire: "text"
+          },
+          ordered: {
+            wire: "ordered"
+          },
+          items: {
+            wire: "items"
+          },
+          url: {
+            wire: "url"
+          },
+          alt: {
+            wire: "alt"
+          },
+          label: {
+            wire: "label"
+          },
+          title: {
+            wire: "title"
+          },
+          imageUrl: {
+            wire: "imageUrl"
+          },
+          price: {
+            wire: "price"
+          },
+          description: {
+            wire: "description"
+          },
+          ctaLabel: {
+            wire: "ctaLabel"
+          },
+          html: {
+            wire: "html"
+          },
+          columns: {
+            wire: "columns"
+          }
+        }
+      },
+      audienceFilterId: {
+        wire: "audience_filter_id"
+      },
+      abTest: {
+        wire: "ab_test",
+        props: {
+          variants: {
+            wire: "variants",
+            items: {
+              subject: {
+                wire: "subject"
+              },
+              preheader: {
+                wire: "preheader"
+              }
+            }
+          },
+          samplePct: {
+            wire: "sample_pct"
+          },
+          metric: {
+            wire: "metric"
+          },
+          waitHours: {
+            wire: "wait_hours"
+          },
+          winnerMode: {
+            wire: "winner_mode"
+          }
+        }
+      }
+    }
+  },
+  "newsletters.remove": {
+    id: "newsletters.remove",
+    method: "DELETE",
+    path: "/newsletters/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.duplicate": {
+    id: "newsletters.duplicate",
+    method: "POST",
+    path: "/newsletters/{id}/duplicate",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.review": {
+    id: "newsletters.review",
+    method: "GET",
+    path: "/newsletters/{id}/review",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.test": {
+    id: "newsletters.test",
+    method: "POST",
+    path: "/newsletters/{id}/test",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.send": {
+    id: "newsletters.send",
+    method: "POST",
+    path: "/newsletters/{id}/send",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: true,
+    body: {
+      audienceLimit: {
+        wire: "audience_limit"
+      }
+    }
+  },
+  "newsletters.schedule": {
+    id: "newsletters.schedule",
+    method: "POST",
+    path: "/newsletters/{id}/schedule",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: true,
+    body: {
+      scheduledAt: {
+        wire: "scheduled_at"
+      },
+      audienceLimit: {
+        wire: "audience_limit"
+      }
+    }
+  },
+  "newsletters.unschedule": {
+    id: "newsletters.unschedule",
+    method: "POST",
+    path: "/newsletters/{id}/unschedule",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.pause": {
+    id: "newsletters.pause",
+    method: "POST",
+    path: "/newsletters/{id}/pause",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.resume": {
+    id: "newsletters.resume",
+    method: "POST",
+    path: "/newsletters/{id}/resume",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.sendMore": {
+    id: "newsletters.sendMore",
+    method: "POST",
+    path: "/newsletters/{id}/send-more",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: true,
+    body: {
+      count: {
+        wire: "count"
+      }
+    }
+  },
+  "newsletters.report": {
+    id: "newsletters.report",
+    method: "GET",
+    path: "/newsletters/{id}/report",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "newsletters.abWinner": {
+    id: "newsletters.abWinner",
+    method: "POST",
+    path: "/newsletters/{id}/ab-winner",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      variant: {
+        wire: "variant"
+      }
+    }
+  },
+  "contacts.list": {
+    id: "contacts.list",
+    method: "GET",
+    path: "/contacts",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      },
+      segmentId: {
+        wire: "segment_id"
+      },
+      status: {
+        wire: "status"
+      },
+      search: {
+        wire: "search"
+      },
+      tag: {
+        wire: "tag"
+      }
+    }
+  },
+  "contacts.create": {
+    id: "contacts.create",
+    method: "POST",
+    path: "/contacts",
+    pathParams: [],
+    paginated: false,
+    idempotent: true,
+    body: {
+      email: {
+        wire: "email"
+      },
+      segmentId: {
+        wire: "segment_id"
+      },
+      name: {
+        wire: "name"
+      },
+      firstName: {
+        wire: "first_name"
+      },
+      lastName: {
+        wire: "last_name"
+      },
+      language: {
+        wire: "language"
+      },
+      customFields: {
+        wire: "custom_fields"
+      },
+      tags: {
+        wire: "tags"
+      }
+    }
+  },
+  "contacts.import": {
+    id: "contacts.import",
+    method: "POST",
+    path: "/contacts/import",
+    pathParams: [],
+    paginated: false,
+    idempotent: true,
+    body: {
+      segmentId: {
+        wire: "segment_id"
+      },
+      consent: {
+        wire: "consent"
+      },
+      contacts: {
+        wire: "contacts",
+        items: {
+          email: {
+            wire: "email"
+          },
+          name: {
+            wire: "name"
+          },
+          firstName: {
+            wire: "first_name"
+          },
+          lastName: {
+            wire: "last_name"
+          },
+          language: {
+            wire: "language"
+          },
+          customFields: {
+            wire: "custom_fields"
+          },
+          openRate: {
+            wire: "open_rate"
+          },
+          clickRate: {
+            wire: "click_rate"
+          },
+          lastActivityAt: {
+            wire: "last_activity_at"
+          },
+          tags: {
+            wire: "tags"
+          },
+          status: {
+            wire: "status"
+          },
+          unsubscribedAt: {
+            wire: "unsubscribed_at"
+          }
+        }
+      }
+    }
+  },
+  "contacts.export": {
+    id: "contacts.export",
+    method: "GET",
+    path: "/contacts/export",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    query: {
+      segmentId: {
+        wire: "segment_id"
+      },
+      status: {
+        wire: "status"
+      }
+    },
+    responseType: "text"
+  },
+  "contacts.get": {
+    id: "contacts.get",
+    method: "GET",
+    path: "/contacts/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "contacts.unsubscribe": {
+    id: "contacts.unsubscribe",
+    method: "POST",
+    path: "/contacts/{id}/unsubscribe",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "contacts.reactivate": {
+    id: "contacts.reactivate",
+    method: "POST",
+    path: "/contacts/{id}/reactivate",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "contacts.remove": {
+    id: "contacts.remove",
+    method: "DELETE",
+    path: "/contacts/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "contacts.update": {
+    id: "contacts.update",
+    method: "PATCH",
+    path: "/contacts/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      firstName: {
+        wire: "first_name"
+      },
+      lastName: {
+        wire: "last_name"
+      },
+      name: {
+        wire: "name"
+      },
+      language: {
+        wire: "language"
+      },
+      customFields: {
+        wire: "custom_fields"
+      },
+      tags: {
+        wire: "tags"
+      },
+      addTags: {
+        wire: "add_tags"
+      },
+      removeTags: {
+        wire: "remove_tags"
+      }
+    }
+  },
+  "contactFields.list": {
+    id: "contactFields.list",
+    method: "GET",
+    path: "/contact-fields",
+    pathParams: [],
+    paginated: false,
+    idempotent: false
+  },
+  "contactFields.create": {
+    id: "contactFields.create",
+    method: "POST",
+    path: "/contact-fields",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      key: {
+        wire: "key"
+      },
+      label: {
+        wire: "label"
+      },
+      type: {
+        wire: "type"
+      },
+      options: {
+        wire: "options"
+      },
+      defaultValue: {
+        wire: "default_value"
+      },
+      inSignup: {
+        wire: "in_signup"
+      }
+    }
+  },
+  "contactFields.update": {
+    id: "contactFields.update",
+    method: "PATCH",
+    path: "/contact-fields/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      label: {
+        wire: "label"
+      },
+      options: {
+        wire: "options"
+      },
+      defaultValue: {
+        wire: "default_value"
+      },
+      inSignup: {
+        wire: "in_signup"
+      },
+      position: {
+        wire: "position"
+      }
+    }
+  },
+  "contactFields.remove": {
+    id: "contactFields.remove",
+    method: "DELETE",
+    path: "/contact-fields/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "events.send": {
+    id: "events.send",
+    method: "POST",
+    path: "/events",
+    pathParams: [],
+    paginated: false,
+    idempotent: true,
+    body: {
+      email: {
+        wire: "email"
+      },
+      contactId: {
+        wire: "contact_id"
+      },
+      event: {
+        wire: "event"
+      },
+      properties: {
+        wire: "properties"
+      },
+      occurredAt: {
+        wire: "occurred_at"
+      },
+      createContact: {
+        wire: "create_contact"
+      },
+      segmentId: {
+        wire: "segment_id"
+      }
+    }
+  },
+  "audienceFilters.list": {
+    id: "audienceFilters.list",
+    method: "GET",
+    path: "/audience-filters",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "audienceFilters.create": {
+    id: "audienceFilters.create",
+    method: "POST",
+    path: "/audience-filters",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      description: {
+        wire: "description"
+      },
+      rules: {
+        wire: "rules"
+      }
+    }
+  },
+  "audienceFilters.get": {
+    id: "audienceFilters.get",
+    method: "GET",
+    path: "/audience-filters/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "audienceFilters.update": {
+    id: "audienceFilters.update",
+    method: "PATCH",
+    path: "/audience-filters/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      description: {
+        wire: "description"
+      },
+      rules: {
+        wire: "rules"
+      }
+    }
+  },
+  "audienceFilters.remove": {
+    id: "audienceFilters.remove",
+    method: "DELETE",
+    path: "/audience-filters/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "audienceFilters.count": {
+    id: "audienceFilters.count",
+    method: "POST",
+    path: "/audience-filters/count",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      filterId: {
+        wire: "filter_id"
+      },
+      rules: {
+        wire: "rules"
+      },
+      segmentId: {
+        wire: "segment_id"
+      }
+    }
+  },
+  "signups.create": {
+    id: "signups.create",
+    method: "POST",
+    path: "/signups",
+    pathParams: [],
+    paginated: false,
+    idempotent: true,
+    body: {
+      email: {
+        wire: "email"
+      },
+      name: {
+        wire: "name"
+      },
+      firstName: {
+        wire: "first_name"
+      },
+      segmentId: {
+        wire: "segment_id"
+      },
+      language: {
+        wire: "language"
+      },
+      sourceUrl: {
+        wire: "source_url"
+      },
+      customFields: {
+        wire: "custom_fields"
+      }
+    }
+  },
+  "segments.list": {
+    id: "segments.list",
+    method: "GET",
+    path: "/segments",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "segments.create": {
+    id: "segments.create",
+    method: "POST",
+    path: "/segments",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      slug: {
+        wire: "slug"
+      },
+      language: {
+        wire: "language"
+      },
+      description: {
+        wire: "description"
+      },
+      themes: {
+        wire: "themes"
+      }
+    }
+  },
+  "topics.list": {
+    id: "topics.list",
+    method: "GET",
+    path: "/topics",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    query: {
+      segmentId: {
+        wire: "segment_id"
+      }
+    }
+  },
+  "segments.archive.get": {
+    id: "segments.archive.get",
+    method: "GET",
+    path: "/segments/{id}/archive",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "segments.archive.update": {
+    id: "segments.archive.update",
+    method: "PATCH",
+    path: "/segments/{id}/archive",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      enabled: {
+        wire: "enabled"
+      },
+      slug: {
+        wire: "slug"
+      },
+      description: {
+        wire: "description"
+      },
+      author: {
+        wire: "author"
+      },
+      about: {
+        wire: "about"
+      },
+      avatarUrl: {
+        wire: "avatar_url"
+      },
+      links: {
+        wire: "links",
+        props: {
+          website: {
+            wire: "website"
+          },
+          x: {
+            wire: "x"
+          },
+          linkedin: {
+            wire: "linkedin"
+          },
+          youtube: {
+            wire: "youtube"
+          },
+          instagram: {
+            wire: "instagram"
+          },
+          github: {
+            wire: "github"
+          },
+          bluesky: {
+            wire: "bluesky"
+          }
+        }
+      }
+    }
+  },
+  "newsletters.archive.update": {
+    id: "newsletters.archive.update",
+    method: "PATCH",
+    path: "/newsletters/{id}/archive",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      pinned: {
+        wire: "pinned"
+      },
+      hidden: {
+        wire: "hidden"
+      }
+    }
+  },
+  "segments.domain.get": {
+    id: "segments.domain.get",
+    method: "GET",
+    path: "/segments/{id}/domain",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "segments.domain.set": {
+    id: "segments.domain.set",
+    method: "POST",
+    path: "/segments/{id}/domain",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      domain: {
+        wire: "domain"
+      }
+    }
+  },
+  "segments.domain.remove": {
+    id: "segments.domain.remove",
+    method: "DELETE",
+    path: "/segments/{id}/domain",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "suppressions.list": {
+    id: "suppressions.list",
+    method: "GET",
+    path: "/suppressions",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      },
+      reason: {
+        wire: "reason"
+      }
+    }
+  },
+  "suppressions.create": {
+    id: "suppressions.create",
+    method: "POST",
+    path: "/suppressions",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      email: {
+        wire: "email"
+      },
+      reason: {
+        wire: "reason"
+      },
+      notes: {
+        wire: "notes"
+      }
+    }
+  },
+  "suppressions.remove": {
+    id: "suppressions.remove",
+    method: "DELETE",
+    path: "/suppressions/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "images.list": {
+    id: "images.list",
+    method: "GET",
+    path: "/images",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "images.create": {
+    id: "images.create",
+    method: "POST",
+    path: "/images",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    rawBody: true
+  },
+  "stats.overview": {
+    id: "stats.overview",
+    method: "GET",
+    path: "/stats/overview",
+    pathParams: [],
+    paginated: false,
+    idempotent: false
+  },
+  "domains.create": {
+    id: "domains.create",
+    method: "POST",
+    path: "/domains",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      trackingSubdomain: {
+        wire: "tracking_subdomain"
+      }
+    }
+  },
+  "domains.list": {
+    id: "domains.list",
+    method: "GET",
+    path: "/domains",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "domains.get": {
+    id: "domains.get",
+    method: "GET",
+    path: "/domains/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "domains.verify": {
+    id: "domains.verify",
+    method: "POST",
+    path: "/domains/{id}/verify",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "apiKeys.create": {
+    id: "apiKeys.create",
+    method: "POST",
+    path: "/api-keys",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      permission: {
+        wire: "permission"
+      },
+      domainId: {
+        wire: "domain_id"
+      }
+    }
+  },
+  "apiKeys.list": {
+    id: "apiKeys.list",
+    method: "GET",
+    path: "/api-keys",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "apiKeys.update": {
+    id: "apiKeys.update",
+    method: "PATCH",
+    path: "/api-keys/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      }
+    }
+  },
+  "apiKeys.remove": {
+    id: "apiKeys.remove",
+    method: "DELETE",
+    path: "/api-keys/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "logs.list": {
+    id: "logs.list",
+    method: "GET",
+    path: "/logs",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "logs.get": {
+    id: "logs.get",
+    method: "GET",
+    path: "/logs/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "usage.get": {
+    id: "usage.get",
+    method: "GET",
+    path: "/usage",
+    pathParams: [],
+    paginated: false,
+    idempotent: false
+  },
+  "sequences.list": {
+    id: "sequences.list",
+    method: "GET",
+    path: "/sequences",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    query: {
+      includeArchived: {
+        wire: "include_archived"
+      }
+    }
+  },
+  "sequences.create": {
+    id: "sequences.create",
+    method: "POST",
+    path: "/sequences",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      description: {
+        wire: "description"
+      },
+      segmentId: {
+        wire: "segment_id"
+      },
+      topicId: {
+        wire: "topic_id"
+      },
+      trigger: {
+        wire: "trigger",
+        props: {
+          type: {
+            wire: "type"
+          },
+          includeImports: {
+            wire: "include_imports"
+          },
+          topicId: {
+            wire: "topic_id"
+          },
+          leadMagnetId: {
+            wire: "lead_magnet_id"
+          },
+          event: {
+            wire: "event"
+          },
+          newsletterId: {
+            wire: "newsletter_id"
+          },
+          filterId: {
+            wire: "filter_id"
+          },
+          includeExisting: {
+            wire: "include_existing"
+          }
+        }
+      },
+      reentry: {
+        wire: "reentry",
+        props: {
+          mode: {
+            wire: "mode"
+          },
+          days: {
+            wire: "days"
+          }
+        }
+      },
+      exit: {
+        wire: "exit",
+        props: {
+          events: {
+            wire: "events"
+          },
+          filterId: {
+            wire: "filter_id"
+          }
+        }
+      },
+      steps: {
+        wire: "steps",
+        items: {
+          id: {
+            wire: "id"
+          },
+          type: {
+            wire: "type"
+          },
+          subject: {
+            wire: "subject"
+          },
+          preheader: {
+            wire: "preheader"
+          },
+          markdown: {
+            wire: "markdown"
+          },
+          html: {
+            wire: "html"
+          },
+          doc: {
+            wire: "doc"
+          },
+          templateId: {
+            wire: "template_id"
+          },
+          amount: {
+            wire: "amount"
+          },
+          unit: {
+            wire: "unit"
+          },
+          until: {
+            wire: "until",
+            props: {
+              time: {
+                wire: "time"
+              },
+              weekdays: {
+                wire: "weekdays"
+              },
+              timezone: {
+                wire: "timezone"
+              }
+            }
+          },
+          event: {
+            wire: "event"
+          },
+          timeoutHours: {
+            wire: "timeout_hours"
+          },
+          onTimeout: {
+            wire: "on_timeout"
+          },
+          filterId: {
+            wire: "filter_id"
+          },
+          rule: {
+            wire: "rule"
+          },
+          yes: {
+            wire: "yes"
+          },
+          no: {
+            wire: "no"
+          },
+          action: {
+            wire: "action"
+          },
+          key: {
+            wire: "key"
+          },
+          value: {
+            wire: "value"
+          },
+          topicId: {
+            wire: "topic_id"
+          },
+          webhookId: {
+            wire: "webhook_id"
+          }
+        }
+      }
+    }
+  },
+  "sequences.get": {
+    id: "sequences.get",
+    method: "GET",
+    path: "/sequences/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "sequences.update": {
+    id: "sequences.update",
+    method: "PATCH",
+    path: "/sequences/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      description: {
+        wire: "description"
+      },
+      segmentId: {
+        wire: "segment_id"
+      },
+      topicId: {
+        wire: "topic_id"
+      },
+      trigger: {
+        wire: "trigger",
+        props: {
+          type: {
+            wire: "type"
+          },
+          includeImports: {
+            wire: "include_imports"
+          },
+          topicId: {
+            wire: "topic_id"
+          },
+          leadMagnetId: {
+            wire: "lead_magnet_id"
+          },
+          event: {
+            wire: "event"
+          },
+          newsletterId: {
+            wire: "newsletter_id"
+          },
+          filterId: {
+            wire: "filter_id"
+          },
+          includeExisting: {
+            wire: "include_existing"
+          }
+        }
+      },
+      reentry: {
+        wire: "reentry",
+        props: {
+          mode: {
+            wire: "mode"
+          },
+          days: {
+            wire: "days"
+          }
+        }
+      },
+      exit: {
+        wire: "exit",
+        props: {
+          events: {
+            wire: "events"
+          },
+          filterId: {
+            wire: "filter_id"
+          }
+        }
+      },
+      steps: {
+        wire: "steps",
+        items: {
+          id: {
+            wire: "id"
+          },
+          type: {
+            wire: "type"
+          },
+          subject: {
+            wire: "subject"
+          },
+          preheader: {
+            wire: "preheader"
+          },
+          markdown: {
+            wire: "markdown"
+          },
+          html: {
+            wire: "html"
+          },
+          doc: {
+            wire: "doc"
+          },
+          templateId: {
+            wire: "template_id"
+          },
+          amount: {
+            wire: "amount"
+          },
+          unit: {
+            wire: "unit"
+          },
+          until: {
+            wire: "until",
+            props: {
+              time: {
+                wire: "time"
+              },
+              weekdays: {
+                wire: "weekdays"
+              },
+              timezone: {
+                wire: "timezone"
+              }
+            }
+          },
+          event: {
+            wire: "event"
+          },
+          timeoutHours: {
+            wire: "timeout_hours"
+          },
+          onTimeout: {
+            wire: "on_timeout"
+          },
+          filterId: {
+            wire: "filter_id"
+          },
+          rule: {
+            wire: "rule"
+          },
+          yes: {
+            wire: "yes"
+          },
+          no: {
+            wire: "no"
+          },
+          action: {
+            wire: "action"
+          },
+          key: {
+            wire: "key"
+          },
+          value: {
+            wire: "value"
+          },
+          topicId: {
+            wire: "topic_id"
+          },
+          webhookId: {
+            wire: "webhook_id"
+          }
+        }
+      }
+    }
+  },
+  "sequences.remove": {
+    id: "sequences.remove",
+    method: "DELETE",
+    path: "/sequences/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "sequences.activate": {
+    id: "sequences.activate",
+    method: "POST",
+    path: "/sequences/{id}/activate",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "sequences.pause": {
+    id: "sequences.pause",
+    method: "POST",
+    path: "/sequences/{id}/pause",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "sequences.archive": {
+    id: "sequences.archive",
+    method: "POST",
+    path: "/sequences/{id}/archive",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "sequences.enrollments": {
+    id: "sequences.enrollments",
+    method: "GET",
+    path: "/sequences/{id}/enrollments",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    query: {
+      status: {
+        wire: "status"
+      },
+      limit: {
+        wire: "limit"
+      }
+    }
+  },
+  "sequences.enroll": {
+    id: "sequences.enroll",
+    method: "POST",
+    path: "/sequences/{id}/enrollments",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      email: {
+        wire: "email"
+      },
+      contactId: {
+        wire: "contact_id"
+      }
+    }
+  },
+  "sequences.unenroll": {
+    id: "sequences.unenroll",
+    method: "DELETE",
+    path: "/sequences/{id}/enrollments/{enrollment_id}",
+    pathParams: ["id", "enrollment_id"],
+    paginated: false,
+    idempotent: false
+  },
+  "sequences.stats": {
+    id: "sequences.stats",
+    method: "GET",
+    path: "/sequences/{id}/stats",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "webhooks.create": {
+    id: "webhooks.create",
+    method: "POST",
+    path: "/webhooks",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      endpoint: {
+        wire: "endpoint"
+      },
+      events: {
+        wire: "events"
+      },
+      description: {
+        wire: "description"
+      },
+      includeNewsletters: {
+        wire: "include_newsletters"
+      },
+      segmentIds: {
+        wire: "segment_ids"
+      },
+      domains: {
+        wire: "domains"
+      }
+    }
+  },
+  "webhooks.list": {
+    id: "webhooks.list",
+    method: "GET",
+    path: "/webhooks",
+    pathParams: [],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      }
+    }
+  },
+  "webhooks.get": {
+    id: "webhooks.get",
+    method: "GET",
+    path: "/webhooks/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "webhooks.update": {
+    id: "webhooks.update",
+    method: "PATCH",
+    path: "/webhooks/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      endpoint: {
+        wire: "endpoint"
+      },
+      events: {
+        wire: "events"
+      },
+      status: {
+        wire: "status"
+      },
+      description: {
+        wire: "description"
+      },
+      includeNewsletters: {
+        wire: "include_newsletters"
+      },
+      segmentIds: {
+        wire: "segment_ids"
+      },
+      domains: {
+        wire: "domains"
+      }
+    }
+  },
+  "webhooks.remove": {
+    id: "webhooks.remove",
+    method: "DELETE",
+    path: "/webhooks/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "webhooks.rotateSigningSecret": {
+    id: "webhooks.rotateSigningSecret",
+    method: "POST",
+    path: "/webhooks/{id}/signing-secret/rotate",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "webhooks.test": {
+    id: "webhooks.test",
+    method: "POST",
+    path: "/webhooks/{id}/test",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      type: {
+        wire: "type"
+      }
+    }
+  },
+  "webhooks.deliveries": {
+    id: "webhooks.deliveries",
+    method: "GET",
+    path: "/webhooks/{id}/deliveries",
+    pathParams: ["id"],
+    paginated: true,
+    idempotent: false,
+    query: {
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      },
+      before: {
+        wire: "before"
+      },
+      status: {
+        wire: "status"
+      }
+    }
+  },
+  "webhooks.retryDelivery": {
+    id: "webhooks.retryDelivery",
+    method: "POST",
+    path: "/webhooks/{id}/deliveries/{delivery_id}/retry",
+    pathParams: ["id", "delivery_id"],
+    paginated: false,
+    idempotent: false
+  },
+  "inboxes.list": {
+    id: "inboxes.list",
+    method: "GET",
+    path: "/inboxes",
+    pathParams: [],
+    paginated: false,
+    idempotent: false
+  },
+  "inboxes.create": {
+    id: "inboxes.create",
+    method: "POST",
+    path: "/inboxes",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    body: {
+      name: {
+        wire: "name"
+      },
+      displayName: {
+        wire: "display_name"
+      },
+      description: {
+        wire: "description"
+      },
+      domainId: {
+        wire: "domain_id"
+      },
+      replyFrom: {
+        wire: "reply_from"
+      }
+    }
+  },
+  "inboxes.get": {
+    id: "inboxes.get",
+    method: "GET",
+    path: "/inboxes/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "inboxes.update": {
+    id: "inboxes.update",
+    method: "PATCH",
+    path: "/inboxes/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      displayName: {
+        wire: "display_name"
+      },
+      description: {
+        wire: "description"
+      },
+      replyFrom: {
+        wire: "reply_from"
+      },
+      status: {
+        wire: "status"
+      }
+    }
+  },
+  "inboxes.remove": {
+    id: "inboxes.remove",
+    method: "DELETE",
+    path: "/inboxes/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "threads.list": {
+    id: "threads.list",
+    method: "GET",
+    path: "/threads",
+    pathParams: [],
+    paginated: false,
+    idempotent: false,
+    query: {
+      inboxId: {
+        wire: "inbox_id"
+      },
+      status: {
+        wire: "status"
+      },
+      label: {
+        wire: "label"
+      },
+      spam: {
+        wire: "spam"
+      },
+      assigneeAgent: {
+        wire: "assignee_agent"
+      },
+      unread: {
+        wire: "unread"
+      },
+      limit: {
+        wire: "limit"
+      },
+      after: {
+        wire: "after"
+      }
+    }
+  },
+  "threads.get": {
+    id: "threads.get",
+    method: "GET",
+    path: "/threads/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "threads.update": {
+    id: "threads.update",
+    method: "PATCH",
+    path: "/threads/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      status: {
+        wire: "status"
+      },
+      labels: {
+        wire: "labels"
+      },
+      addLabels: {
+        wire: "add_labels"
+      },
+      removeLabels: {
+        wire: "remove_labels"
+      },
+      assigneeAgent: {
+        wire: "assignee_agent"
+      },
+      assigneeUserId: {
+        wire: "assignee_user_id"
+      },
+      spam: {
+        wire: "spam"
+      },
+      unread: {
+        wire: "unread"
+      }
+    }
+  },
+  "threads.reply": {
+    id: "threads.reply",
+    method: "POST",
+    path: "/threads/{id}/reply",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      text: {
+        wire: "text"
+      },
+      html: {
+        wire: "html"
+      },
+      messageId: {
+        wire: "message_id"
+      },
+      replyAll: {
+        wire: "reply_all"
+      },
+      cc: {
+        wire: "cc"
+      },
+      quote: {
+        wire: "quote"
+      },
+      draft: {
+        wire: "draft"
+      },
+      status: {
+        wire: "status"
+      }
+    }
+  },
+  "messages.get": {
+    id: "messages.get",
+    method: "GET",
+    path: "/messages/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "messages.update": {
+    id: "messages.update",
+    method: "PATCH",
+    path: "/messages/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      text: {
+        wire: "text"
+      },
+      html: {
+        wire: "html"
+      },
+      cc: {
+        wire: "cc"
+      }
+    }
+  },
+  "messages.send": {
+    id: "messages.send",
+    method: "POST",
+    path: "/messages/{id}/send",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false,
+    body: {
+      status: {
+        wire: "status"
+      }
+    }
+  },
+  "messages.remove": {
+    id: "messages.remove",
+    method: "DELETE",
+    path: "/messages/{id}",
+    pathParams: ["id"],
+    paginated: false,
+    idempotent: false
+  },
+  "messages.attachment": {
+    id: "messages.attachment",
+    method: "GET",
+    path: "/messages/{id}/attachments/{attachment_id}",
+    pathParams: ["id", "attachment_id"],
+    paginated: false,
+    idempotent: false
+  }
+};
+var OPERATION_IDS = Object.keys(OPERATIONS);
+
+// src/emails.ts
+var RENDER_ERROR = "Failed to render React component. Make sure to install `@react-email/render` or `@react-email/components`.";
+var RenderError = class extends Error {
+};
+async function renderReact(node) {
+  let renderFn;
+  try {
+    ({ render: renderFn } = await import("@react-email/render"));
+  } catch {
+    throw new RenderError(RENDER_ERROR);
+  }
+  if (typeof renderFn !== "function") throw new RenderError(RENDER_ERROR);
+  try {
+    return await renderFn(node);
+  } catch (err) {
+    throw new RenderError(err instanceof Error ? err.message : String(err));
+  }
+}
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  }
+  return btoa(binary);
+}
+async function prepare(email) {
+  const { react, attachments, ...rest } = email;
+  const out = { ...rest };
+  if (react) out.html = await renderReact(react);
+  if (attachments) {
+    out.attachments = attachments.map((a) => {
+      const { filename, ...file } = a;
+      return {
+        ...file,
+        ...filename === false ? {} : { filename },
+        ...a.content instanceof Uint8Array ? { content: toBase64(a.content) } : {}
+      };
+    });
+  }
+  return out;
+}
+function renderFailure(err) {
+  if (!(err instanceof RenderError)) return void 0;
+  return { data: null, error: { name: "application_error", statusCode: null, message: err.message }, headers: null };
+}
+function makeEmailsSend(client) {
+  return async (payload, options) => {
+    try {
+      const body = await prepare(payload);
+      return await client.call(OPERATIONS["emails.send"], body, options);
+    } catch (err) {
+      const failure = renderFailure(err);
+      if (failure) return failure;
+      throw err;
+    }
+  };
+}
+function makeBatchSend(client) {
+  return async (emails, options = {}) => {
+    try {
+      const body = [];
+      for (const email of emails) body.push(await prepare(email));
+      const { batchValidation, ...requestOptions } = options;
+      const headers = new Headers({ "x-batch-validation": batchValidation ?? "strict" });
+      for (const [key, value] of new Headers(requestOptions.headers)) headers.set(key, value);
+      return await client.call(OPERATIONS["batch.send"], body, { ...requestOptions, headers });
+    } catch (err) {
+      const failure = renderFailure(err);
+      if (failure) return failure;
+      throw err;
+    }
+  };
+}
+
+// src/webhooks/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256(data) {
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const padded = new Uint8Array(data.length + 9 + 63 >> 6 << 6);
+  padded.set(data);
+  padded[data.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(data.length / 536870912));
+  view.setUint32(padded.length - 4, data.length << 3 >>> 0);
+  const w = new Uint32Array(64);
+  for (let off = 0; off < padded.length; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const a2 = w[i - 15];
+      const b2 = w[i - 2];
+      const s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3;
+      const s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let i = 0; i < 64; i++) {
+      const t1 = hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K[i] + w[i] | 0;
+      const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h[0] = h[0] + a | 0;
+    h[1] = h[1] + b | 0;
+    h[2] = h[2] + c | 0;
+    h[3] = h[3] + d | 0;
+    h[4] = h[4] + e | 0;
+    h[5] = h[5] + f | 0;
+    h[6] = h[6] + g | 0;
+    h[7] = h[7] + hh | 0;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) outView.setUint32(i * 4, h[i]);
+  return out;
+}
+function hmacSha256(key, message) {
+  const block = new Uint8Array(64);
+  block.set(key.length > 64 ? sha256(key) : key);
+  const inner = new Uint8Array(64 + message.length);
+  const outer = new Uint8Array(64 + 32);
+  for (let i = 0; i < 64; i++) {
+    inner[i] = block[i] ^ 54;
+    outer[i] = block[i] ^ 92;
+  }
+  inner.set(message, 64);
+  outer.set(sha256(inner), 64);
+  return sha256(outer);
+}
+
+// src/webhooks/verify.ts
+var TOLERANCE_SECONDS = 5 * 60;
+var PREFIX = "whsec_";
+var B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var WebhookVerificationError = class _WebhookVerificationError extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _WebhookVerificationError.prototype);
+    this.name = "WebhookVerificationError";
+  }
+};
+function base64Decode(input) {
+  const clean = input.replace(/=+$/, "");
+  if (input.length < 4 || input.length - clean.length > 2) throw new Error("Base64Coder: incorrect padding");
+  if (clean.length % 4 === 1) throw new Error("Base64Coder: incorrect characters for decoding");
+  const out = new Uint8Array(Math.floor(clean.length * 3 / 4));
+  let acc = 0;
+  let bits = 0;
+  let n = 0;
+  for (let i = 0; i < clean.length; i++) {
+    const v = B64.indexOf(clean[i]);
+    if (v < 0) throw new Error("Base64Coder: incorrect characters for decoding");
+    acc = acc << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[n++] = acc >> bits & 255;
+      acc &= (1 << bits) - 1;
+    }
+  }
+  return out;
+}
+function base64Encode(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const n = bytes[i] << 16 | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0);
+    out += B64[n >> 18 & 63] + B64[n >> 12 & 63];
+    out += i + 1 < bytes.length ? B64[n >> 6 & 63] : "=";
+    out += i + 2 < bytes.length ? B64[n & 63] : "=";
+  }
+  return out;
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+function toPayloadString(payload) {
+  if (typeof payload === "string") return payload;
+  if (payload?.constructor?.name === "Buffer") return String(payload);
+  throw new Error("Expected payload to be of type string or Buffer.");
+}
+function verify(input) {
+  const secret = input.webhookSecret;
+  if (typeof secret !== "string") throw new Error("Expected secret to be of type string");
+  const key = base64Decode(secret.startsWith(PREFIX) ? secret.slice(PREFIX.length) : secret);
+  if (key.length === 0) throw new Error("Secret can't be empty.");
+  const { id, timestamp: timestampHeader, signature } = input.headers ?? {};
+  if (!signature || !id || !timestampHeader) throw new WebhookVerificationError("Missing required headers");
+  const now = Math.floor(Date.now() / 1e3);
+  const timestamp = parseInt(timestampHeader, 10);
+  if (Number.isNaN(timestamp)) throw new WebhookVerificationError("Invalid Signature Headers");
+  if (now - timestamp > TOLERANCE_SECONDS) throw new WebhookVerificationError("Message timestamp too old");
+  if (timestamp > now + TOLERANCE_SECONDS) throw new WebhookVerificationError("Message timestamp too new");
+  const body = toPayloadString(input.payload);
+  const encoder = new TextEncoder();
+  const expected = encoder.encode(
+    base64Encode(hmacSha256(key, encoder.encode(`${id}.${timestamp}.${body}`)))
+  );
+  for (const candidate of signature.split(" ")) {
+    const [version, value] = candidate.split(",");
+    if (version !== "v1") continue;
+    if (timingSafeEqual(encoder.encode(value ?? ""), expected)) {
+      return body === "" ? void 0 : JSON.parse(body);
+    }
+  }
+  throw new WebhookVerificationError("No matching signature found");
+}
+
+// src/resources.ts
+function camel2(snake) {
+  return snake.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+var CALL_STYLE_OVERRIDES = {
+  "apiKeys.update": "idBody",
+  "templates.update": "idBody",
+  "webhooks.update": "idBody",
+  // Resend : `publish(identifier, requestOptions?)`. Le `versionId` optionnel de Smartletter n'y a pas de place.
+  "templates.publish": "id"
+};
+function callStyle(op) {
+  const forced = CALL_STYLE_OVERRIDES[op.id];
+  if (forced) return forced;
+  return op.pathParams.length === 1 && !op.body && !op.query && !op.rawBody && !op.bodyIsArray ? "id" : "params";
+}
+function makeLeaf(client, op) {
+  const style = callStyle(op);
+  if (style === "id") {
+    const name = camel2(op.pathParams[0]);
+    return (id, options) => client.call(op, { [name]: id }, options);
+  }
+  if (style === "idBody") {
+    const name = camel2(op.pathParams[0]);
+    return (id, payload, options) => client.call(op, { ...payload, [name]: id }, options);
+  }
+  return (args, options) => {
+    const needsObject = op.pathParams.length > 0 && args === void 0;
+    return client.call(op, needsObject ? {} : args, options);
+  };
+}
+function chainable(promise, publish) {
+  return Object.assign(promise, {
+    async publish(options) {
+      const { data, error } = await promise;
+      if (error) return { data: null, error, headers: null };
+      return publish(data.id, options);
+    }
+  });
+}
+function makeTemplateMethods(templates) {
+  const create = templates.create;
+  const duplicate = templates.duplicate;
+  const publish = templates.publish;
+  const createWithReact = async (payload, options) => {
+    try {
+      const { react, ...rest } = payload ?? {};
+      const body = react ? { ...rest, html: await renderReact(react) } : payload;
+      return await create(body, options);
+    } catch (err) {
+      const failure = renderFailure(err);
+      if (failure) return failure;
+      throw err;
+    }
+  };
+  templates.create = ((payload, options) => chainable(createWithReact(payload, options), publish));
+  templates.duplicate = ((id, options) => chainable(duplicate(id, options), publish));
+}
+function buildResources(client) {
+  const root = {};
+  for (const op of Object.values(OPERATIONS)) {
+    const segments = op.id.split(".");
+    const leaf = segments.pop();
+    let node = root;
+    for (const segment of segments) {
+      const next = node[segment];
+      node = node[segment] = typeof next === "object" ? next : {};
+    }
+    node[leaf] = makeLeaf(client, op);
+  }
+  root.emails.send = makeEmailsSend(client);
+  root.batch.send = makeBatchSend(client);
+  root.emails.create = root.emails.send;
+  root.batch.create = root.batch.send;
+  makeTemplateMethods(root.templates);
+  root.webhooks.verify = verify;
+  return root;
+}
+
+// src/index.ts
+var Smartletter = class extends Client {
+  constructor(key, options = {}) {
+    super(key, options);
+    Object.assign(this, buildResources(this));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Resend,
+  Smartletter,
+  WebhookVerificationError
+});
+//# sourceMappingURL=index.cjs.map