@skrybe/sdk 1.0.0 → 2.0.0

package/dist/index.cjs

@@ -0,0 +1,1235 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACTIVITY_TYPES: () => ACTIVITY_TYPES,
+  ApiError: () => ApiError,
+  AuthenticationError: () => AuthenticationError,
+  CAMPAIGN_STATUSES: () => CAMPAIGN_STATUSES,
+  ConnectionError: () => ConnectionError,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  InvalidRequestError: () => InvalidRequestError,
+  MAX_ACTIVITY_PAGE: () => MAX_ACTIVITY_PAGE,
+  MAX_CAMPAIGNS_PAGE: () => MAX_CAMPAIGNS_PAGE,
+  MAX_RECIPIENTS: () => MAX_RECIPIENTS,
+  MAX_SUBSCRIBERS_PAGE: () => MAX_SUBSCRIBERS_PAGE,
+  MAX_TEST_EMAILS: () => MAX_TEST_EMAILS,
+  RateLimitError: () => RateLimitError,
+  SUBSCRIBER_STATUSES: () => SUBSCRIBER_STATUSES,
+  Skrybe: () => Skrybe,
+  SkrybeError: () => SkrybeError,
+  VERSION: () => VERSION
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SkrybeError = class extends Error {
+  constructor(type, code, message, opts = {}) {
+    super(message, opts.cause === void 0 ? void 0 : { cause: opts.cause });
+    /** Stable machine-readable slug, e.g. `list_not_found`. */
+    __publicField(this, "code");
+    __publicField(this, "type");
+    __publicField(this, "hint");
+    __publicField(this, "status");
+    __publicField(this, "raw");
+    this.name = "SkrybeError";
+    this.type = type;
+    this.code = code;
+    this.hint = opts.hint;
+    this.status = opts.status;
+    this.raw = opts.raw;
+  }
+};
+var AuthenticationError = class extends SkrybeError {
+  constructor(code, message, opts) {
+    super("authentication", code, message, opts);
+    this.name = "AuthenticationError";
+  }
+};
+var InvalidRequestError = class extends SkrybeError {
+  constructor(code, message, opts) {
+    super("invalid_request", code, message, opts);
+    this.name = "InvalidRequestError";
+  }
+};
+var RateLimitError = class extends SkrybeError {
+  constructor(code, message, opts) {
+    super("rate_limit", code, message, opts);
+    this.name = "RateLimitError";
+  }
+};
+var ConnectionError = class extends SkrybeError {
+  constructor(code, message, opts) {
+    super("connection", code, message, opts);
+    this.name = "ConnectionError";
+  }
+};
+var ApiError = class extends SkrybeError {
+  constructor(code, message, opts) {
+    super("api", code, message, opts);
+    this.name = "ApiError";
+  }
+};
+function createError(type, code, message, opts) {
+  switch (type) {
+    case "authentication":
+      return new AuthenticationError(code, message, opts);
+    case "invalid_request":
+      return new InvalidRequestError(code, message, opts);
+    case "rate_limit":
+      return new RateLimitError(code, message, opts);
+    case "connection":
+      return new ConnectionError(code, message, opts);
+    default:
+      return new ApiError(code, message, opts);
+  }
+}
+function excerpt(body, limit = 200) {
+  const flat = body.replace(/\s+/g, " ").trim();
+  if (flat === "") return "(an empty response)";
+  return flat.length > limit ? `${flat.slice(0, limit)}\u2026` : flat;
+}
+var LIST_IDS_HINT = "Call lists.list() to see the IDs available to this API key.";
+var UNDER_REVIEW_HINT = "Sending is paused while the brand is reviewed for a high bounce rate. Contact Skrybe support.";
+var DOMAIN_HINT = "Verify the From domain for this brand in the Skrybe dashboard.";
+var PROSE_ERRORS = {
+  // Authentication
+  "api key not passed": { code: "api_key_missing", type: "authentication" },
+  "invalid api key": {
+    code: "invalid_api_key",
+    type: "authentication",
+    hint: "Generate a key in the Skrybe dashboard under Settings. Keys are cleared for every login of a brand placed under review."
+  },
+  // Request shape
+  "no data passed": { code: "no_data_passed", type: "invalid_request" },
+  "some fields are missing.": { code: "missing_fields", type: "invalid_request" },
+  // Brands and lists
+  "brand id not passed": { code: "brand_id_missing", type: "invalid_request" },
+  // Also the answer to the install's main account key, which no brand is tied to.
+  "brand does not exist": {
+    code: "brand_not_found",
+    type: "api",
+    hint: "Use an API key from a brand login; the main account key is not tied to a brand."
+  },
+  "list does not exist": { code: "list_not_found", type: "api", hint: LIST_IDS_HINT },
+  "invalid list id.": { code: "list_not_found", type: "api", hint: LIST_IDS_HINT },
+  // Also what the server produces from an id it cannot decrypt, so this is
+  // the answer to a malformed id as much as to a missing one.
+  "list id not passed": {
+    code: "list_id_invalid",
+    type: "invalid_request",
+    hint: "A list ID is the encrypted value lists.list() returns, not the number in the dashboard URL."
+  },
+  // Autoresponders
+  "autoresponder id not passed": { code: "autoresponder_id_missing", type: "invalid_request" },
+  "autoresponder does not exist": { code: "autoresponder_not_found", type: "api" },
+  "email id not passed": { code: "email_id_missing", type: "invalid_request" },
+  "autoresponder email does not exist": { code: "autoresponder_email_not_found", type: "api" },
+  "autoresponder name not passed": { code: "autoresponder_name_missing", type: "invalid_request" },
+  "type must be drip, annually or on_date": { code: "invalid_autoresponder_type", type: "invalid_request" },
+  "list already has a drip autoresponder": {
+    code: "drip_exists",
+    type: "api",
+    hint: "A list can have one drip autoresponder. Add emails to the existing one."
+  },
+  "custom_field not passed": {
+    code: "custom_field_missing",
+    type: "invalid_request",
+    hint: "annually and on_date autoresponders send on a Date custom field of the list."
+  },
+  "field is not a date field": { code: "field_not_date", type: "invalid_request" },
+  "field already has an autoresponder": { code: "field_has_autoresponder", type: "api" },
+  "subject not passed": { code: "subject_missing", type: "invalid_request" },
+  "a drip email cannot go before signup": { code: "invalid_when", type: "invalid_request" },
+  "when must be immediately, or a delay such as +3 days": { code: "invalid_when", type: "invalid_request" },
+  "when must be on, or an offset such as +9 hours or -1 days": { code: "invalid_when", type: "invalid_request" },
+  // Templates
+  "template id not passed": { code: "template_id_missing", type: "invalid_request" },
+  "template does not exist": { code: "template_not_found", type: "api" },
+  "template name not passed": { code: "template_name_missing", type: "invalid_request" },
+  "template name cannot be empty": { code: "template_name_missing", type: "invalid_request" },
+  "html not passed": { code: "html_missing", type: "invalid_request" },
+  "editor must be html or dragdrop": { code: "invalid_editor", type: "invalid_request" },
+  // List management
+  "list name not passed": { code: "list_name_missing", type: "invalid_request" },
+  "list name is too long": {
+    code: "list_name_too_long",
+    type: "invalid_request",
+    hint: "A list name can be at most 100 characters."
+  },
+  "opt_in must be single or double": { code: "invalid_opt_in", type: "invalid_request" },
+  "nothing to update": { code: "nothing_to_update", type: "invalid_request", hint: "Pass at least one field to change." },
+  "list is used by a scheduled or sending campaign": {
+    code: "list_in_use",
+    type: "api",
+    hint: "Unschedule the campaign, or wait for it to finish sending, then delete the list."
+  },
+  // Custom fields
+  "field name not passed": { code: "field_name_missing", type: "invalid_request" },
+  "invalid field name": {
+    code: "invalid_field_name",
+    type: "invalid_request",
+    hint: 'Up to 100 characters, without : % [ ] , " < or >.'
+  },
+  "name and email are built-in fields": { code: "reserved_field_name", type: "invalid_request" },
+  "type must be text or date": { code: "invalid_field_type", type: "invalid_request" },
+  "field already exists": { code: "field_exists", type: "api", hint: "Field names are case-insensitive." },
+  "field does not exist": { code: "field_not_found", type: "api" },
+  "field is used by an autoresponder": {
+    code: "field_in_use",
+    type: "api",
+    hint: "Change the autoresponder in the Skrybe dashboard first."
+  },
+  "field is used by a segment": {
+    code: "field_in_use",
+    type: "api",
+    hint: "Remove it from the segment in the Skrybe dashboard first."
+  },
+  "list was changed by another request. try again.": { code: "conflict", type: "api" },
+  // Campaigns
+  "campaign id not passed": { code: "campaign_id_missing", type: "invalid_request" },
+  "campaign does not exist": { code: "campaign_not_found", type: "api" },
+  "invalid status": { code: "invalid_status", type: "invalid_request" },
+  "invalid page": { code: "invalid_page", type: "invalid_request" },
+  "invalid limit": { code: "invalid_limit", type: "invalid_request" },
+  "invalid type": { code: "invalid_type", type: "invalid_request" },
+  // Sending a campaign
+  "list or segment id(s) not passed": {
+    code: "recipients_missing",
+    type: "invalid_request",
+    hint: "Pass at least one list or segment ID."
+  },
+  "one or more list ids are invalid": { code: "list_not_found", type: "api", hint: LIST_IDS_HINT },
+  "one or more segment ids are invalid": { code: "segment_not_found", type: "api" },
+  "campaign has already been sent": {
+    code: "campaign_not_draft",
+    type: "api",
+    hint: "It has already started sending, so it can no longer be sent, scheduled or edited."
+  },
+  "campaign is scheduled": {
+    code: "campaign_scheduled",
+    type: "api",
+    hint: "Unschedule it first, or leave it to send at its scheduled time."
+  },
+  "campaign is not scheduled": { code: "campaign_not_scheduled", type: "api" },
+  // Editing and deleting campaigns
+  "campaign is sending": {
+    code: "campaign_sending",
+    type: "api",
+    hint: "Stop it in the Skrybe dashboard first, or wait for it to finish."
+  },
+  "subject cannot be empty": { code: "subject_empty", type: "invalid_request" },
+  "html cannot be empty": { code: "html_empty", type: "invalid_request" },
+  "invalid from_email": { code: "invalid_from_email", type: "invalid_request" },
+  "invalid reply_to": { code: "invalid_reply_to", type: "invalid_request" },
+  "track_opens and track_clicks must be 0, 1 or 2": {
+    code: "invalid_tracking",
+    type: "invalid_request",
+    hint: "0 off, 1 on, 2 anonymous."
+  },
+  "campaign was changed by another request. try again.": { code: "conflict", type: "api" },
+  // Scheduling
+  "schedule_date_time not passed": { code: "schedule_missing", type: "invalid_request" },
+  "schedule_date_time is invalid": {
+    code: "invalid_schedule",
+    type: "invalid_request",
+    hint: 'Use a date and time such as "2027-06-15 18:05" or "June 15, 2027 6:05pm".'
+  },
+  "schedule_date_time is in the past": {
+    code: "schedule_in_past",
+    type: "invalid_request",
+    hint: "The time is read in the timezone given, or the account's timezone if none is."
+  },
+  "schedule_timezone is invalid": {
+    code: "invalid_timezone",
+    type: "invalid_request",
+    hint: "Use an IANA name such as Africa/Lagos or America/New_York."
+  },
+  // Test sends
+  "email addresses not passed": { code: "emails_missing", type: "invalid_request" },
+  "too many email addresses": {
+    code: "too_many_emails",
+    type: "invalid_request",
+    hint: "A test send goes to at most 5 addresses."
+  },
+  "quota exceeded. please upgrade your plan.": { code: "quota_exceeded", type: "rate_limit" },
+  "no active subscribers to send to": {
+    code: "no_recipients",
+    type: "api",
+    hint: "Every subscriber on those lists is unsubscribed, bounced, unconfirmed or excluded."
+  },
+  // Subscribers
+  "subscriber does not exist": { code: "subscriber_not_found", type: "api" },
+  "email does not exist in list": { code: "subscriber_not_found", type: "api" },
+  "email not passed": { code: "email_missing", type: "invalid_request" },
+  "email address not passed": { code: "email_missing", type: "invalid_request" },
+  "invalid email address.": { code: "invalid_email", type: "invalid_request" },
+  "bounced email address.": { code: "bounced_email", type: "api" },
+  "email is suppressed.": { code: "suppressed_email", type: "api" },
+  // unsubscribe.php's wording for an address that is not on the list.
+  "email does not exist.": { code: "subscriber_not_found", type: "api" },
+  "ip address is invalid.": { code: "invalid_ip_address", type: "invalid_request" },
+  "country must be a valid 2 letter country code": {
+    code: "invalid_country",
+    type: "invalid_request",
+    hint: "Use a two-letter ISO 3166-1 code, e.g. NG."
+  },
+  "referrer is not a valid url": { code: "invalid_referrer", type: "invalid_request" },
+  "consent not given.": {
+    code: "consent_not_given",
+    type: "invalid_request",
+    hint: "The list requires GDPR consent; pass gdpr: true."
+  },
+  "failed recaptcha test.": {
+    code: "recaptcha_failed",
+    type: "api",
+    hint: "The list has reCAPTCHA enabled on its subscribe form, which an API call cannot satisfy."
+  },
+  // Sending
+  "unauthorised from email domain": {
+    code: "unauthorised_from_domain",
+    type: "api",
+    hint: "The From domain must be verified for this brand, or listed in its allowed domains."
+  }
+};
+var PROSE_PATTERN_ERRORS = [
+  [/^error: this campaign would exceed/, { code: "quota_exceeded", type: "rate_limit" }],
+  [/^account under review:/, { code: "account_under_review", type: "api", hint: UNDER_REVIEW_HINT }],
+  [/^brand is under review/, { code: "account_under_review", type: "api", hint: UNDER_REVIEW_HINT }],
+  [/^a field is too long/, { code: "field_too_long", type: "invalid_request" }],
+  [
+    /^test send rate limit reached/,
+    {
+      code: "rate_limited",
+      type: "rate_limit",
+      hint: "Test sends are limited to 20 an hour per brand, shared with the Skrybe dashboard."
+    }
+  ],
+  [/^domain not verified in ses/, { code: "domain_not_verified", type: "api", hint: DOMAIN_HINT }],
+  [/^domain ".*" is not verified/, { code: "domain_not_verified", type: "api", hint: DOMAIN_HINT }]
+];
+var PROSE_EMPTY = /* @__PURE__ */ new Set(["no lists found", "no brands found", "no campaigns found"]);
+function isProseEmpty(body) {
+  return PROSE_EMPTY.has(body.trim().toLowerCase());
+}
+var PROSE_OK = /* @__PURE__ */ new Set(["1", "true", "already subscribed."]);
+function isProseSuccess(body) {
+  return PROSE_OK.has(body.trim().toLowerCase());
+}
+function classifyProse(body, status) {
+  const trimmed = body.trim();
+  const key = trimmed.toLowerCase();
+  const rule = PROSE_ERRORS[key] ?? PROSE_PATTERN_ERRORS.find(([pattern]) => pattern.test(key))?.[1];
+  if (rule) return createError(rule.type, rule.code, trimmed, { raw: body, status, hint: rule.hint });
+  if (key.startsWith("unable to")) return new ApiError("operation_failed", trimmed, { raw: body, status });
+  return null;
+}
+function typeForStatus(status) {
+  if (status === 401 || status === 403) return "authentication";
+  if (status === 402 || status === 429) return "rate_limit";
+  if (status === 400 || status === 405 || status === 422) return "invalid_request";
+  return "api";
+}
+function codeForStatus(status) {
+  switch (status) {
+    case 400:
+      return "invalid_request";
+    case 401:
+      return "unauthenticated";
+    case 402:
+      return "quota_exceeded";
+    case 403:
+      return "forbidden";
+    case 404:
+      return "not_found";
+    case 405:
+      return "method_not_allowed";
+    case 429:
+      return "rate_limited";
+    default:
+      return status >= 500 ? "server_error" : "api_error";
+  }
+}
+function unexpectedResponse(operation, body) {
+  return new ApiError("unexpected_response", `Unexpected response from ${operation}: ${excerpt(body)}`, { raw: body });
+}
+
+// src/parse.ts
+function extractByStructure(body, prefix) {
+  const entry = new RegExp(
+    String.raw`"${prefix}\d+"\s*:\s*\{\s*` + String.raw`"id"\s*:\s*"([^"]*)"\s*,\s*` + String.raw`"name"\s*:\s*"([\s\S]*?)"\s*\}` + String.raw`(?=\s*,\s*"${prefix}\d+"\s*:|\s*\}\s*$)`,
+    "g"
+  );
+  const out = [];
+  for (const match of body.matchAll(entry)) {
+    out.push({ id: match[1] ?? "", name: match[2] ?? "" });
+  }
+  return out;
+}
+function parseNumberedObject(body, prefix) {
+  const trimmed = body.trim();
+  if (trimmed === "") return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const out = [];
+      for (const [key, value] of Object.entries(parsed)) {
+        if (!key.startsWith(prefix)) continue;
+        if (value === null || typeof value !== "object") continue;
+        const row = value;
+        out.push({ id: String(row.id ?? ""), name: String(row.name ?? "") });
+      }
+      return sortByNumericSuffix(out, parsed, prefix);
+    }
+  } catch {
+  }
+  const recovered = extractByStructure(trimmed, prefix);
+  if (recovered.length > 0) return recovered;
+  throw new ApiError(
+    "malformed_response",
+    `Could not parse the ${prefix} payload returned by the API.`,
+    { raw: body, hint: `The server sent: ${excerpt(trimmed)}` }
+  );
+}
+function sortByNumericSuffix(rows, source, prefix) {
+  const keys = Object.keys(source).filter((k) => k.startsWith(prefix));
+  const order = /* @__PURE__ */ new Map();
+  keys.forEach((key, index) => {
+    const n = Number.parseInt(key.slice(prefix.length), 10);
+    if (!Number.isNaN(n)) order.set(index, n);
+  });
+  return rows.map((row, index) => ({ row, sort: order.get(index) ?? index })).sort((a, b) => a.sort - b.sort).map((x) => x.row);
+}
+function parseNumberedRecords(body, prefix) {
+  const parsed = parseJsonObject(body, `${prefix} payload`);
+  const key = new RegExp(`^${prefix}(\\d+)$`);
+  return Object.entries(parsed).map(([name, value]) => ({ match: key.exec(name), value })).filter(
+    (entry) => entry.match !== null && entry.value !== null && typeof entry.value === "object"
+  ).sort((a, b) => Number(a.match[1]) - Number(b.match[1])).map((entry) => entry.value);
+}
+function parseJsonObject(body, what) {
+  const trimmed = body.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  throw new ApiError(
+    "malformed_response",
+    `Could not parse the ${what} returned by the API.`,
+    { raw: body, hint: `The server sent: ${excerpt(trimmed)}` }
+  );
+}
+
+// src/resources/autoresponders.ts
+var Autoresponders = class {
+  constructor(transport) {
+    __publicField(this, "transport", transport);
+  }
+  /** The brand's autoresponders, or one list's. */
+  async list(opts = {}) {
+    const body = await this.transport.text({
+      path: "api/autoresponders/get-autoresponders.php",
+      body: { list_id: opts.listId },
+      retryable: true
+    });
+    return parseJsonObject(body, "autoresponders").autoresponders;
+  }
+  /** One autoresponder with its emails. */
+  async get(autoresponderId) {
+    const body = await this.transport.text({
+      path: "api/autoresponders/get-autoresponder-emails.php",
+      body: { autoresponder_id: autoresponderId },
+      retryable: true
+    });
+    return parseJsonObject(body, "autoresponder");
+  }
+  async emailStats(emailId) {
+    const body = await this.transport.text({
+      path: "api/autoresponders/autoresponder-stats.php",
+      body: { email_id: emailId },
+      retryable: true
+    });
+    return parseJsonObject(body, "autoresponder email stats");
+  }
+  /** Creates an autoresponder with no emails; add them with `createEmail()`. Not retried. */
+  async create(params) {
+    const body = await this.transport.text({
+      path: "api/autoresponders/create-autoresponder.php",
+      body: { name: params.name, type: params.type, list_id: params.listId, custom_field: params.customField }
+    });
+    return parseJsonObject(body, "autoresponder");
+  }
+  /** Adds an email to an autoresponder. Not retried: a repeat would add it twice. */
+  async createEmail(autoresponderId, params) {
+    const body = await this.transport.text({
+      path: "api/autoresponders/create-autoresponder-email.php",
+      body: {
+        autoresponder_id: autoresponderId,
+        subject: params.subject,
+        html_text: params.htmlText,
+        plain_text: params.plainText,
+        preheader: params.preheader,
+        when: params.when,
+        from_name: params.fromName,
+        from_email: params.fromEmail,
+        reply_to: params.replyTo,
+        query_string: params.queryString,
+        track_opens: params.trackOpens,
+        track_clicks: params.trackClicks,
+        enabled: params.enabled ? 1 : void 0
+      }
+    });
+    return parseJsonObject(body, "autoresponder email");
+  }
+};
+
+// src/resources/shared.ts
+function joinIds(ids) {
+  return ids && ids.length > 0 ? ids.join(",") : void 0;
+}
+
+// src/resources/campaigns.ts
+var CAMPAIGN_STATUSES = ["draft", "scheduled", "preparing", "sending", "sent", "paused"];
+var MAX_CAMPAIGNS_PAGE = 100;
+var MAX_TEST_EMAILS = 5;
+var ACTIVITY_TYPES = ["opens", "clicks", "bounces", "complaints", "unsubscribes"];
+var MAX_ACTIVITY_PAGE = 1e3;
+var Campaigns = class {
+  constructor(transport) {
+    __publicField(this, "transport", transport);
+  }
+  /**
+   * `api/campaigns/create.php` creates a draft, and optionally sends or
+   * schedules it in the same call. To send a draft that already exists, see
+   * `send()`.
+   */
+  async create(params) {
+    const text = await this.transport.text({
+      path: "api/campaigns/create.php",
+      body: {
+        from_name: params.fromName,
+        from_email: params.fromEmail,
+        reply_to: params.replyTo,
+        title: params.title,
+        subject: params.subject,
+        html_text: params.htmlText,
+        plain_text: params.plainText,
+        list_ids: joinIds(params.listIds),
+        segment_ids: joinIds(params.segmentIds),
+        exclude_list_ids: joinIds(params.excludeListIds),
+        exclude_segments_ids: joinIds(params.excludeSegmentIds),
+        query_string: params.queryString,
+        track_opens: params.trackOpens,
+        track_clicks: params.trackClicks,
+        send_campaign: params.send ? 1 : void 0,
+        schedule_date_time: params.scheduleDateTime,
+        schedule_timezone: params.scheduleTimezone,
+        // Asks for `{"status": ..., "campaign_id": ...}` instead of bare prose.
+        json: 1
+      }
+    });
+    const trimmed = text.trim();
+    if (trimmed === "Campaign scheduled") return { outcome: "scheduled" };
+    if (trimmed === "Campaign created and now sending") return { outcome: "sending" };
+    if (trimmed === "Campaign created") return { outcome: "created" };
+    if (trimmed.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed.status === "string" && parsed.status.startsWith("Campaign created")) {
+          return { outcome: "created", campaignId: parsed.campaign_id };
+        }
+      } catch {
+      }
+    }
+    throw new ApiError("unexpected_response", `Unexpected response from campaigns/create: ${excerpt(trimmed)}`, {
+      raw: text
+    });
+  }
+  /** One page, newest first. An empty page is an empty array, not an error. */
+  async list(params = {}) {
+    const body = await this.transport.text({
+      path: "api/campaigns/get-campaigns.php",
+      body: { page: params.page, limit: params.limit, status: params.status },
+      retryable: true
+    });
+    if (isProseEmpty(body)) return [];
+    return parseNumberedRecords(body, "campaign");
+  }
+  /** Every page, fetched in order at the largest page size. */
+  async listAll(params = {}) {
+    const all = [];
+    for (let page = 1; ; page++) {
+      const rows = await this.list({ ...params, page, limit: MAX_CAMPAIGNS_PAGE });
+      all.push(...rows);
+      if (rows.length < MAX_CAMPAIGNS_PAGE) return all;
+    }
+  }
+  async get(campaignId, opts = {}) {
+    const body = await this.transport.text({
+      path: "api/campaigns/get-campaign.php",
+      body: { campaign_id: campaignId, include_content: opts.includeContent ? "yes" : void 0 },
+      retryable: true
+    });
+    return parseJsonObject(body, "campaign");
+  }
+  async stats(campaignId) {
+    const body = await this.transport.text({
+      path: "api/campaigns/stats.php",
+      body: { campaign_id: campaignId },
+      retryable: true
+    });
+    return parseJsonObject(body, "campaign stats");
+  }
+  /**
+   * `api/campaigns/send.php` sends an existing draft. It only ever claims a
+   * draft, so a repeat after a lost response answers "Campaign has already been
+   * sent" rather than sending twice. It is still not retried: that answer
+   * would turn a success into a reported failure.
+   */
+  async send(campaignId, recipients) {
+    const body = await this.transport.text({
+      path: "api/campaigns/send.php",
+      body: { campaign_id: campaignId, ...recipientFields(recipients) }
+    });
+    return parseJsonObject(body, "send result");
+  }
+  /**
+   * Sends the campaign as a test to up to 5 addresses. Each request counts
+   * against a per-brand limit shared with the dashboard (20 an hour), so it is
+   * never retried.
+   */
+  async testSend(campaignId, emails) {
+    const body = await this.transport.text({
+      path: "api/campaigns/test-send.php",
+      body: { campaign_id: campaignId, emails: emails.join(",") }
+    });
+    return parseJsonObject(body, "test send result");
+  }
+  /**
+   * Schedules a draft, or moves a scheduled campaign. The recipients are
+   * reserved against the quota now and handed back by `unschedule()`.
+   */
+  async schedule(campaignId, params) {
+    const body = await this.transport.text({
+      path: "api/campaigns/schedule.php",
+      body: {
+        campaign_id: campaignId,
+        ...recipientFields(params),
+        schedule_date_time: params.at,
+        schedule_timezone: params.timezone
+      }
+    });
+    return parseJsonObject(body, "schedule result");
+  }
+  /** Back to a draft, with its quota reservation refunded. */
+  async unschedule(campaignId) {
+    const body = await this.transport.text({ path: "api/campaigns/unschedule.php", body: { campaign_id: campaignId } });
+    return parseJsonObject(body, "unschedule result");
+  }
+  /** Edits a draft or scheduled campaign and returns it as `get()` would. */
+  async update(campaignId, changes) {
+    const body = await this.transport.text({
+      path: "api/campaigns/update-campaign.php",
+      body: {
+        campaign_id: campaignId,
+        title: changes.title,
+        subject: changes.subject,
+        preheader: changes.preheader,
+        from_name: changes.fromName,
+        from_email: changes.fromEmail,
+        reply_to: changes.replyTo,
+        html_text: changes.htmlText,
+        plain_text: changes.plainText,
+        query_string: changes.queryString,
+        track_opens: changes.trackOpens,
+        track_clicks: changes.trackClicks
+      }
+    });
+    return parseJsonObject(body, "campaign");
+  }
+  /** A new draft copied from the campaign, in the same brand. */
+  async duplicate(campaignId, opts = {}) {
+    const body = await this.transport.text({
+      path: "api/campaigns/duplicate-campaign.php",
+      body: { campaign_id: campaignId, title: opts.title }
+    });
+    return parseJsonObject(body, "campaign");
+  }
+  /**
+   * Deletes the campaign with its links and attachments; a sent one loses its
+   * report. Refused while the campaign is preparing or sending.
+   */
+  async delete(campaignId) {
+    const body = await this.transport.text({ path: "api/campaigns/delete-campaign.php", body: { campaign_id: campaignId } });
+    return parseJsonObject(body, "delete result");
+  }
+  /**
+   * A page of who opened, clicked, bounced, complained or unsubscribed. Opens
+   * and clicks are in the order subscribers first did them.
+   */
+  async activity(campaignId, params = {}) {
+    const body = await this.transport.text({
+      path: "api/campaigns/get-activity.php",
+      body: { campaign_id: campaignId, type: params.type, page: params.page, limit: params.limit },
+      retryable: true
+    });
+    return parseJsonObject(body, "campaign activity");
+  }
+  /** Every page of one activity type, at the largest page size. */
+  async activityAll(campaignId, type) {
+    const all = [];
+    for (let page = 1; ; page++) {
+      const r = await this.activity(campaignId, { type, page, limit: MAX_ACTIVITY_PAGE });
+      all.push(...r.activity);
+      if (r.activity.length === 0 || page * MAX_ACTIVITY_PAGE >= r.total) return all;
+    }
+  }
+};
+function recipientFields(r) {
+  return {
+    list_ids: joinIds(r.listIds),
+    segment_ids: joinIds(r.segmentIds),
+    exclude_list_ids: joinIds(r.excludeListIds),
+    exclude_segment_ids: joinIds(r.excludeSegmentIds),
+    dry_run: r.dryRun ? 1 : void 0
+  };
+}
+
+// src/resources/emails.ts
+var MAX_RECIPIENTS = 250;
+var Emails = class {
+  constructor(transport) {
+    __publicField(this, "transport", transport);
+  }
+  /**
+   * `api/emails/send.php`: a bulk send to addresses or lists. It creates a
+   * campaign behind the scenes; the subject doubles as its title.
+   */
+  async send(params) {
+    const to = params.to ?? [];
+    if (to.length === 0 && (params.listIds ?? []).length === 0) {
+      throw new InvalidRequestError("recipients_missing", "Nothing to send to.", {
+        hint: "Pass `to` addresses, or `listIds`."
+      });
+    }
+    if (to.length > MAX_RECIPIENTS) {
+      throw new InvalidRequestError(
+        "too_many_recipients",
+        `${to.length} recipients is more than the ${MAX_RECIPIENTS} this endpoint accepts.`,
+        { hint: "Split the send, or put the addresses on a list and pass `listIds`." }
+      );
+    }
+    const data = await this.transport.json({
+      path: "api/emails/send.php",
+      body: {
+        from_name: params.fromName,
+        from_email: params.fromEmail,
+        reply_to: params.replyTo,
+        subject: params.subject,
+        html_text: params.htmlText,
+        plain_text: params.plainText,
+        // Both go over the wire as JSON strings inside a form body.
+        to: to.length > 0 ? JSON.stringify(to) : void 0,
+        "recipient-variables": params.recipientVariables ? JSON.stringify(params.recipientVariables) : void 0,
+        list_ids: params.listIds?.join(","),
+        query_string: params.queryString,
+        track_opens: params.trackOpens,
+        track_clicks: params.trackClicks,
+        schedule_date_time: params.scheduleDateTime,
+        schedule_timezone: params.scheduleTimezone
+      }
+    });
+    return { message: data.message ?? "Sent.", campaignId: data.data?.campaign_id };
+  }
+  /**
+   * `api/emails/send-transactional.php`: one email, delivered immediately with
+   * nothing queued. For OTPs, password resets and receipts.
+   */
+  async sendTransactional(params) {
+    if (!params.htmlBody && !params.plainBody) {
+      throw new InvalidRequestError("body_missing", "A message body is required.", {
+        hint: "Pass `htmlBody`, `plainBody`, or both."
+      });
+    }
+    const data = await this.transport.json({
+      path: "api/emails/send-transactional.php",
+      encoding: "json",
+      body: {
+        to_email: params.toEmail,
+        subject: params.subject,
+        html_body: params.htmlBody,
+        plain_body: params.plainBody,
+        from_name: params.fromName,
+        from_email: params.fromEmail,
+        reply_to: params.replyTo
+      }
+    });
+    return { message: data.message ?? "Email sent successfully.", messageId: data.message_id };
+  }
+};
+
+// src/resources/lists.ts
+var Lists = class {
+  constructor(transport) {
+    __publicField(this, "transport", transport);
+  }
+  /** The brand's lists. An empty brand is an empty array, not an error. */
+  async list(opts = {}) {
+    const body = await this.transport.text({
+      path: "api/lists/get-lists.php",
+      body: { include_hidden: opts.includeHidden ? "yes" : "no" },
+      retryable: true
+    });
+    if (isProseEmpty(body)) return [];
+    return parseNumberedObject(body, "list");
+  }
+  async get(listId) {
+    const body = await this.transport.text({ path: "api/lists/get-list.php", body: { list_id: listId }, retryable: true });
+    return parseJsonObject(body, "list");
+  }
+  /** Not retried: a repeat after a lost response would create a second list. */
+  async create(params) {
+    const body = await this.transport.text({
+      path: "api/lists/create.php",
+      body: { name: params.name, opt_in: params.optIn }
+    });
+    return parseJsonObject(body, "list");
+  }
+  async update(listId, changes) {
+    const body = await this.transport.text({
+      path: "api/lists/update-list.php",
+      body: { list_id: listId, name: changes.name, opt_in: changes.optIn }
+    });
+    return parseJsonObject(body, "list");
+  }
+  /**
+   * Deletes the list with its subscribers, segments, autoresponders and rules.
+   * Refused while a scheduled or sending campaign is going to it.
+   */
+  async delete(listId) {
+    const body = await this.transport.text({ path: "api/lists/delete.php", body: { list_id: listId } });
+    return parseJsonObject(body, "delete result");
+  }
+  /**
+   * Subscribers a campaign to this list would reach.
+   *
+   * Anything but a bare integer is a failure and is thrown, never reported as
+   * 0: "this list is empty" is the one wrong answer a caller cannot detect.
+   */
+  async activeSubscriberCount(listId) {
+    const body = await this.transport.text({
+      path: "api/subscribers/active-subscriber-count.php",
+      body: { list_id: listId },
+      retryable: true
+    });
+    const trimmed = body.trim();
+    if (!/^\d+$/.test(trimmed)) {
+      throw new ApiError("malformed_response", `Expected a subscriber count for list ${listId}, got: ${excerpt(trimmed)}`, {
+        raw: body
+      });
+    }
+    return Number.parseInt(trimmed, 10);
+  }
+  /** Adds a field; every subscriber gets an empty value for it. Returns the list with its fields. */
+  async addCustomField(listId, params) {
+    const body = await this.transport.text({
+      path: "api/lists/add-custom-field.php",
+      body: { list_id: listId, name: params.name, type: params.type }
+    });
+    return parseJsonObject(body, "list");
+  }
+  /**
+   * Renames a field, keeping subscribers' values. The autoresponders and
+   * segment conditions that use it follow; tags already in campaigns keep the
+   * old name.
+   */
+  async renameCustomField(listId, name, newName) {
+    const body = await this.transport.text({
+      path: "api/lists/rename-custom-field.php",
+      body: { list_id: listId, name, new_name: newName }
+    });
+    return parseJsonObject(body, "list");
+  }
+  /** Deletes a field and every subscriber's value for it. Refused while an autoresponder or segment uses it. */
+  async deleteCustomField(listId, name) {
+    const body = await this.transport.text({
+      path: "api/lists/delete-custom-field.php",
+      body: { list_id: listId, name }
+    });
+    return parseJsonObject(body, "list");
+  }
+};
+
+// src/resources/misc.ts
+var Brands = class {
+  constructor(transport) {
+    __publicField(this, "transport", transport);
+  }
+  /**
+   * The key's own brand: a brand key gets exactly one row. Empty, not an error,
+   * when there is none.
+   */
+  async list() {
+    const body = await this.transport.text({ path: "api/brands/get-brands.php", retryable: true });
+    if (isProseEmpty(body)) return [];
+    return parseNumberedObject(body, "brand");
+  }
+};
+var Stats = class {
+  constructor(transport) {
+    __publicField(this, "transport", transport);
+  }
+  /**
+   * Emails sent across the whole installation (campaigns, autoresponders and
+   * transactional), not a per-brand figure. Public and cached for 5 minutes.
+   */
+  async totalEmailsSent() {
+    const data = await this.transport.json({
+      path: "api/stats/emails-sent.php",
+      method: "GET",
+      anonymous: true,
+      retryable: true
+    });
+    return data.total_emails_sent ?? 0;
+  }
+};
+
+// src/resources/subscribers.ts
+var SUBSCRIBER_STATUSES = ["active", "unconfirmed", "unsubscribed", "bounced", "complained"];
+var MAX_SUBSCRIBERS_PAGE = 1e3;
+var Subscribers = class {
+  constructor(transport) {
+    __publicField(this, "transport", transport);
+  }
+  /**
+   * Adds an address to a list. Posting one that is already there updates its
+   * name and custom fields, and resolves `already_subscribed` rather than
+   * throwing, so re-running an import is safe.
+   */
+  async subscribe(params) {
+    const body = {};
+    for (const [name, value] of Object.entries(params.fields ?? {})) body[name.replace(/ /g, "")] = value;
+    body.email = params.email;
+    body.list = params.listId;
+    body.boolean = "true";
+    if (params.name !== void 0) body.name = params.name;
+    if (params.country !== void 0) body.country = params.country;
+    if (params.ipAddress !== void 0) body.ipaddress = params.ipAddress;
+    if (params.referrer !== void 0) body.referrer = params.referrer;
+    if (params.gdpr) body.gdpr = "true";
+    if (params.silent) body.silent = "true";
+    const text = await this.transport.text({ path: "subscribe", body });
+    if (text.trim().toLowerCase() === "already subscribed.") return "already_subscribed";
+    if (isProseSuccess(text)) return "subscribed";
+    throw unexpectedResponse("subscribe", text);
+  }
+  /** Marks the address unsubscribed from the list. */
+  async unsubscribe(ref) {
+    const text = await this.transport.text({
+      path: "unsubscribe",
+      body: { email: ref.email, list: ref.listId, boolean: "true" }
+    });
+    if (!isProseSuccess(text)) throw unexpectedResponse("unsubscribe", text);
+  }
+  /** Removes the subscriber outright, rather than marking it unsubscribed. */
+  async delete(ref) {
+    const text = await this.transport.text({
+      path: "api/subscribers/delete.php",
+      body: { list_id: ref.listId, email: ref.email }
+    });
+    if (!isProseSuccess(text)) throw unexpectedResponse("delete", text);
+  }
+  /**
+   * One of Subscribed, Unsubscribed, Unconfirmed, Bounced, Soft bounced or
+   * Complained. Returned as given, so a status added server-side surfaces
+   * rather than being rejected.
+   */
+  async status(ref) {
+    const text = await this.transport.text({
+      path: "api/subscribers/subscription-status.php",
+      body: { email: ref.email, list_id: ref.listId },
+      retryable: true
+    });
+    const status = text.trim();
+    if (status === "") throw unexpectedResponse("subscription-status", text);
+    return status;
+  }
+  /** One page of a list's subscribers, oldest first. */
+  async list(listId, params = {}) {
+    const body = await this.transport.text({
+      path: "api/subscribers/get-subscribers.php",
+      body: { list_id: listId, status: params.status, page: params.page, limit: params.limit },
+      retryable: true
+    });
+    return parseJsonObject(body, "subscribers page");
+  }
+  /**
+   * Every page, at the largest page size. Oldest first, so someone joining
+   * mid-way lands on a later page instead of shifting the ones already read.
+   */
+  async listAll(listId, params = {}) {
+    const all = [];
+    for (let page = 1; ; page++) {
+      const r = await this.list(listId, { ...params, page, limit: MAX_SUBSCRIBERS_PAGE });
+      all.push(...r.subscribers);
+      if (r.subscribers.length < MAX_SUBSCRIBERS_PAGE) return all;
+    }
+  }
+};
+
+// src/resources/templates.ts
+var fieldsBody = (fields) => ({
+  name: fields.name,
+  html_text: fields.htmlText,
+  plain_text: fields.plainText,
+  from_name: fields.fromName,
+  from_email: fields.fromEmail,
+  reply_to: fields.replyTo,
+  editor: fields.editor
+});
+var Templates = class {
+  constructor(transport) {
+    __publicField(this, "transport", transport);
+  }
+  /** The brand's templates by name, without their HTML. */
+  async list() {
+    const text = await this.transport.text({ path: "api/templates/get-templates.php", retryable: true });
+    return parseJsonObject(text, "templates").templates;
+  }
+  async get(templateId, opts = {}) {
+    const text = await this.transport.text({
+      path: "api/templates/get-template.php",
+      body: { template_id: templateId, include_content: opts.includeContent ? "yes" : void 0 },
+      retryable: true
+    });
+    return parseJsonObject(text, "template");
+  }
+  /** Not retried: a repeat would create a second template. */
+  async create(fields) {
+    const text = await this.transport.text({ path: "api/templates/create-template.php", body: fieldsBody(fields) });
+    return parseJsonObject(text, "template");
+  }
+  /** Only the fields given change. */
+  async update(templateId, fields) {
+    const text = await this.transport.text({
+      path: "api/templates/update-template.php",
+      body: { template_id: templateId, ...fieldsBody(fields) }
+    });
+    return parseJsonObject(text, "template");
+  }
+  /** Campaigns already made from it are unaffected. */
+  async delete(templateId) {
+    const text = await this.transport.text({
+      path: "api/templates/delete-template.php",
+      body: { template_id: templateId }
+    });
+    return parseJsonObject(text, "delete result");
+  }
+};
+
+// src/version.ts
+var VERSION = "2.0.0";
+
+// src/transport.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var Transport = class {
+  constructor(opts) {
+    __publicField(this, "opts");
+    this.opts = { ...opts, baseUrl: opts.baseUrl.replace(/\/+$/, "") };
+  }
+  /**
+   * Perform a request and return the body as text.
+   *
+   * Legacy endpoints answer HTTP 200 with a prose error, so a 2xx here is not
+   * proof of success: recognised prose errors are thrown, and anything else is
+   * handed back for the caller to parse.
+   */
+  async text(opts) {
+    const response = await this.send(opts);
+    const text = await response.text();
+    if (!response.ok) throw errorFromResponse(response, text);
+    const prose = classifyProse(text, response.status);
+    if (prose) throw prose;
+    return text;
+  }
+  /** Perform a request against one of the endpoints that returns real JSON. */
+  async json(opts) {
+    const response = await this.send(opts);
+    const text = await response.text();
+    if (!response.ok) throw errorFromResponse(response, text);
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new ApiError("malformed_response", "The API returned a response that was not valid JSON.", {
+        raw: text,
+        status: response.status
+      });
+    }
+  }
+  async send(opts) {
+    const method = opts.method ?? "POST";
+    const target = `${this.opts.baseUrl}/${opts.path.replace(/^\/+/, "")}`;
+    const fields = {};
+    for (const [key, value] of Object.entries(opts.body ?? {})) {
+      if (value !== void 0) fields[key] = String(value);
+    }
+    if (!opts.anonymous) fields.api_key = this.opts.apiKey;
+    const headers = { "User-Agent": `skrybe-sdk-ts/${VERSION}` };
+    let url = target;
+    let body;
+    if (method === "GET") {
+      const query = new URLSearchParams(fields).toString();
+      if (query !== "") url = `${target}?${query}`;
+    } else if (opts.encoding === "json") {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(fields);
+    } else {
+      headers["Content-Type"] = "application/x-www-form-urlencoded";
+      body = new URLSearchParams(fields).toString();
+    }
+    const attempts = opts.retryable ? this.opts.maxRetries + 1 : 1;
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.opts.timeoutMs);
+      try {
+        const response = await this.opts.fetch(url, { method, headers, body, signal: controller.signal });
+        if (RETRYABLE_STATUS.has(response.status) && attempt < attempts) {
+          await response.text().catch(() => void 0);
+          await delay(backoffMs(attempt, response.headers.get("retry-after")));
+          continue;
+        }
+        return response;
+      } catch (err) {
+        lastError = err;
+        if (isAbort(err)) {
+          throw new ConnectionError("timeout", `Request to ${target} timed out after ${this.opts.timeoutMs}ms.`, {
+            cause: err
+          });
+        }
+        if (attempt < attempts) {
+          await delay(backoffMs(attempt, null));
+          continue;
+        }
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw new ConnectionError(
+      "network_error",
+      `Could not reach ${this.opts.baseUrl}: ${lastError?.message ?? "unknown error"}`,
+      { cause: lastError }
+    );
+  }
+};
+function errorFromResponse(response, text) {
+  let message = text.trim();
+  try {
+    const parsed = JSON.parse(text);
+    const extracted = parsed.error ?? parsed.message;
+    if (typeof extracted === "string" && extracted !== "") message = extracted;
+  } catch {
+  }
+  if (message === "") message = `HTTP ${response.status} from the Skrybe API.`;
+  return createError(typeForStatus(response.status), codeForStatus(response.status), message, {
+    raw: text,
+    status: response.status
+  });
+}
+function backoffMs(attempt, retryAfter) {
+  if (retryAfter) {
+    const seconds = Number.parseInt(retryAfter, 10);
+    if (!Number.isNaN(seconds) && seconds >= 0) return Math.min(seconds * 1e3, 3e4);
+  }
+  return 2 ** (attempt - 1) * 500 + Math.floor(Math.random() * 250);
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbort(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://dashboard.skry.be";
+var Skrybe = class {
+  constructor(options) {
+    __publicField(this, "emails");
+    __publicField(this, "campaigns");
+    __publicField(this, "lists");
+    __publicField(this, "subscribers");
+    __publicField(this, "templates");
+    __publicField(this, "autoresponders");
+    __publicField(this, "brands");
+    __publicField(this, "stats");
+    if (!options?.apiKey) {
+      throw new InvalidRequestError("api_key_missing", "An apiKey is required.", {
+        hint: "Generate one in the Skrybe dashboard under Settings."
+      });
+    }
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+      throw new InvalidRequestError("fetch_unavailable", "No global fetch is available in this runtime.", {
+        hint: "Use Node.js 18 or newer, or pass a fetch implementation as `fetch`."
+      });
+    }
+    const transport = new Transport({
+      apiKey: options.apiKey,
+      baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+      timeoutMs: options.timeoutMs ?? 3e4,
+      maxRetries: Math.max(0, options.maxRetries ?? 2),
+      // Bound so a fetch that relies on `this` being globalThis still works.
+      fetch: options.fetch ?? ((input, init) => globalThis.fetch(input, init))
+    });
+    this.emails = new Emails(transport);
+    this.campaigns = new Campaigns(transport);
+    this.lists = new Lists(transport);
+    this.subscribers = new Subscribers(transport);
+    this.templates = new Templates(transport);
+    this.autoresponders = new Autoresponders(transport);
+    this.brands = new Brands(transport);
+    this.stats = new Stats(transport);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ACTIVITY_TYPES,
+  ApiError,
+  AuthenticationError,
+  CAMPAIGN_STATUSES,
+  ConnectionError,
+  DEFAULT_BASE_URL,
+  InvalidRequestError,
+  MAX_ACTIVITY_PAGE,
+  MAX_CAMPAIGNS_PAGE,
+  MAX_RECIPIENTS,
+  MAX_SUBSCRIBERS_PAGE,
+  MAX_TEST_EMAILS,
+  RateLimitError,
+  SUBSCRIBER_STATUSES,
+  Skrybe,
+  SkrybeError,
+  VERSION
+});
+//# sourceMappingURL=index.cjs.map