mailchannels-sdk 0.5.0 → 0.6.1

package/dist/mailchannels.mjs

@@ -52,46 +52,92 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
 })(ErrorCode || {});
 const getStatusError = (response, errors = {}) => {
   const statusText = errors[response.status] || "Unknown error.";
-  let details = "";
-  if (typeof response._data === "string") {
-    details = response._data;
-  } else if (response._data?.message) {
-    details = response._data.message;
-  } else if (Array.isArray(response._data?.errors) && response._data.errors.length) {
-    details = response._data.errors.join(", ");
+  const payload = response._data ?? response.data;
+  let details;
+  if (typeof payload === "string") {
+    details = payload;
+  } else if (payload?.message) {
+    details = payload.message;
+  } else if (Array.isArray(payload?.errors) && payload.errors?.length) {
+    details = payload.errors.join(", ");
   }
   return details ? `${statusText} ${details}` : statusText;
 };
+function getResultError(result, error, fallback) {
+  if (result.error) return result.error;
+  return error instanceof Error ? error.message : fallback;
+}
 
+const isValidEmail = (email) => {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+};
 const parseRecipientString = (input) => {
   const trimmed = input.trim();
-  const match = trimmed.match(/^([^<]*)<([^@\s]+@[^>\s]+)>$/);
+  const match = trimmed.match(/^([^<]*)<([^>]*)>$/);
   if (match) {
     const [, name, email] = match;
-    return { email: email?.trim() || "", name: name?.trim() };
+    if (!email?.trim() || !isValidEmail(email.trim())) return void 0;
+    return { email: email.trim(), name: name?.trim() };
   }
+  if (!isValidEmail(trimmed)) return void 0;
   return { email: trimmed };
 };
 const parseRecipient = (recipient) => {
   if (typeof recipient === "string") {
     return parseRecipientString(recipient);
   }
-  if (recipient?.email) {
-    return { email: recipient.email, name: recipient.name };
-  }
+  if (!recipient?.email || !isValidEmail(recipient.email)) return void 0;
+  return { email: recipient.email, name: recipient.name };
 };
 const parseArrayRecipients = (recipients) => {
-  if (!recipients) return;
-  if (typeof recipients === "string") {
-    return [parseRecipientString(recipients)];
-  }
-  if (Array.isArray(recipients)) {
-    return recipients.map((recipient) => parseRecipient(recipient)).filter((recipient) => Boolean(recipient));
-  }
-  return [recipients];
+  if (!recipients) return void 0;
+  const arr = typeof recipients === "string" ? [parseRecipientString(recipients)] : Array.isArray(recipients) ? recipients.map(parseRecipient) : [recipients];
+  const filtered = arr.filter((recipient) => Boolean(recipient));
+  return filtered.length > 0 ? filtered : void 0;
 };
 
 const stripPemHeaders = (pem) => pem.replace(/-----[^-]+-----|\s|#.*$/gm, "");
+const clean = (data) => {
+  if (Array.isArray(data)) {
+    const result = [];
+    for (let i = 0; i < data.length; i++) {
+      const cleaned = clean(data[i]);
+      if (cleaned !== void 0) {
+        result.push(cleaned);
+      }
+    }
+    return result;
+  }
+  if (data && typeof data === "object" && data.constructor === Object) {
+    const result = {};
+    const obj = data;
+    const keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const cleaned = clean(obj[key]);
+      if (cleaned !== void 0) {
+        result[key] = cleaned;
+      }
+    }
+    return result;
+  }
+  return data;
+};
+const validateLimit = (limit, max) => {
+  if (typeof limit === "number" && (limit < 1 || max && limit > max)) {
+    return "The limit value " + (max ? `must be between 1 and ${max}.` : "is invalid. Only positive values are allowed.");
+  }
+  return null;
+};
+const validateOffset = (offset) => {
+  if (typeof offset === "number" && offset < 0) {
+    return "Offset must be greater than or equal to 0.";
+  }
+  return null;
+};
+const mapBuckets = (arr) => {
+  return arr.map(({ count, period_start }) => ({ count, periodStart: period_start }));
+};
 
 class Emails {
   constructor(mailchannels) {
@@ -114,20 +160,20 @@ class Emails {
    */
   async send(options, dryRun = false) {
     const { cc, bcc, from, to, html, text, mustaches, dkim } = options;
-    const data = { success: false, data: null, error: null };
+    const result = { success: false, data: null, error: null };
     const parsedFrom = parseRecipient(from);
     if (!parsedFrom || !parsedFrom.email) {
-      data.error = "No sender provided. Use the `from` option to specify a sender";
-      return data;
+      result.error = "No sender provided. Use the `from` option to specify a sender";
+      return result;
     }
     const parsedTo = parseArrayRecipients(to);
     if (!parsedTo || !parsedTo.length) {
-      data.error = "No recipients provided. Use the `to` option to specify at least one recipient";
-      return data;
+      result.error = "No recipients provided. Use the `to` option to specify at least one recipient";
+      return result;
     }
     if (!text && !html) {
-      data.error = "No email content provided";
-      return data;
+      result.error = "No email content provided";
+      return result;
     }
     const content = [];
     const template_type = mustaches ? "mustache" : void 0;
@@ -161,28 +207,31 @@ class Emails {
       body: payload,
       onResponse: async ({ response: response2 }) => {
         if (response2.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request.",
           [ErrorCode.Forbidden]: "User does not have access to this feature.",
           [ErrorCode.PayloadTooLarge]: "The total message size should not exceed 30MB. This includes the message itself, headers, and the combined size of any attachments."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.data = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to send email.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       rendered: response.data,
       requestId: response.request_id,
-      results: response.results?.map((result) => ({
-        index: result.index,
-        messageId: result.message_id,
-        reason: result.reason,
-        status: result.status
+      results: response.results?.map((result2) => ({
+        index: result2.index,
+        messageId: result2.message_id,
+        reason: result2.reason,
+        status: result2.status
       }))
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Validates a domain's email authentication setup by retrieving its DKIM, SPF, and Domain Lockdown status. This endpoint checks whether the domain is properly configured for secure email delivery.
@@ -204,7 +253,7 @@ class Emails {
   async checkDomain(options) {
     const { dkim, domain, senderId } = options;
     const dkimOptions = dkim ? Array.isArray(dkim) ? dkim : [dkim] : void 0;
-    const data = { results: null, error: null };
+    const result = { data: null, error: null };
     const payload = {
       dkim_settings: dkimOptions?.map(({ domain: domain2, privateKey, selector }) => ({
         dkim_domain: domain2,
@@ -217,14 +266,17 @@ class Emails {
     const response = await this.mailchannels.post("/tx/v1/check-domain", {
       body: payload,
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request.",
           [ErrorCode.Forbidden]: "User does not have access to this feature."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.results = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to check domain.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       dkim: response.check_results.dkim.map((dkimResults) => ({
         domain: dkimResults.dkim_domain,
         keyStatus: dkimResults.dkim_key_status,
@@ -236,8 +288,8 @@ class Emails {
       senderDomain: response.check_results.sender_domain,
       spf: response.check_results.spf,
       references: response.references
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Create a DKIM key pair for a specified domain and selector using the specified algorithm and key length, for the current customer.
@@ -246,17 +298,17 @@ class Emails {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { key, error } = await mailchannels.emails.createDkimKey('example.com', {
+   * const { data, error } = await mailchannels.emails.createDkimKey('example.com', {
    *   selector: 'mailchannels'
    * })
    * ```
    */
   async createDkimKey(domain, options) {
-    const data = { key: null, error: null };
+    const result = { data: null, error: null };
     if (!options.selector || options.selector.length > 63) {
-      data.error = "Selector must be between 1 and 63 characters.";
+      result.error = "Selector must be between 1 and 63 characters.";
     }
-    if (data.error) return data;
+    if (result.error) return result;
     const payload = {
       algorithm: options.algorithm,
       key_length: options.length,
@@ -265,52 +317,51 @@ class Emails {
     const response = await this.mailchannels.post(`/tx/v1/domains/${domain}/dkim-keys`, {
       body: payload,
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request.",
-          [ErrorCode.Conflict]: "Key pair already created for customer_handle, domain, and selector."
+          [ErrorCode.Conflict]: "Key pair already created for domain, and selector."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.key = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to create DKIM key.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       algorithm: response.algorithm,
       createdAt: response.created_at,
       dnsRecords: response.dkim_dns_records,
       domain: response.domain,
+      gracePeriodExpiresAt: response.gracePeriodExpiresAt,
       length: response.key_length,
       publicKey: response.public_key,
+      retiresAt: response.retiresAt,
       selector: response.selector,
       status: response.status,
       statusModifiedAt: response.status_modified_at
-    };
-    return data;
+    });
+    return result;
   }
   /**
-   * Search for DKIM keys by customer handle and domain, with optional filters. If selector is provided, at most one key will be returned.
+   * Search for DKIM keys by domain, with optional filters. If selector is provided, at most one key will be returned.
    * @param domain - The domain to search DKIM keys for.
    * @param options - The options to filter DKIM keys by.
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { keys } = await mailchannels.getDkimKeys('example.com', {
+   * const { data, error } = await mailchannels.getDkimKeys('example.com', {
    *   includeDnsRecord: true
    * })
    * ```
    */
   async getDkimKeys(domain, options) {
-    const data = { keys: [], error: null };
+    const result = { data: null, error: null };
     if (options?.selector && options.selector.length > 63) {
-      data.error = "Selector must be a maximum of 63 characters.";
-      return data;
-    }
-    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 100)) {
-      data.error = "Limit must be between 1 and 100.";
-      return data;
-    }
-    if (typeof options?.offset === "number" && options.offset < 0) {
-      data.error = "Offset value is invalid. Only positive values are allowed.";
-      return data;
+      result.error = "Selector must be between 1 and 63 characters.";
+      return result;
     }
+    result.error = validateLimit(options?.limit, 100) || validateOffset(options?.offset);
+    if (result.error) return result;
     const payload = {
       selector: options?.selector,
       status: options?.status,
@@ -321,24 +372,29 @@ class Emails {
     const response = await this.mailchannels.get(`/tx/v1/domains/${domain}/dkim-keys`, {
       query: payload,
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.keys = response.keys.map((key) => ({
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch DKIM keys.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.keys.map((key) => ({
       algorithm: key.algorithm,
       createdAt: key.created_at,
       dnsRecords: key.dkim_dns_records,
       domain: key.domain,
+      gracePeriodExpiresAt: key.gracePeriodExpiresAt,
       length: key.key_length,
       publicKey: key.public_key,
+      retiresAt: key.retiresAt,
       selector: key.selector,
       status: key.status,
       statusModifiedAt: key.status_modified_at
-    }));
-    return data;
+    })));
+    return result;
   }
   /**
    * Update fields of an existing DKIM key pair for the specified domain and selector, for the current customer. Currently, only the `status` field can be updated.
@@ -347,16 +403,16 @@ class Emails {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.emails.updateDkimKey('example.com', {
+   * const { success, error } = await mailchannels.emails.updateDkimKey('example.com', {
    *   selector: 'mailchannels',
    *   status: 'retired'
    * })
    */
   async updateDkimKey(domain, options) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!options.selector || options.selector.length > 63) {
-      data.error = "Selector must be between 1 and 63 characters.";
-      return data;
+      result.error = "Selector must be between 1 and 63 characters.";
+      return result;
     }
     const payload = {
       status: options.status
@@ -366,16 +422,93 @@ class Emails {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.NotFound]: "Specified key pair not found, or no active key for rotation. This may also occur if the DKIM domain or selector path parameter is missing."
+        });
+      }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to update DKIM key.");
+    });
+    return result;
+  }
+  /**
+   * Rotate an active DKIM key pair. Mark the original key as `rotated`, and create a new key pair with the required new key selector, reusing the same algorithm and key length. The rotated key remains valid for signing for a 3-day grace period, and is automatically changed to `retired` 2 weeks after rotation. Publish the new key to its DNS TXT record before rotated key expires for signing as emails sent with an unpublished key will fail DKIM validation by receiving providers. After the grace period, only the new key is valid for signing if published.
+   * @param domain - The domain the DKIM key belongs to.
+   * @param selector - The selector of the DKIM key to rotate.
+   * @param options - The options to rotate the DKIM key.
+   * @param options.newKey.selector - The selector for the new key pair. Must be a maximum of 63 characters.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.emails.rotateDkimKey('example.com', 'mailchannels', {
+   *   newKey: {
+   *     selector: 'new-selector'
+   *   }
+   * })
+   * ```
+   */
+  async rotateDkimKey(domain, selector, options) {
+    const result = { data: null, error: null };
+    if (!selector || selector.length > 63) {
+      result.error = "Selector must be between 1 and 63 characters.";
+      return result;
+    }
+    if (!options.newKey.selector || options.newKey.selector.length > 63) {
+      result.error = "New key selector must be between 1 and 63 characters.";
+      return result;
+    }
+    const payload = {
+      new_key: {
+        selector: options.newKey.selector
+      }
+    };
+    const response = await this.mailchannels.post(`/tx/v1/domains/${domain}/dkim-keys/${selector}/rotate`, {
+      body: payload,
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request.",
-          [ErrorCode.NotFound]: "Specified key pair not found, or the DKIM domain or selector path parameter is missing."
+          [ErrorCode.NotFound]: "Specified key pair not found.",
+          [ErrorCode.Conflict]: "Key pair already created for domain, and provided new key selector."
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to rotate DKIM key.");
+      return null;
     });
-    return data;
+    if (!response) return result;
+    result.data = clean({
+      new: {
+        algorithm: response.new_key.algorithm,
+        createdAt: response.new_key.created_at,
+        dnsRecords: response.new_key.dkim_dns_records,
+        domain: response.new_key.domain,
+        gracePeriodExpiresAt: response.new_key.gracePeriodExpiresAt,
+        length: response.new_key.key_length,
+        publicKey: response.new_key.public_key,
+        retiresAt: response.new_key.retiresAt,
+        selector: response.new_key.selector,
+        status: response.new_key.status,
+        statusModifiedAt: response.new_key.status_modified_at
+      },
+      rotated: {
+        algorithm: response.rotated_key.algorithm,
+        createdAt: response.rotated_key.created_at,
+        dnsRecords: response.rotated_key.dkim_dns_records,
+        domain: response.rotated_key.domain,
+        gracePeriodExpiresAt: response.rotated_key.gracePeriodExpiresAt,
+        length: response.rotated_key.key_length,
+        publicKey: response.rotated_key.public_key,
+        retiresAt: response.rotated_key.retiresAt,
+        selector: response.rotated_key.selector,
+        status: response.rotated_key.status,
+        statusModifiedAt: response.rotated_key.status_modified_at
+      }
+    });
+    return result;
   }
 }
 
@@ -389,18 +522,18 @@ class Webhooks {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = mailchannels.webhooks.enroll('https://example.com/api/webhooks/mailchannels')
+   * const { success, error } = mailchannels.webhooks.enroll('https://example.com/api/webhooks/mailchannels')
    * ```
    */
   async enroll(endpoint) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!endpoint) {
-      data.error = "No endpoint provided.";
-      return data;
+      result.error = "No endpoint provided.";
+      return result;
     }
     if (endpoint.length > 8e3) {
-      data.error = "The endpoint exceeds the maximum length of 8000 characters.";
-      return data;
+      result.error = "The endpoint exceeds the maximum length of 8000 characters.";
+      return result;
     }
     await this.mailchannels.post("/tx/v1/webhook", {
       query: {
@@ -409,55 +542,63 @@ class Webhooks {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.Conflict]: `Endpoint '${endpoint}' is already enrolled to receive notifications.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to enroll webhook.");
     });
-    return data;
+    return result;
   }
   /**
    * Retrieves all registered webhook endpoints associated with the customer.
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { webhooks } = await mailchannels.webhooks.list()
+   * const { data, error } = await mailchannels.webhooks.list()
    * ```
    */
   async list() {
-    const data = { webhooks: [], error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.get("/tx/v1/webhook", {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2);
+        result.error = getStatusError(response2);
       }
-    }).catch(() => []);
-    data.webhooks = response.map(({ webhook }) => webhook);
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch webhooks.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.map(({ webhook }) => webhook));
+    return result;
   }
   /**
    * Deletes all registered webhook endpoints for the customer.
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.webhooks.delete()
+   * const { success, error } = await mailchannels.webhooks.delete()
    * ```
    */
   async delete() {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     await this.mailchannels.delete("/tx/v1/webhook", {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (!response.ok) {
-          data.error = getStatusError(response);
+          result.error = getStatusError(response);
           return;
         }
-        data.success = true;
+        result.success = true;
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete webhooks.");
     });
-    return data;
+    return result;
   }
   /**
    * Retrieves the public key used to verify signatures on incoming webhook payloads.
@@ -465,24 +606,28 @@ class Webhooks {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { key } = await mailchannels.webhooks.getSigningKey('key-id')
+   * const { data, error } = await mailchannels.webhooks.getSigningKey('key-id')
    * ```
    */
   async getSigningKey(id) {
-    const data = { key: null, error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.get("/tx/v1/webhook/public-key", {
       query: {
         id
       },
-      onResponseError: ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request.",
           [ErrorCode.NotFound]: `The key '${id}' is not found.`
         });
       }
-    }).catch(() => null);
-    data.key = response?.key || null;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to get signing key.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({ key: response.key });
+    return result;
   }
   /**
    * Validates whether your enrolled webhook(s) respond with an HTTP `2xx` status code. Sends a test request to each webhook containing your customer handle, a hardcoded event type (`test`), a hardcoded sender email (`test@mailchannels.com`), a timestamp, a request ID (provided or generated), and an SMTP ID. The response includes the HTTP status code and body returned by each webhook.
@@ -490,31 +635,35 @@ class Webhooks {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { allPassed, results } = await mailchannels.webhooks.validate('optional-request-id')
+   * const { data, error } = await mailchannels.webhooks.validate('optional-request-id')
    * ```
    */
   async validate(requestId) {
-    const data = { allPassed: false, results: [], error: null };
+    const result = { data: null, error: null };
     if (requestId && requestId.length > 28) {
-      data.error = "The request id should not exceed 28 characters.";
-      return data;
+      result.error = "The request id should not exceed 28 characters.";
+      return result;
     }
     const response = await this.mailchannels.post("/tx/v1/webhook/validate", {
       body: {
         request_id: requestId
       },
-      onResponseError: ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request.",
           [ErrorCode.NotFound]: "No webhooks found for the account."
         });
       }
-    }).catch(() => null);
-    if (response) {
-      data.allPassed = response.all_passed;
-      data.results = response.results;
-    }
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to validate webhooks.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
+      allPassed: response.all_passed,
+      results: response.results
+    });
+    return result;
   }
 }
 
@@ -531,21 +680,21 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { account } = await mailchannels.subAccounts.create('My Company', 'validhandle123')
+   * const { data, error } = await mailchannels.subAccounts.create('My Company', 'validhandle123')
    * ```
    */
   async create(companyName, handle) {
-    const data = { account: null, error: null };
+    const result = { data: null, error: null };
     const isValidCompany = SubAccounts.COMPANY_PATTERN.test(companyName);
     if (!isValidCompany) {
-      data.error = "Invalid company name. Company name must be between 3 and 128 characters.";
-      return data;
+      result.error = "Invalid company name. Company name must be between 3 and 128 characters.";
+      return result;
     }
     if (handle) {
       const isValidHandle = SubAccounts.HANDLE_PATTERN.test(handle);
       if (!isValidHandle) {
-        data.error = "Invalid handle. Sub-account handle must be between 3 and 128 characters and contain only lowercase letters and numbers.";
-        return data;
+        result.error = "Invalid handle. Sub-account handle must be between 3 and 128 characters and contain only lowercase letters and numbers.";
+        return result;
       }
     }
     const response = await this.mailchannels.post("/tx/v1/sub-account", {
@@ -553,20 +702,23 @@ class SubAccounts {
         company_name: companyName,
         handle
       },
-      onResponseError: ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
           [ErrorCode.Forbidden]: "The parent account does not have permission to create sub-accounts.",
           [ErrorCode.Conflict]: `Sub-account with handle '${handle}' already exists.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.account = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to create sub-account.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       companyName: response.company_name,
       enabled: response.enabled,
       handle: response.handle
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Retrieves all sub-accounts associated with the parent account. The response is paginated with a default limit of 1000 sub-accounts per page and an offset of 0.
@@ -574,57 +726,57 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { accounts } = await mailchannels.subAccounts.list()
+   * const { data, error } = await mailchannels.subAccounts.list()
    * ```
    */
   async list(options) {
-    const data = { accounts: [], error: null };
-    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 1e3)) {
-      data.error = "The limit value is invalid. Possible limit values are 1 to 1000.";
-      return data;
-    }
-    if (typeof options?.offset === "number" && options.offset < 0) {
-      data.error = "Offset must be greater than or equal to 0.";
-      return data;
-    }
+    const result = { data: null, error: null };
+    result.error = validateLimit(options?.limit, 1e3) || validateOffset(options?.offset);
+    if (result.error) return result;
     const response = await this.mailchannels.get("/tx/v1/sub-account", {
       query: options,
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2);
+        result.error = getStatusError(response2);
       }
-    }).catch(() => []);
-    data.accounts = response.map((account) => ({
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch sub-accounts.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.map((account) => ({
       companyName: account.company_name,
       enabled: account.enabled,
       handle: account.handle
-    }));
-    return data;
+    })));
+    return result;
   }
   /**
    * Deletes the sub-account identified by its handle.
    * @param handle - Handle of sub-account to be deleted.
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.subAccounts.delete('validhandle123')
+   * const { success, error } = await mailchannels.subAccounts.delete('validhandle123')
    * ```
    */
   async delete(handle) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     await this.mailchannels.delete(`/tx/v1/sub-account/${handle}`, {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (!response.ok) {
-          data.error = getStatusError(response);
+          result.error = getStatusError(response);
           return;
         }
-        data.success = true;
+        result.success = true;
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete sub-account.");
     });
-    return data;
+    return result;
   }
   /**
    * Suspends the sub-account identified by its handle. This action disables the account, preventing it from sending any emails until it is reactivated.
@@ -632,28 +784,30 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.subAccounts.suspend('validhandle123')
+   * const { success, error } = await mailchannels.subAccounts.suspend('validhandle123')
    * ```
    */
   async suspend(handle) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     await this.mailchannels.post(`/tx/v1/sub-account/${handle}/suspend`, {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.NotFound]: `The specified sub-account '${handle}' does not exist.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to suspend sub-account.");
     });
-    return data;
+    return result;
   }
   /**
    * Activates a suspended sub-account identified by its handle, restoring its ability to send emails.
@@ -661,29 +815,31 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.subAccounts.activate('validhandle123')
+   * const { success, error } = await mailchannels.subAccounts.activate('validhandle123')
    * ```
    */
   async activate(handle) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     await this.mailchannels.post(`/tx/v1/sub-account/${handle}/activate`, {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.Forbidden]: "The parent account does not have permission to activate the sub-account.",
           [ErrorCode.NotFound]: `The specified sub-account '${handle}' does not exist.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to activate sub-account.");
     });
-    return data;
+    return result;
   }
   /**
    * Creates a new API key for the specified sub-account.
@@ -691,30 +847,33 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { key } = await mailchannels.subAccounts.createApiKey('validhandle123')
+   * const { data, error } = await mailchannels.subAccounts.createApiKey('validhandle123')
    * ```
    */
   async createApiKey(handle) {
-    const data = { key: null, error: null };
+    const result = { data: null, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     const response = await this.mailchannels.post(`/tx/v1/sub-account/${handle}/api-key`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.Forbidden]: "You can't create API keys for this sub-account.",
           [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`,
           [ErrorCode.UnprocessableEntity]: "You have reached the limit of API keys you can create for this sub-account."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.key = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to create sub-account API key.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       id: response.id,
       value: response.key
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Retrieves details of all API keys associated with the specified sub-account. For security reasons, the full API key is not returned; only the key ID and a partially redacted version are provided.
@@ -723,35 +882,33 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { keys } = await mailchannels.subAccounts.listApiKeys('validhandle123')
+   * const { data, error } = await mailchannels.subAccounts.listApiKeys('validhandle123')
    * ```
    */
   async listApiKeys(handle, options) {
-    const data = { keys: [], error: null };
+    const result = { data: null, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
-    }
-    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 1e3)) {
-      data.error = "The limit value is invalid. Possible limit values are 1 to 1000.";
-      return data;
-    }
-    if (typeof options?.offset === "number" && options.offset < 0) {
-      data.error = "Offset must be greater than or equal to 0.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
+    result.error = validateLimit(options?.limit, 1e3) || validateOffset(options?.offset);
+    if (result.error) return result;
     const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/api-key`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
         });
       }
-    }).catch(() => []);
-    data.keys = response.map((key) => ({
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch sub-account API keys.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.map((key) => ({
       id: key.id,
       value: key.key
-    }));
-    return data;
+    })));
+    return result;
   }
   /**
    * Deletes the API key identified by its ID for the specified sub-account.
@@ -760,28 +917,30 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.subAccounts.deleteApiKey('validhandle123', 1)
+   * const { success, error } = await mailchannels.subAccounts.deleteApiKey('validhandle123', 1)
    * ```
    */
   async deleteApiKey(handle, id) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     await this.mailchannels.delete(`/tx/v1/sub-account/${handle}/api-key/${id}`, {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.BadRequest]: "Missing or invalid API key ID."
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete sub-account API key.");
     });
-    return data;
+    return result;
   }
   /**
    * Creates a new SMTP password for the specified sub-account.
@@ -789,31 +948,34 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { password } = await mailchannels.subAccounts.createSmtpPassword('validhandle123')
+   * const { data, error } = await mailchannels.subAccounts.createSmtpPassword('validhandle123')
    * ```
    */
   async createSmtpPassword(handle) {
-    const data = { password: null, error: null };
+    const result = { data: null, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     const response = await this.mailchannels.post(`/tx/v1/sub-account/${handle}/smtp-password`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.Forbidden]: "You can't create SMTP passwords for this sub-account.",
           [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`,
           [ErrorCode.UnprocessableEntity]: "You have reached the limit of SMTP passwords you can create for this sub-account."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.password = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to create sub-account SMTP password.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       enabled: response.enabled,
       id: response.id,
       value: response.smtp_password
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Retrieves details of all SMTP passwords associated with the specified sub-account. For security, the full SMTP password is not returned; only the password ID and a partially redacted version are provided.
@@ -821,28 +983,32 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { passwords } = await mailchannels.subAccounts.listSmtpPasswords('validhandle123')
+   * const { data, error } = await mailchannels.subAccounts.listSmtpPasswords('validhandle123')
    * ```
    */
   async listSmtpPasswords(handle) {
-    const data = { passwords: [], error: null };
+    const result = { data: null, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/smtp-password`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
         });
       }
-    }).catch(() => []);
-    data.passwords = response.map((password) => ({
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch sub-account SMTP passwords.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.map((password) => ({
       enabled: password.enabled,
       id: password.id,
       value: password.smtp_password
-    }));
-    return data;
+    })));
+    return result;
   }
   /**
    * Deletes the SMTP password identified by its ID for the specified sub-account.
@@ -851,28 +1017,30 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.subAccounts.deleteSmtpPassword('validhandle123', 1)
+   * const { success, error } = await mailchannels.subAccounts.deleteSmtpPassword('validhandle123', 1)
    * ```
    */
   async deleteSmtpPassword(handle, id) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     await this.mailchannels.delete(`/tx/v1/sub-account/${handle}/smtp-password/${id}`, {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.BadRequest]: "Missing or invalid SMTP password ID."
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete sub-account SMTP password.");
     });
-    return data;
+    return result;
   }
   /**
    * Retrieves the limit of a specified sub-account. A value of `-1` indicates that the sub-account inherits the parent account's limit, allowing the sub-account to utilize any remaining capacity within the parent account's allocation.
@@ -880,25 +1048,28 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { limit } = await mailchannels.subAccounts.getLimit('validhandle123')
+   * const { data, error } = await mailchannels.subAccounts.getLimit('validhandle123')
    * ```
    */
   async getLimit(handle) {
-    const data = { limit: null, error: null };
+    const result = { data: null, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/limit`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.limit = response;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch sub-account limit.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response);
+    return result;
   }
   /**
    * Sets the limit for the specified sub-account.
@@ -907,30 +1078,32 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.subAccounts.setLimit('validhandle123', { sends: 1000 })
+   * const { success, error } = await mailchannels.subAccounts.setLimit('validhandle123', { sends: 1000 })
    * ```
    */
   async setLimit(handle, limit) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     await this.mailchannels.put(`/tx/v1/sub-account/${handle}/limit`, {
       body: limit,
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.BadRequest]: "Bad Request.",
           [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to set sub-account limit.");
     });
-    return data;
+    return result;
   }
   /**
    * Deletes the limit for the specified sub-account. After a successful deletion, the specified sub-account will be limited to the parent account's limit.
@@ -938,28 +1111,30 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.subAccounts.deleteLimit('validhandle123')
+   * const { success, error } = await mailchannels.subAccounts.deleteLimit('validhandle123')
    * ```
    */
   async deleteLimit(handle) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     await this.mailchannels.delete(`/tx/v1/sub-account/${handle}/limit`, {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete sub-account limit.");
     });
-    return data;
+    return result;
   }
   /**
    * Retrieves usage statistics for the specified sub-account during the current billing period.
@@ -967,35 +1142,35 @@ class SubAccounts {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { usage } = await mailchannels.subAccounts.getUsage('validhandle123')
+   * const { data, error } = await mailchannels.subAccounts.getUsage('validhandle123')
    * ```
    */
   async getUsage(handle) {
-    const data = { usage: null, error: null };
+    const result = { data: null, error: null };
     if (!handle) {
-      data.error = "No handle provided.";
-      return data;
+      result.error = "No handle provided.";
+      return result;
     }
     const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/usage`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.usage = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch sub-account usage.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       endDate: response.period_end_date,
       startDate: response.period_start_date,
       total: response.total_usage
-    };
-    return data;
+    });
+    return result;
   }
 }
 
-const mapBuckets = (arr) => {
-  return arr.map(({ count, period_start }) => ({ count, periodStart: period_start }));
-};
 class Metrics {
   constructor(mailchannels) {
     this.mailchannels = mailchannels;
@@ -1006,11 +1181,11 @@ class Metrics {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { engagement } = await mailchannels.metrics.engagement()
+   * const { data, error } = await mailchannels.metrics.engagement()
    * ```
    */
   async engagement(options) {
-    const data = { engagement: null, error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.get("/tx/v1/metrics/engagement", {
       query: {
         start_time: options?.startTime,
@@ -1019,13 +1194,16 @@ class Metrics {
         interval: options?.interval
       },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.engagement = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch engagement metrics.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       buckets: {
         click: mapBuckets(response.buckets.click),
         clickTrackingDelivered: mapBuckets(response.buckets.click_tracking_delivered),
@@ -1038,8 +1216,8 @@ class Metrics {
       open: response.open,
       openTrackingDelivered: response.open_tracking_delivered,
       startTime: response.start_time
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Retrieve performance metrics for messages sent from your account, including counts of processed, delivered, hard-bounced events. Supports optional filters for time range, and campaign ID.
@@ -1047,11 +1225,11 @@ class Metrics {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { performance } = await mailchannels.metrics.performance()
+   * const { data, error } = await mailchannels.metrics.performance()
    * ```
    */
   async performance(options) {
-    const data = { performance: null, error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.get("/tx/v1/metrics/performance", {
       query: {
         start_time: options?.startTime,
@@ -1060,13 +1238,16 @@ class Metrics {
         interval: options?.interval
       },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.performance = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch performance metrics.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       bounced: response.bounced,
       buckets: {
         bounced: mapBuckets(response.buckets.bounced),
@@ -1077,8 +1258,8 @@ class Metrics {
       endTime: response.end_time,
       processed: response.processed,
       startTime: response.start_time
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Retrieve recipient behaviour metrics for messages sent from your account, including counts of unsubscribed events. Supports optional filters for time range, and campaign ID.
@@ -1086,11 +1267,11 @@ class Metrics {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { behaviour } = await mailchannels.metrics.recipientBehaviour()
+   * const { data, error } = await mailchannels.metrics.recipientBehaviour()
    * ```
    */
   async recipientBehaviour(options) {
-    const data = { behaviour: null, error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.get("/tx/v1/metrics/recipient-behaviour", {
       query: {
         start_time: options?.startTime,
@@ -1099,13 +1280,16 @@ class Metrics {
         interval: options?.interval
       },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.behaviour = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch recipient behaviour metrics.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       buckets: {
         unsubscribeDelivered: mapBuckets(response.buckets.unsubscribe_delivered),
         unsubscribed: mapBuckets(response.buckets.unsubscribed)
@@ -1114,8 +1298,8 @@ class Metrics {
       startTime: response.start_time,
       unsubscribeDelivered: response.unsubscribe_delivered,
       unsubscribed: response.unsubscribed
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Retrieve volume metrics for messages sent from your account, including counts of processed, delivered and dropped events. Supports optional filters for time range and campaign ID.
@@ -1123,11 +1307,11 @@ class Metrics {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { volume } = await mailchannels.metrics.volume()
+   * const { data, error } = await mailchannels.metrics.volume()
    * ```
    */
   async volume(options) {
-    const data = { volume: null, error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.get("/tx/v1/metrics/volume", {
       query: {
         start_time: options?.startTime,
@@ -1136,13 +1320,16 @@ class Metrics {
         interval: options?.interval
       },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.volume = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch volume metrics.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       buckets: {
         delivered: mapBuckets(response.buckets.delivered),
         dropped: mapBuckets(response.buckets.dropped),
@@ -1153,31 +1340,76 @@ class Metrics {
       endTime: response.end_time,
       processed: response.processed,
       startTime: response.start_time
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Retrieves usage statistics during the current billing period.
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { usage } = await mailchannels.metrics.usage()
+   * const { data, error } = await mailchannels.metrics.usage()
    * ```
    */
   async usage() {
-    const data = { usage: null, error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.get("/tx/v1/usage", {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2);
+        result.error = getStatusError(response2);
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.usage = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch usage metrics.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       endDate: response.period_end_date,
       startDate: response.period_start_date,
       total: response.total_usage
-    };
-    return data;
+    });
+    return result;
+  }
+  /**
+   * Retrieves a list of senders, either sub-accounts or campaigns, with their associated message metrics. Sorted by total # of sent messages (processed + dropped). Supports optional filter for time range, and optional settings for limit, offset, and sort order. Note: senders without any messages in the given time range will not be included in the results. The default time range is from one month ago to now, and the default sort order is descending.
+   * @param type - The type of senders to retrieve metrics for. Can be either `sub-accounts` or `campaigns`.
+   * @param options - Optional filter options for time range, limit, offset, and sort order.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.metrics.senders('campaigns')
+   * ```
+   */
+  async senders(type, options) {
+    const result = { data: null, error: null };
+    result.error = validateLimit(options?.limit, 1e3) || validateOffset(options?.offset);
+    if (result.error) return result;
+    const response = await this.mailchannels.get(`/tx/v1/metrics/senders/${type}`, {
+      query: {
+        start_time: options?.startTime,
+        end_time: options?.endTime,
+        limit: options?.limit,
+        offset: options?.offset,
+        sort_order: options?.sortOrder
+      },
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch senders metrics.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
+      endTime: response.end_time,
+      limit: response.limit,
+      offset: response.offset,
+      senders: response.senders,
+      startTime: response.start_time,
+      total: response.total
+    });
+    return result;
   }
 }
 
@@ -1191,19 +1423,20 @@ class Suppressions {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.suppressions.create({
+   * const { success, error } = await mailchannels.suppressions.create({
    * // ...
    * });
    */
   async create(options) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     const { addToSubAccounts, entries } = options;
     const payload = {
       add_to_sub_accounts: addToSubAccounts,
       suppression_entries: entries.map((entry) => ({
         notes: entry.notes,
         recipient: entry.recipient,
-        suppression_types: Array.from(new Set(entry.types))
+        // Default to non-transactional when caller omits types
+        suppression_types: Array.from(new Set(entry.types || ["non-transactional"]))
       }))
     };
     await this.mailchannels.post("/tx/v1/suppression-list", {
@@ -1211,17 +1444,19 @@ class Suppressions {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.BadRequest]: "Bad Request.",
           [ErrorCode.Conflict]: "Conflict. One or more suppression entries in the request already exist and cannot be created again.",
           [ErrorCode.PayloadTooLarge]: "Payload too large. The request exceeds the maximum allowed total of 1000 suppression entries for the parent account and/or its sub-accounts."
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to create suppression entries.");
     });
-    return data;
+    return result;
   }
   /**
    * Deletes suppression entry associated with the account based on the specified recipient and source.
@@ -1230,11 +1465,11 @@ class Suppressions {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.suppressions.delete('name@example.com', 'api');
+   * const { success, error } = await mailchannels.suppressions.delete('name@example.com', 'api');
    * ```
    */
   async delete(recipient, source) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     await this.mailchannels.delete(`/tx/v1/suppression-list/recipients/${recipient}`, {
       query: {
         source
@@ -1242,35 +1477,31 @@ class Suppressions {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.BadRequest]: "Bad Request."
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete suppression entry.");
     });
-    return data;
+    return result;
   }
   /**
    * Retrieve suppression entries associated with the specified account. Supports filtering by recipient, source and creation date range. The response is paginated, with a default limit of `1000` entries per page and an offset of `0`.
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { list }= await mailchannels.suppressions.list();
+   * const { data, error } = await mailchannels.suppressions.list();
    * ```
    * @param options - Options to filter and customize the suppression entries retrieval.
    */
   async list(options) {
-    const data = { list: [], error: null };
-    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 1e3)) {
-      data.error = "The limit must be between 1 and 1000.";
-      return data;
-    }
-    if (typeof options?.offset === "number" && options.offset < 0) {
-      data.error = "Offset must be greater than or equal to 0.";
-      return data;
-    }
+    const result = { data: null, error: null };
+    result.error = validateLimit(options?.limit, 1e3) || validateOffset(options?.offset);
+    if (result.error) return result;
     const payload = {
       recipient: options?.recipient,
       source: options?.source,
@@ -1282,21 +1513,24 @@ class Suppressions {
     const response = await this.mailchannels.get("/tx/v1/suppression-list", {
       query: payload,
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.list = response.suppression_list.map((entry) => ({
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch suppression entries.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.suppression_list.map((entry) => ({
       createdAt: entry.created_at,
       notes: entry.notes,
       recipient: entry.recipient,
       sender: entry.sender,
       source: entry.source,
       types: entry.suppression_types
-    }));
-    return data;
+    })));
+    return result;
   }
 }
 
@@ -1310,7 +1544,7 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { data } = await mailchannels.domains.provision({
+   * const { data, error } = await mailchannels.domains.provision({
    *   domain: 'example.com',
    *   subscriptionHandle: 'your-subscription-handle'
    * })
@@ -1318,7 +1552,7 @@ class Domains {
    */
   async provision(options) {
     const { associateKey, overwrite, ...payload } = options;
-    const data = { data: null, error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.post("/inbound/v1/domains", {
       query: {
         "associate-key": associateKey,
@@ -1326,15 +1560,18 @@ class Domains {
       },
       body: payload,
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request, returned in the case that an error occurs while converting an A-label domain to a U-label domain name.",
           [ErrorCode.Forbidden]: "The limit on associated domains is reached or you are attempting to associate a domain with a subscription that is not your own.",
           [ErrorCode.Conflict]: `The domain '${options.domain}' is already provisioned, and is associated with a different customer.`
         });
       }
-    }).catch(() => null);
-    data.data = response;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to provision domain.");
+      return null;
+    });
+    result.data = clean(response);
+    return result;
   }
   /**
    * Provision up to 1000 domains to use MailChannels Inbound.
@@ -1343,7 +1580,7 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { results } = await mailchannels.domains.bulkProvision({
+   * const { data, error } = await mailchannels.domains.bulkProvision({
    *   subscriptionHandle: 'your-subscription-handle'
    * }, [
    *   {
@@ -1358,14 +1595,14 @@ class Domains {
    */
   async bulkProvision(options, domains) {
     const { associateKey, overwrite, subscriptionHandle } = options;
-    const data = { results: null, error: null };
+    const result = { data: null, error: null };
     if (!domains || !domains.length) {
-      data.error = "No domains provided.";
-      return data;
+      result.error = "No domains provided.";
+      return result;
     }
     if (domains.length > 1e3) {
-      data.error = "The maximum number of domains to be provisioned is 1000.";
-      return data;
+      result.error = "The maximum number of domains to be provisioned is 1000.";
+      return result;
     }
     const response = await this.mailchannels.post("/inbound/v1/domains/batch", {
       query: {
@@ -1375,15 +1612,18 @@ class Domains {
       },
       body: { domains },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request, returned in the case that a domain name fails RFC 5891 validation.",
           [ErrorCode.Forbidden]: "The limit on associated domains is reached or you are attempting to associate a domain with a subscription that is not your own."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.results = response;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to provision domains.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response);
+    return result;
   }
   /**
    * Fetch a list of all domains associated with this API key.
@@ -1391,29 +1631,28 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { domains } = await mailchannels.domains.list()
+   * const { data, error } = await mailchannels.domains.list()
    * ```
    */
   async list(options) {
-    const data = { domains: [], total: 0, error: null };
-    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 5e3)) {
-      data.error = "The limit value is invalid. Possible limit values are 1 to 5000.";
-      return data;
-    }
-    if (typeof options?.offset === "number" && options.offset < 0) {
-      data.error = "Offset must be greater than or equal to 0.";
-      return data;
-    }
+    const result = { data: null, error: null };
+    result.error = validateLimit(options?.limit, 5e3) || validateOffset(options?.offset);
+    if (result.error) return result;
     const response = await this.mailchannels.get("/inbound/v1/domains", {
       query: options,
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2);
+        result.error = getStatusError(response2);
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.domains = response.domains;
-    data.total = response.total;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch domains.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
+      domains: response.domains,
+      total: response.total
+    });
+    return result;
   }
   /**
    * De-provision a domain to cease protecting it with MailChannels Inbound.
@@ -1421,29 +1660,31 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.domains.delete('example.com')
+   * const { success, error } = await mailchannels.domains.delete('example.com')
    * ```
    */
   async delete(domain) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!domain) {
-      data.error = "No domain provided.";
-      return data;
+      result.error = "No domain provided.";
+      return result;
     }
     await this.mailchannels.delete(`/inbound/v1/domains/${domain}`, {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The domain '${domain}' was not found.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete domain.");
     });
-    return data;
+    return result;
   }
   /**
    * Add an entry to a domain blocklist or safelist.
@@ -1452,7 +1693,7 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { entry } = await mailchannels.domains.addListEntry('example.com', {
+   * const { data, error } = await mailchannels.domains.addListEntry('example.com', {
    *   listName: 'safelist',
    *   item: 'name@domain.com'
    * })
@@ -1460,31 +1701,34 @@ class Domains {
    */
   async addListEntry(domain, options) {
     const { listName, item } = options;
-    const data = { entry: null, error: null };
+    const result = { data: null, error: null };
     if (!domain) {
-      data.error = "No domain provided.";
-      return data;
+      result.error = "No domain provided.";
+      return result;
     }
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     const response = await this.mailchannels.post(`/inbound/v1/domains/${domain}/lists/${listName}`, {
       body: { item },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The domain '${domain}' was not found.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.entry = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to add domain list entry.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       action: response.action,
       item: response.item,
       type: response.item_type
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Get domain list entries.
@@ -1493,34 +1737,37 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { entries } = await mailchannels.domains.listEntries('example.com', 'safelist')
+   * const { data, error } = await mailchannels.domains.listEntries('example.com', 'safelist')
    * ```
    */
   async listEntries(domain, listName) {
-    const data = { entries: [], error: null };
+    const result = { data: null, error: null };
     if (!domain) {
-      data.error = "No domain provided.";
-      return data;
+      result.error = "No domain provided.";
+      return result;
     }
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/lists/${listName}`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The domain '${domain}' was not found.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.entries = response.map(({ action, item, item_type }) => ({
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch domain list entries.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.map(({ action, item, item_type }) => ({
       action,
       item,
       type: item_type
-    }));
-    return data;
+    })));
+    return result;
   }
   /**
    * Delete item from domain list.
@@ -1529,7 +1776,7 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.domains.deleteListEntry('example.com', {
+   * const { success, error } = await mailchannels.domains.deleteListEntry('example.com', {
    *   listName: 'safelist',
    *   item: 'name@domain.com'
    * })
@@ -1537,30 +1784,32 @@ class Domains {
    */
   async deleteListEntry(domain, options) {
     const { listName, item } = options;
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!domain) {
-      data.error = "No domain provided.";
-      return data;
+      result.error = "No domain provided.";
+      return result;
     }
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     await this.mailchannels.delete(`/inbound/v1/domains/${domain}/lists/${listName}`, {
       query: { item },
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The domain '${domain}' was not found.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete domain list entry.");
     });
-    return data;
+    return result;
   }
   /**
    * Generate a link that allows a user to log in as a domain administrator.
@@ -1568,27 +1817,32 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { link } = await mailchannels.domains.createLoginLink('example.com')
+   * const { data, error } = await mailchannels.domains.createLoginLink('example.com')
    * ```
    */
   async createLoginLink(domain) {
-    const data = { link: null, error: null };
+    const result = { data: null, error: null };
     if (!domain) {
-      data.error = "No domain provided.";
-      return data;
+      result.error = "No domain provided.";
+      return result;
     }
     const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/login-link`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.Unauthorized]: "The domain does not belong to this customer.",
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The domain '${domain}' was not found.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.link = response.loginLink;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to create login link.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
+      link: response.loginLink
+    });
+    return result;
   }
   /**
    * Sets the list of downstream addresses for the domain. This action deletes any existing downstream address for the domain before creating new ones. If the `records` parameter is an empty array, all downstream address records will be deleted.
@@ -1597,7 +1851,7 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.domains.setDownstreamAddress('example.com', [
+   * const { success, error } = await mailchannels.domains.setDownstreamAddress('example.com', [
    *   {
    *     port: 25,
    *     priority: 10,
@@ -1608,30 +1862,32 @@ class Domains {
    * ```
    */
   async setDownstreamAddress(domain, records = []) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!domain) {
-      data.error = "No domain provided.";
-      return data;
+      result.error = "No domain provided.";
+      return result;
     }
     if (records.length > 10) {
-      data.error = "The maximum of records to be set is 10.";
-      return data;
+      result.error = "The maximum of records to be set is 10.";
+      return result;
     }
     await this.mailchannels.put(`/inbound/v1/domains/${domain}/downstream-address`, {
       body: { records },
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The domain '${domain}' was not found.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to set downstream address.");
     });
-    return data;
+    return result;
   }
   /**
    * Retrieve stored downstream addresses for the domain.
@@ -1640,35 +1896,32 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { records } = await mailchannels.domains.listDownstreamAddresses('example.com')
+   * const { data, error } = await mailchannels.domains.listDownstreamAddresses('example.com')
    * ```
    */
   async listDownstreamAddresses(domain, options) {
-    const data = { records: [], error: null };
+    const result = { data: null, error: null };
     if (!domain) {
-      data.error = "No domain provided.";
-      return data;
-    }
-    if (typeof options?.limit === "number" && options.limit < 1) {
-      data.error = "The limit value is invalid. Only positive values are allowed.";
-      return data;
-    }
-    if (typeof options?.offset === "number" && options.offset < 0) {
-      data.error = "Offset must be greater than or equal to 0.";
-      return data;
+      result.error = "No domain provided.";
+      return result;
     }
+    result.error = validateLimit(options?.limit) || validateOffset(options?.offset);
+    if (result.error) return result;
     const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/downstream-address`, {
       query: options,
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The domain '${domain}' was not found.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.records = response.records;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to list downstream addresses.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.records);
+    return result;
   }
   /**
    * Update the API key that is associated with a domain.
@@ -1677,34 +1930,36 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.domains.updateApiKey('example.com', 'your-api-key')
+   * const { success, error } = await mailchannels.domains.updateApiKey('example.com', 'your-api-key')
    * ```
    */
   async updateApiKey(domain, key) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!domain) {
-      data.error = "No domain provided.";
-      return data;
+      result.error = "No domain provided.";
+      return result;
     }
     if (!key) {
-      data.error = "No API key provided.";
-      return data;
+      result.error = "No API key provided.";
+      return result;
     }
     await this.mailchannels.put(`/inbound/v1/domains/${domain}/api-key`, {
       body: { apiKey: key },
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: "The domain does not exist."
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to update domain API key.");
     });
-    return data;
+    return result;
   }
   /**
    * Generate a batch of links that allow a user to log in as a domain administrator to their different domains.
@@ -1712,32 +1967,35 @@ class Domains {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { results } = await mailchannels.domains.bulkCreateLoginLinks(['example.com', 'example2.com'])
+   * const { data, error } = await mailchannels.domains.bulkCreateLoginLinks(['example.com', 'example2.com'])
    * ```
    */
   async bulkCreateLoginLinks(domains) {
-    const data = { results: null, error: null };
+    const result = { data: null, error: null };
     if (!domains || !domains.length) {
-      data.error = "No domains provided.";
-      return data;
+      result.error = "No domains provided.";
+      return result;
     }
     if (domains.length > 1e3) {
-      data.error = "The maximum number of domains to create login links for is 1000.";
-      return data;
+      result.error = "The maximum number of domains to create login links for is 1000.";
+      return result;
     }
     const response = await this.mailchannels.post("/inbound/v1/domains/batch/login-link", {
       body: {
         domains: domains.map((domain) => ({ domain }))
       },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: "Bad Request."
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.results = response;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to create login links.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response);
+    return result;
   }
 }
 
@@ -1751,7 +2009,7 @@ class Lists {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { entry } = await mailchannels.lists.addListEntry({
+   * const { data, error } = await mailchannels.lists.addListEntry({
    *   listName: 'safelist',
    *   item: 'name@domain.com'
    * })
@@ -1759,24 +2017,27 @@ class Lists {
    */
   async addListEntry(options) {
     const { listName, item } = options;
-    const data = { entry: null, error: null };
+    const result = { data: null, error: null };
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     const response = await this.mailchannels.post(`/inbound/v1/lists/${listName}`, {
       body: { item },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2);
+        result.error = getStatusError(response2);
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.entry = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to add list entry.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       action: response.action,
       item: response.item,
       type: response.item_type
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Get account-level list entries.
@@ -1784,27 +2045,30 @@ class Lists {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { entries } = await mailchannels.lists.listEntries('safelist')
+   * const { data, error } = await mailchannels.lists.listEntries('safelist')
    * ```
    */
   async listEntries(listName) {
-    const data = { entries: [], error: null };
+    const result = { data: null, error: null };
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     const response = await this.mailchannels.get(`/inbound/v1/lists/${listName}`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2);
+        result.error = getStatusError(response2);
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.entries = response.map(({ action, item, item_type }) => ({
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch list entries.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.map(({ action, item, item_type }) => ({
       action,
       item,
       type: item_type
-    }));
-    return data;
+    })));
+    return result;
   }
   /**
    * Delete item from account-level list.
@@ -1812,7 +2076,7 @@ class Lists {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.lists.deleteListEntry({
+   * const { success, error } = await mailchannels.lists.deleteListEntry({
    *   listName: 'safelist',
    *   item: 'name@domain.com'
    * })
@@ -1820,23 +2084,25 @@ class Lists {
    */
   async deleteListEntry(options) {
     const { listName, item } = options;
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     await this.mailchannels.delete(`/inbound/v1/lists/${listName}`, {
       query: { item },
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response);
+        result.error = getStatusError(response);
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete list entry.");
     });
-    return data;
+    return result;
   }
 }
 
@@ -1851,17 +2117,17 @@ class Users {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { user } = await mailchannels.users.create("name@example.com", {
+   * const { data, error } = await mailchannels.users.create("name@example.com", {
    *   admin: true
    * })
    * ```
    */
   async create(email, options) {
     const { admin, filter, listEntries } = options || {};
-    const data = { user: null, error: null };
+    const result = { data: null, error: null };
     if (!email) {
-      data.error = "No email address provided.";
-      return data;
+      result.error = "No email address provided.";
+      return result;
     }
     const response = await this.mailchannels.put("/inbound/v1/users", {
       query: {
@@ -1873,13 +2139,16 @@ class Users {
         list_entries: listEntries
       },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.BadRequest]: `The email address '${email}' is invalid.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.user = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to create user.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       email: response.recipient.email_address,
       roles: response.recipient.roles,
       filter: response.recipient.filter,
@@ -1888,8 +2157,8 @@ class Users {
         type: item_type,
         action
       }))
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Add item to recipient user list
@@ -1898,7 +2167,7 @@ class Users {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { entry } = await mailchannels.users.addListEntry('name@example.com', {
+   * const { data, error } = await mailchannels.users.addListEntry('name@example.com', {
    *   listName: 'safelist',
    *   item: 'name@domain.com'
    * })
@@ -1906,31 +2175,34 @@ class Users {
    */
   async addListEntry(email, options) {
     const { listName, item } = options;
-    const data = { entry: null, error: null };
+    const result = { data: null, error: null };
     if (!email) {
-      data.error = "No email provided.";
-      return data;
+      result.error = "No email provided.";
+      return result;
     }
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     const response = await this.mailchannels.post(`/inbound/v1/users/${email}/lists/${listName}`, {
       body: { item },
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The recipient '${email}' was not found.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.entry = {
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to add user list entry.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
       action: response.action,
       item: response.item,
       type: response.item_type
-    };
-    return data;
+    });
+    return result;
   }
   /**
    * Get recipient list entries.
@@ -1939,34 +2211,37 @@ class Users {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { entries } = await mailchannels.users.listEntries('name@example.com', 'safelist')
+   * const { data, error } = await mailchannels.users.listEntries('name@example.com', 'safelist')
    * ```
    */
   async listEntries(email, listName) {
-    const data = { entries: [], error: null };
+    const result = { data: null, error: null };
     if (!email) {
-      data.error = "No email provided.";
-      return data;
+      result.error = "No email provided.";
+      return result;
     }
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     const response = await this.mailchannels.get(`/inbound/v1/users/${email}/lists/${listName}`, {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The recipient '${email}' was not found.`
         });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.entries = response.map(({ action, item, item_type }) => ({
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch user list entries.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response.map(({ action, item, item_type }) => ({
       action,
       item,
       type: item_type
-    }));
-    return data;
+    })));
+    return result;
   }
   /**
    * Delete item from recipient list.
@@ -1975,7 +2250,7 @@ class Users {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.users.deleteListEntry('name@example.com', {
+   * const { success, error } = await mailchannels.users.deleteListEntry('name@example.com', {
    *   listName: 'safelist',
    *   item: 'name@domain.com'
    * })
@@ -1983,30 +2258,32 @@ class Users {
    */
   async deleteListEntry(email, options) {
     const { listName, item } = options;
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     if (!email) {
-      data.error = "No email provided.";
-      return data;
+      result.error = "No email provided.";
+      return result;
     }
     if (!listName) {
-      data.error = "No list name provided.";
-      return data;
+      result.error = "No list name provided.";
+      return result;
     }
     await this.mailchannels.delete(`/inbound/v1/users/${email}/lists/${listName}`, {
       query: { item },
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response, {
+        result.error = getStatusError(response, {
           [ErrorCode.Forbidden]: "The domain is associated with an api key that is different than the one in the request, the domain is associated with a different customer, or the domain in the request is an alias domain.",
           [ErrorCode.NotFound]: `The recipient '${email}' was not found.`
         });
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to delete user list entry.");
     });
-    return data;
+    return result;
   }
 }
 
@@ -2019,42 +2296,48 @@ class Service {
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.service.status()
+   * const { success, error } = await mailchannels.service.status()
    * ```
    */
   async status() {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     await this.mailchannels.get("/inbound/v1/status", {
       ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response);
+        result.error = getStatusError(response);
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch service status.");
     });
-    return data;
+    return result;
   }
   /**
    * Get a list of your subscriptions to MailChannels Inbound
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { subscriptions } = await mailchannels.service.subscriptions()
+   * const { data, error } = await mailchannels.service.subscriptions()
    * ```
    */
   async subscriptions() {
-    const data = { subscriptions: [], error: null };
+    const result = { data: null, error: null };
     const response = await this.mailchannels.get("/inbound/v1/subscriptions", {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2, {
+        result.error = getStatusError(response2, {
           [ErrorCode.NotFound]: "We could not find a customer that matched the customerHandle."
         });
       }
-    }).catch(() => []);
-    data.subscriptions = response;
-    return data;
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to fetch subscriptions.");
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response);
+    return result;
   }
   /**
    * Submit a false negative or false positive report.
@@ -2068,22 +2351,25 @@ class Service {
    * ```
    */
   async report(options) {
-    const data = { success: false, error: null };
+    const result = { success: false, error: null };
     const { type, ...payload } = options;
     await this.mailchannels.post("/inbound/v1/report", {
       query: {
         report_type: type
       },
       body: payload,
+      ignoreResponseError: true,
       onResponse: async ({ response }) => {
         if (response.ok) {
-          data.success = true;
+          result.success = true;
           return;
         }
-        data.error = getStatusError(response);
+        result.error = getStatusError(response);
       }
+    }).catch((error) => {
+      result.error = getResultError(result, error, "Failed to submit report.");
     });
-    return data;
+    return result;
   }
 }