mailchannels-sdk 0.4.7 → 0.6.0

package/dist/mailchannels.mjs

@@ -1,5 +1,4 @@
 import { $fetch } from 'ofetch';
-import { Emails, Webhooks, SubAccounts, Metrics, Suppressions, Domains, Lists, Users, Service } from './modules.mjs';
 
 class MailChannelsClient {
   static BASE_URL = "https://api.mailchannels.net";
@@ -41,6 +40,2266 @@ class MailChannelsClient {
   }
 }
 
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["BadRequest"] = 400] = "BadRequest";
+  ErrorCode2[ErrorCode2["Unauthorized"] = 401] = "Unauthorized";
+  ErrorCode2[ErrorCode2["Forbidden"] = 403] = "Forbidden";
+  ErrorCode2[ErrorCode2["NotFound"] = 404] = "NotFound";
+  ErrorCode2[ErrorCode2["Conflict"] = 409] = "Conflict";
+  ErrorCode2[ErrorCode2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+  ErrorCode2[ErrorCode2["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+  return ErrorCode2;
+})(ErrorCode || {});
+const getStatusError = (response, errors = {}) => {
+  const statusText = errors[response.status] || "Unknown error.";
+  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;
+};
+
+const parseRecipientString = (input) => {
+  const trimmed = input.trim();
+  const match = trimmed.match(/^([^<]*)<([^@\s]+@[^>\s]+)>$/);
+  if (match) {
+    const [, name, email] = match;
+    return { email: email?.trim() || "", name: name?.trim() };
+  }
+  return { email: trimmed };
+};
+const parseRecipient = (recipient) => {
+  if (typeof recipient === "string") {
+    return parseRecipientString(recipient);
+  }
+  if (recipient?.email) {
+    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];
+};
+
+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;
+};
+
+class Emails {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Send an email using MailChannels Email API.
+   * @param options - The email options to send.
+   * @param dryRun - When set to `true`, the message will not be sent. Instead, the fully rendered message will be returned in the `data` property of the response. The default value is `false`.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, data } = await mailchannels.emails.send({
+   *   to: 'to@example.com',
+   *   from: 'from@example.com',
+   *   subject: 'Test',
+   *   html: 'Test'
+   * })
+   * ```
+   */
+  async send(options, dryRun = false) {
+    const { cc, bcc, from, to, html, text, mustaches, dkim } = options;
+    const result = { success: false, data: null, error: null };
+    const parsedFrom = parseRecipient(from);
+    if (!parsedFrom || !parsedFrom.email) {
+      result.error = "No sender provided. Use the `from` option to specify a sender";
+      return result;
+    }
+    const parsedTo = parseArrayRecipients(to);
+    if (!parsedTo || !parsedTo.length) {
+      result.error = "No recipients provided. Use the `to` option to specify at least one recipient";
+      return result;
+    }
+    if (!text && !html) {
+      result.error = "No email content provided";
+      return result;
+    }
+    const content = [];
+    const template_type = mustaches ? "mustache" : void 0;
+    if (text) content.push({ type: "text/plain", value: text, template_type });
+    if (html) content.push({ type: "text/html", value: html, template_type });
+    const payload = {
+      attachments: options.attachments,
+      campaign_id: options.campaignId,
+      personalizations: [{
+        bcc: parseArrayRecipients(bcc),
+        cc: parseArrayRecipients(cc),
+        to: parsedTo,
+        dkim_domain: dkim?.domain || void 0,
+        dkim_private_key: dkim?.privateKey ? stripPemHeaders(dkim.privateKey) : void 0,
+        dkim_selector: dkim?.selector || void 0,
+        dynamic_template_data: options.mustaches
+      }],
+      headers: options.headers,
+      reply_to: parseRecipient(options.replyTo),
+      from: parsedFrom,
+      subject: options.subject,
+      content,
+      tracking_settings: options.tracking ? {
+        click_tracking: options.tracking.click ? { enable: options.tracking.click } : void 0,
+        open_tracking: options.tracking.open ? { enable: options.tracking.open } : void 0
+      } : void 0,
+      transactional: options.transactional
+    };
+    const response = await this.mailchannels.post("/tx/v1/send", {
+      query: { "dry-run": dryRun },
+      body: payload,
+      onResponse: async ({ response: response2 }) => {
+        if (response2.ok) {
+          result.success = true;
+          return;
+        }
+        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 result;
+    result.data = clean({
+      rendered: response.data,
+      requestId: response.request_id,
+      results: response.results?.map((result2) => ({
+        index: result2.index,
+        messageId: result2.message_id,
+        reason: result2.reason,
+        status: result2.status
+      }))
+    });
+    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.
+   * @param options - The domain options to check.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { results } = await mailchannels.emails.checkDomain({
+   *   dkim: [{
+   *     domain: 'example.com',
+   *     privateKey: 'your-private-key',
+   *     selector: 'mailchannels'
+   *   }],
+   *   domain: 'example.com',
+   *   senderId: 'sender-id'
+   * })
+   * ```
+   */
+  async checkDomain(options) {
+    const { dkim, domain, senderId } = options;
+    const dkimOptions = dkim ? Array.isArray(dkim) ? dkim : [dkim] : void 0;
+    const result = { data: null, error: null };
+    const payload = {
+      dkim_settings: dkimOptions?.map(({ domain: domain2, privateKey, selector }) => ({
+        dkim_domain: domain2,
+        dkim_private_key: privateKey ? stripPemHeaders(privateKey) : void 0,
+        dkim_selector: selector
+      })),
+      domain,
+      sender_id: senderId
+    };
+    const response = await this.mailchannels.post("/tx/v1/check-domain", {
+      body: payload,
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.Forbidden]: "User does not have access to this feature."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean({
+      dkim: response.check_results.dkim.map((dkimResults) => ({
+        domain: dkimResults.dkim_domain,
+        keyStatus: dkimResults.dkim_key_status,
+        selector: dkimResults.dkim_selector,
+        reason: dkimResults.reason,
+        verdict: dkimResults.verdict
+      })),
+      domainLockdown: response.check_results.domain_lockdown,
+      senderDomain: response.check_results.sender_domain,
+      spf: response.check_results.spf,
+      references: response.references
+    });
+    return result;
+  }
+  /**
+   * Create a DKIM key pair for a specified domain and selector using the specified algorithm and key length, for the current customer.
+   * @param domain - The domain to create the DKIM key for.
+   * @param options - DKIM key creation options.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.emails.createDkimKey('example.com', {
+   *   selector: 'mailchannels'
+   * })
+   * ```
+   */
+  async createDkimKey(domain, options) {
+    const result = { data: null, error: null };
+    if (!options.selector || options.selector.length > 63) {
+      result.error = "Selector must be between 1 and 63 characters.";
+    }
+    if (result.error) return result;
+    const payload = {
+      algorithm: options.algorithm,
+      key_length: options.length,
+      selector: options.selector
+    };
+    const response = await this.mailchannels.post(`/tx/v1/domains/${domain}/dkim-keys`, {
+      body: payload,
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.Conflict]: "Key pair already created for domain, and selector."
+        });
+      }
+    }).catch(() => 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 result;
+  }
+  /**
+   * 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 { data, error } = await mailchannels.getDkimKeys('example.com', {
+   *   includeDnsRecord: true
+   * })
+   * ```
+   */
+  async getDkimKeys(domain, options) {
+    const result = { data: null, error: null };
+    if (options?.selector && options.selector.length > 63) {
+      result.error = "Selector must be a maximum of 63 characters.";
+      return result;
+    }
+    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 100)) {
+      result.error = "Limit must be between 1 and 100.";
+      return result;
+    }
+    if (typeof options?.offset === "number" && options.offset < 0) {
+      result.error = "Offset value is invalid. Only positive values are allowed.";
+      return result;
+    }
+    const payload = {
+      selector: options?.selector,
+      status: options?.status,
+      offset: options?.offset,
+      limit: options?.limit,
+      include_dns_record: options?.includeDnsRecord
+    };
+    const response = await this.mailchannels.get(`/tx/v1/domains/${domain}/dkim-keys`, {
+      query: payload,
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => 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 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.
+   * @param domain - The domain the DKIM key belongs to.
+   * @param options - The options to update the DKIM key.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.emails.updateDkimKey('example.com', {
+   *   selector: 'mailchannels',
+   *   status: 'retired'
+   * })
+   */
+  async updateDkimKey(domain, options) {
+    const result = { success: false, error: null };
+    if (!options.selector || options.selector.length > 63) {
+      result.error = "Selector must be between 1 and 63 characters.";
+      return result;
+    }
+    const payload = {
+      status: options.status
+    };
+    await this.mailchannels.patch(`/tx/v1/domains/${domain}/dkim-keys/${options.selector}`, {
+      body: payload,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          result.success = true;
+          return;
+        }
+        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 = error instanceof Error ? error.message : "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.",
+          [ErrorCode.Conflict]: "Key pair already created for domain, and provided new key selector."
+        });
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "Failed to rotate DKIM key.";
+      }
+      return null;
+    });
+    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;
+  }
+}
+
+class Webhooks {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Enrolls the customer to receive event notifications via webhooks.
+   * @param endpoint - The URL to receive event notifications. Must be no longer than `8000` characters.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = mailchannels.webhooks.enroll('https://example.com/api/webhooks/mailchannels')
+   * ```
+   */
+  async enroll(endpoint) {
+    const result = { success: false, error: null };
+    if (!endpoint) {
+      result.error = "No endpoint provided.";
+      return result;
+    }
+    if (endpoint.length > 8e3) {
+      result.error = "The endpoint exceeds the maximum length of 8000 characters.";
+      return result;
+    }
+    await this.mailchannels.post("/tx/v1/webhook", {
+      query: {
+        endpoint
+      },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response, {
+          [ErrorCode.Conflict]: `Endpoint '${endpoint}' is already enrolled to receive notifications.`
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Retrieves all registered webhook endpoints associated with the customer.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.webhooks.list()
+   * ```
+   */
+  async list() {
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/webhook", {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2);
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "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, error } = await mailchannels.webhooks.delete()
+   * ```
+   */
+  async delete() {
+    const result = { success: false, error: null };
+    await this.mailchannels.delete("/tx/v1/webhook", {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (!response.ok) {
+          result.error = getStatusError(response);
+          return;
+        }
+        result.success = true;
+      }
+    });
+    return result;
+  }
+  /**
+   * Retrieves the public key used to verify signatures on incoming webhook payloads.
+   * @param id - The ID of the key.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.webhooks.getSigningKey('key-id')
+   * ```
+   */
+  async getSigningKey(id) {
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/webhook/public-key", {
+      query: {
+        id
+      },
+      onResponseError: ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.NotFound]: `The key '${id}' is not found.`
+        });
+      }
+    }).catch(() => 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.
+   * @param requestId - Optional identifier in the webhook payload. If not provided, a value will be automatically generated. Must not exceed 28 characters.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.webhooks.validate('optional-request-id')
+   * ```
+   */
+  async validate(requestId) {
+    const result = { data: null, error: null };
+    if (requestId && requestId.length > 28) {
+      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 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.NotFound]: "No webhooks found for the account."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean({
+      allPassed: response.all_passed,
+      results: response.results
+    });
+    return result;
+  }
+}
+
+class SubAccounts {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  static COMPANY_PATTERN = /^.{3,128}$/;
+  static HANDLE_PATTERN = /^[a-z0-9]{3,128}$/;
+  /**
+   * Creates a new sub-account under the parent account. Each sub-account must have a unique handle composed solely of lowercase alphanumeric characters. If no handle is provided, a random handle will be generated. Note that Sub-accounts are only available to parent accounts on 100K and higher plans.
+   * @param companyName - The name of the company associated with the sub-account. This name is used for display purposes only and does not affect the functionality of the sub-account. The length must be between 3 and 128 characters.
+   * @param handle - A unique name for the sub-account to be created. The length must be between 3 and 128 characters, and it may contain only lowercase letters and numbers. If not provided, a random handle will be generated.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.subAccounts.create('My Company', 'validhandle123')
+   * ```
+   */
+  async create(companyName, handle) {
+    const result = { data: null, error: null };
+    const isValidCompany = SubAccounts.COMPANY_PATTERN.test(companyName);
+    if (!isValidCompany) {
+      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) {
+        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", {
+      body: {
+        company_name: companyName,
+        handle
+      },
+      onResponseError: ({ 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 result;
+    result.data = clean({
+      companyName: response.company_name,
+      enabled: response.enabled,
+      handle: response.handle
+    });
+    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.
+   * @param options - The options to filter the list of sub-accounts.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.subAccounts.list()
+   * ```
+   */
+  async list(options) {
+    const result = { data: null, error: null };
+    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 1e3)) {
+      result.error = "The limit value is invalid. Possible limit values are 1 to 1000.";
+      return result;
+    }
+    if (typeof options?.offset === "number" && options.offset < 0) {
+      result.error = "Offset must be greater than or equal to 0.";
+      return result;
+    }
+    const response = await this.mailchannels.get("/tx/v1/sub-account", {
+      query: options,
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2);
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "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 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, error } = await mailchannels.subAccounts.delete('validhandle123')
+   * ```
+   */
+  async delete(handle) {
+    const result = { success: false, error: null };
+    if (!handle) {
+      result.error = "No handle provided.";
+      return result;
+    }
+    await this.mailchannels.delete(`/tx/v1/sub-account/${handle}`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (!response.ok) {
+          result.error = getStatusError(response);
+          return;
+        }
+        result.success = true;
+      }
+    });
+    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.
+   * @param handle - Handle of sub-account to be suspended.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.subAccounts.suspend('validhandle123')
+   * ```
+   */
+  async suspend(handle) {
+    const result = { success: false, error: null };
+    if (!handle) {
+      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) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response, {
+          [ErrorCode.NotFound]: `The specified sub-account '${handle}' does not exist.`
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Activates a suspended sub-account identified by its handle, restoring its ability to send emails.
+   * @param handle - Handle of sub-account to be activated.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.subAccounts.activate('validhandle123')
+   * ```
+   */
+  async activate(handle) {
+    const result = { success: false, error: null };
+    if (!handle) {
+      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) {
+          result.success = true;
+          return;
+        }
+        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.`
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Creates a new API key for the specified sub-account.
+   * @param handle - Handle of the sub-account to create API key for.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.subAccounts.createApiKey('validhandle123')
+   * ```
+   */
+  async createApiKey(handle) {
+    const result = { data: null, error: null };
+    if (!handle) {
+      result.error = "No handle provided.";
+      return result;
+    }
+    const response = await this.mailchannels.post(`/tx/v1/sub-account/${handle}/api-key`, {
+      onResponseError: async ({ response: 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 result;
+    result.data = clean({
+      id: response.id,
+      value: response.key
+    });
+    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.
+   * @param handle - Handle of the sub-account to retrieve the API key for.
+   * @param options - The options to filter the list of API keys.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.subAccounts.listApiKeys('validhandle123')
+   * ```
+   */
+  async listApiKeys(handle, options) {
+    const result = { data: null, error: null };
+    if (!handle) {
+      result.error = "No handle provided.";
+      return result;
+    }
+    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 1e3)) {
+      result.error = "The limit value is invalid. Possible limit values are 1 to 1000.";
+      return result;
+    }
+    if (typeof options?.offset === "number" && options.offset < 0) {
+      result.error = "Offset must be greater than or equal to 0.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/api-key`, {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean(response.map((key) => ({
+      id: key.id,
+      value: key.key
+    })));
+    return result;
+  }
+  /**
+   * Deletes the API key identified by its ID for the specified sub-account.
+   * @param handle - Handle of the sub-account for which the API key should be deleted.
+   * @param id - The ID of the API key to delete.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.subAccounts.deleteApiKey('validhandle123', 1)
+   * ```
+   */
+  async deleteApiKey(handle, id) {
+    const result = { success: false, error: null };
+    if (!handle) {
+      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) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Missing or invalid API key ID."
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Creates a new SMTP password for the specified sub-account.
+   * @param handle - Handle of the sub-account to create SMTP password for.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.subAccounts.createSmtpPassword('validhandle123')
+   * ```
+   */
+  async createSmtpPassword(handle) {
+    const result = { data: null, error: null };
+    if (!handle) {
+      result.error = "No handle provided.";
+      return result;
+    }
+    const response = await this.mailchannels.post(`/tx/v1/sub-account/${handle}/smtp-password`, {
+      onResponseError: async ({ response: 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 result;
+    result.data = clean({
+      enabled: response.enabled,
+      id: response.id,
+      value: response.smtp_password
+    });
+    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.
+   * @param handle - Handle of the sub-account to retrieve the SMTP password for.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.subAccounts.listSmtpPasswords('validhandle123')
+   * ```
+   */
+  async listSmtpPasswords(handle) {
+    const result = { data: null, error: null };
+    if (!handle) {
+      result.error = "No handle provided.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/smtp-password`, {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean(response.map((password) => ({
+      enabled: password.enabled,
+      id: password.id,
+      value: password.smtp_password
+    })));
+    return result;
+  }
+  /**
+   * Deletes the SMTP password identified by its ID for the specified sub-account.
+   * @param handle - Handle of the sub-account for which the SMTP password should be deleted.
+   * @param id - The ID of the SMTP password to delete.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.subAccounts.deleteSmtpPassword('validhandle123', 1)
+   * ```
+   */
+  async deleteSmtpPassword(handle, id) {
+    const result = { success: false, error: null };
+    if (!handle) {
+      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) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Missing or invalid SMTP password ID."
+        });
+      }
+    });
+    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.
+   * @param handle - Handle of the sub-account to retrieve the limit for.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.subAccounts.getLimit('validhandle123')
+   * ```
+   */
+  async getLimit(handle) {
+    const result = { data: null, error: null };
+    if (!handle) {
+      result.error = "No handle provided.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/limit`, {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean(response);
+    return result;
+  }
+  /**
+   * Sets the limit for the specified sub-account.
+   * @param handle - Handle of the sub-account to set limit for.
+   * @param limit - The limits to set for the sub-account. The minimum allowed sends is `0`
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.subAccounts.setLimit('validhandle123', { sends: 1000 })
+   * ```
+   */
+  async setLimit(handle, limit) {
+    const result = { success: false, error: null };
+    if (!handle) {
+      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) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    });
+    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.
+   * @param handle - Handle of the sub-account to delete limit for.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.subAccounts.deleteLimit('validhandle123')
+   * ```
+   */
+  async deleteLimit(handle) {
+    const result = { success: false, error: null };
+    if (!handle) {
+      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) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Retrieves usage statistics for the specified sub-account during the current billing period.
+   * @param handle - Handle of the sub-account to query usage stats for.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.subAccounts.getUsage('validhandle123')
+   * ```
+   */
+  async getUsage(handle) {
+    const result = { data: null, error: null };
+    if (!handle) {
+      result.error = "No handle provided.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/usage`, {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean({
+      endDate: response.period_end_date,
+      startDate: response.period_start_date,
+      total: response.total_usage
+    });
+    return result;
+  }
+}
+
+const mapBuckets = (arr) => {
+  return arr.map(({ count, period_start }) => ({ count, periodStart: period_start }));
+};
+class Metrics {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Retrieve engagement metrics for messages sent from your account, including counts of open and click events. Supports optional filters for time range, and campaign ID.
+   * @param options - Options to filter and customize the engagement metrics retrieval.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.metrics.engagement()
+   * ```
+   */
+  async engagement(options) {
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/metrics/engagement", {
+      query: {
+        start_time: options?.startTime,
+        end_time: options?.endTime,
+        campaign_id: options?.campaignId,
+        interval: options?.interval
+      },
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "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),
+        open: mapBuckets(response.buckets.open),
+        openTrackingDelivered: mapBuckets(response.buckets.open_tracking_delivered)
+      },
+      click: response.click,
+      clickTrackingDelivered: response.click_tracking_delivered,
+      endTime: response.end_time,
+      open: response.open,
+      openTrackingDelivered: response.open_tracking_delivered,
+      startTime: response.start_time
+    });
+    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.
+   * @param options - Options to filter and customize the performance metrics retrieval.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.metrics.performance()
+   * ```
+   */
+  async performance(options) {
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/metrics/performance", {
+      query: {
+        start_time: options?.startTime,
+        end_time: options?.endTime,
+        campaign_id: options?.campaignId,
+        interval: options?.interval
+      },
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "Failed to fetch performance metrics.";
+      }
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean({
+      bounced: response.bounced,
+      buckets: {
+        bounced: mapBuckets(response.buckets.bounced),
+        delivered: mapBuckets(response.buckets.delivered),
+        processed: mapBuckets(response.buckets.processed)
+      },
+      delivered: response.delivered,
+      endTime: response.end_time,
+      processed: response.processed,
+      startTime: response.start_time
+    });
+    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.
+   * @param options - Options to filter and customize the recipient behaviour metrics retrieval.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.metrics.recipientBehaviour()
+   * ```
+   */
+  async recipientBehaviour(options) {
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/metrics/recipient-behaviour", {
+      query: {
+        start_time: options?.startTime,
+        end_time: options?.endTime,
+        campaign_id: options?.campaignId,
+        interval: options?.interval
+      },
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "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)
+      },
+      endTime: response.end_time,
+      startTime: response.start_time,
+      unsubscribeDelivered: response.unsubscribe_delivered,
+      unsubscribed: response.unsubscribed
+    });
+    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.
+   * @param options - Options to filter and customize the volume metrics retrieval.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.metrics.volume()
+   * ```
+   */
+  async volume(options) {
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/metrics/volume", {
+      query: {
+        start_time: options?.startTime,
+        end_time: options?.endTime,
+        campaign_id: options?.campaignId,
+        interval: options?.interval
+      },
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "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),
+        processed: mapBuckets(response.buckets.processed)
+      },
+      delivered: response.delivered,
+      dropped: response.dropped,
+      endTime: response.end_time,
+      processed: response.processed,
+      startTime: response.start_time
+    });
+    return result;
+  }
+  /**
+   * Retrieves usage statistics during the current billing period.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.metrics.usage()
+   * ```
+   */
+  async usage() {
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/usage", {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2);
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "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 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 };
+    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) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "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;
+  }
+}
+
+class Suppressions {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Creates suppression entries for the specified account. Parent accounts can create suppression entries for all associated sub-accounts. If `types` is not provided, it defaults to `non-transactional`. The operation is atomic, meaning all entries are successfully added or none are added if an error occurs.
+   * @param options - The details of the suppression entries to create.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.suppressions.create({
+   * // ...
+   * });
+   */
+  async create(options) {
+    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,
+        // 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", {
+      body: payload,
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          result.success = true;
+          return;
+        }
+        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."
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Deletes suppression entry associated with the account based on the specified recipient and source.
+   * @param recipient - The email address of the suppression entry to delete.
+   * @param source - The source of the suppression entry to be deleted. If source is not provided, it defaults to `api`. If source is set to `all`, all suppression entries related to the specified recipient will be deleted.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.suppressions.delete('name@example.com', 'api');
+   * ```
+   */
+  async delete(recipient, source) {
+    const result = { success: false, error: null };
+    await this.mailchannels.delete(`/tx/v1/suppression-list/recipients/${recipient}`, {
+      query: {
+        source
+      },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    });
+    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 { data, error } = await mailchannels.suppressions.list();
+   * ```
+   * @param options - Options to filter and customize the suppression entries retrieval.
+   */
+  async list(options) {
+    const result = { data: null, error: null };
+    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 1e3)) {
+      result.error = "The limit must be between 1 and 1000.";
+      return result;
+    }
+    if (typeof options?.offset === "number" && options.offset < 0) {
+      result.error = "Offset must be greater than or equal to 0.";
+      return result;
+    }
+    const payload = {
+      recipient: options?.recipient,
+      source: options?.source,
+      created_before: options?.createdBefore,
+      created_after: options?.createdAfter,
+      limit: options?.limit,
+      offset: options?.offset
+    };
+    const response = await this.mailchannels.get("/tx/v1/suppression-list", {
+      query: payload,
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => 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 result;
+  }
+}
+
+class Domains {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Provision a single domain to use MailChannels Inbound.
+   * @param options - The provision options and domain data.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.domains.provision({
+   *   domain: 'example.com',
+   *   subscriptionHandle: 'your-subscription-handle'
+   * })
+   * ```
+   */
+  async provision(options) {
+    const { associateKey, overwrite, ...payload } = options;
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.post("/inbound/v1/domains", {
+      query: {
+        "associate-key": associateKey,
+        "overwrite": overwrite
+      },
+      body: payload,
+      onResponseError: async ({ response: 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((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "Failed to provision domain.";
+      }
+      return null;
+    });
+    result.data = clean(response);
+    return result;
+  }
+  /**
+   * Provision up to 1000 domains to use MailChannels Inbound.
+   * @param options - The options to provision the domains.
+   * @param domains - A list of domain data to provision.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.domains.bulkProvision({
+   *   subscriptionHandle: 'your-subscription-handle'
+   * }, [
+   *   {
+   *     domain: 'example.com',
+   *     admins: ['support@example.com']
+   *   },
+   *   {
+   *     domain: 'example2.com'
+   *   }
+   * ])
+   * ```
+   */
+  async bulkProvision(options, domains) {
+    const { associateKey, overwrite, subscriptionHandle } = options;
+    const result = { data: null, error: null };
+    if (!domains || !domains.length) {
+      result.error = "No domains provided.";
+      return result;
+    }
+    if (domains.length > 1e3) {
+      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: {
+        subscriptionHandle,
+        "associate-key": associateKey,
+        "overwrite": overwrite
+      },
+      body: { domains },
+      onResponseError: async ({ response: 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((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "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.
+   * @param options - The options to filter the list of domains.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.domains.list()
+   * ```
+   */
+  async list(options) {
+    const result = { data: null, error: null };
+    if (typeof options?.limit === "number" && (options.limit < 1 || options.limit > 5e3)) {
+      result.error = "The limit value is invalid. Possible limit values are 1 to 5000.";
+      return result;
+    }
+    if (typeof options?.offset === "number" && options.offset < 0) {
+      result.error = "Offset must be greater than or equal to 0.";
+      return result;
+    }
+    const response = await this.mailchannels.get("/inbound/v1/domains", {
+      query: options,
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2);
+      }
+    }).catch(() => 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.
+   * @param domain - The domain name to be removed.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.domains.delete('example.com')
+   * ```
+   */
+  async delete(domain) {
+    const result = { success: false, error: null };
+    if (!domain) {
+      result.error = "No domain provided.";
+      return result;
+    }
+    await this.mailchannels.delete(`/inbound/v1/domains/${domain}`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          result.success = true;
+          return;
+        }
+        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.`
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Add an entry to a domain blocklist or safelist.
+   * @param domain - The domain name.
+   * @param options - The options to add a list entry.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.domains.addListEntry('example.com', {
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async addListEntry(domain, options) {
+    const { listName, item } = options;
+    const result = { data: null, error: null };
+    if (!domain) {
+      result.error = "No domain provided.";
+      return result;
+    }
+    if (!listName) {
+      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 }) => {
+        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 result;
+    result.data = clean({
+      action: response.action,
+      item: response.item,
+      type: response.item_type
+    });
+    return result;
+  }
+  /**
+   * Get domain list entries.
+   * @param domain - The domain name.
+   * @param listName - The name of the list to fetch. This can be a `blocklist`, `safelist`, `blacklist`, or `whitelist`.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.domains.listEntries('example.com', 'safelist')
+   * ```
+   */
+  async listEntries(domain, listName) {
+    const result = { data: null, error: null };
+    if (!domain) {
+      result.error = "No domain provided.";
+      return result;
+    }
+    if (!listName) {
+      result.error = "No list name provided.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/lists/${listName}`, {
+      onResponseError: async ({ response: 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 result;
+    result.data = clean(response.map(({ action, item, item_type }) => ({
+      action,
+      item,
+      type: item_type
+    })));
+    return result;
+  }
+  /**
+   * Delete item from domain list.
+   * @param email - The domain name whose list will be modified.
+   * @param options - The options for the list entry to delete.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.domains.deleteListEntry('example.com', {
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async deleteListEntry(domain, options) {
+    const { listName, item } = options;
+    const result = { success: false, error: null };
+    if (!domain) {
+      result.error = "No domain provided.";
+      return result;
+    }
+    if (!listName) {
+      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) {
+          result.success = true;
+          return;
+        }
+        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.`
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Generate a link that allows a user to log in as a domain administrator.
+   * @param domain - The domain name.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.domains.createLoginLink('example.com')
+   * ```
+   */
+  async createLoginLink(domain) {
+    const result = { data: null, error: null };
+    if (!domain) {
+      result.error = "No domain provided.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/login-link`, {
+      onResponseError: async ({ response: 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 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.
+   * @param domain - The domain name.
+   * @param records - The list of records to set for the domain. A maximum of 10 records can be set.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.domains.setDownstreamAddress('example.com', [
+   *   {
+   *     port: 25,
+   *     priority: 10,
+   *     target: 'example.com.',
+   *     weight: 10
+   *   }
+   * ])
+   * ```
+   */
+  async setDownstreamAddress(domain, records = []) {
+    const result = { success: false, error: null };
+    if (!domain) {
+      result.error = "No domain provided.";
+      return result;
+    }
+    if (records.length > 10) {
+      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) {
+          result.success = true;
+          return;
+        }
+        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.`
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Retrieve stored downstream addresses for the domain.
+   * @param domain - The domain name.
+   * @param options - The options to filter the list of downstream addresses.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.domains.listDownstreamAddresses('example.com')
+   * ```
+   */
+  async listDownstreamAddresses(domain, options) {
+    const result = { data: null, error: null };
+    if (!domain) {
+      result.error = "No domain provided.";
+      return result;
+    }
+    if (typeof options?.limit === "number" && options.limit < 1) {
+      result.error = "The limit value is invalid. Only positive values are allowed.";
+      return result;
+    }
+    if (typeof options?.offset === "number" && options.offset < 0) {
+      result.error = "Offset must be greater than or equal to 0.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/downstream-address`, {
+      query: options,
+      onResponseError: async ({ response: 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 result;
+    result.data = clean(response.records);
+    return result;
+  }
+  /**
+   * Update the API key that is associated with a domain.
+   * @param domain - The domain name.
+   * @param key - The new API key to associate with this domain.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.domains.updateApiKey('example.com', 'your-api-key')
+   * ```
+   */
+  async updateApiKey(domain, key) {
+    const result = { success: false, error: null };
+    if (!domain) {
+      result.error = "No domain provided.";
+      return result;
+    }
+    if (!key) {
+      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) {
+          result.success = true;
+          return;
+        }
+        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."
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Generate a batch of links that allow a user to log in as a domain administrator to their different domains.
+   * @param domains - The list of domain names. Maximum of `1000` links per request.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.domains.bulkCreateLoginLinks(['example.com', 'example2.com'])
+   * ```
+   */
+  async bulkCreateLoginLinks(domains) {
+    const result = { data: null, error: null };
+    if (!domains || !domains.length) {
+      result.error = "No domains provided.";
+      return result;
+    }
+    if (domains.length > 1e3) {
+      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 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean(response);
+    return result;
+  }
+}
+
+class Lists {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Add item to account-level list
+   * @param options - The options for the list entry to add.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.lists.addListEntry({
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async addListEntry(options) {
+    const { listName, item } = options;
+    const result = { data: null, error: null };
+    if (!listName) {
+      result.error = "No list name provided.";
+      return result;
+    }
+    const response = await this.mailchannels.post(`/inbound/v1/lists/${listName}`, {
+      body: { item },
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2);
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean({
+      action: response.action,
+      item: response.item,
+      type: response.item_type
+    });
+    return result;
+  }
+  /**
+   * Get account-level list entries.
+   * @param listName - The name of the list to fetch. This can be a `blocklist`, `safelist`, `blacklist`, or `whitelist`.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.lists.listEntries('safelist')
+   * ```
+   */
+  async listEntries(listName) {
+    const result = { data: null, error: null };
+    if (!listName) {
+      result.error = "No list name provided.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/lists/${listName}`, {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2);
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean(response.map(({ action, item, item_type }) => ({
+      action,
+      item,
+      type: item_type
+    })));
+    return result;
+  }
+  /**
+   * Delete item from account-level list.
+   * @param options - The options for the list entry to delete.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.lists.deleteListEntry({
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async deleteListEntry(options) {
+    const { listName, item } = options;
+    const result = { success: false, error: null };
+    if (!listName) {
+      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) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response);
+      }
+    });
+    return result;
+  }
+}
+
+class Users {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Create a recipient user.
+   * @param email - The email address of the user to create.
+   * @param options - The options for the user to create.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.users.create("name@example.com", {
+   *   admin: true
+   * })
+   * ```
+   */
+  async create(email, options) {
+    const { admin, filter, listEntries } = options || {};
+    const result = { data: null, error: null };
+    if (!email) {
+      result.error = "No email address provided.";
+      return result;
+    }
+    const response = await this.mailchannels.put("/inbound/v1/users", {
+      query: {
+        email_address: email,
+        admin: Boolean(admin),
+        filter
+      },
+      body: {
+        list_entries: listEntries
+      },
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: `The email address '${email}' is invalid.`
+        });
+      }
+    }).catch(() => null);
+    if (!response) return result;
+    result.data = clean({
+      email: response.recipient.email_address,
+      roles: response.recipient.roles,
+      filter: response.recipient.filter,
+      listEntries: response.list_entries.map(({ item, item_type, action }) => ({
+        item,
+        type: item_type,
+        action
+      }))
+    });
+    return result;
+  }
+  /**
+   * Add item to recipient user list
+   * @param email - The email address of the recipient whose list will be modified.
+   * @param options - The options for the list entry to add.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.users.addListEntry('name@example.com', {
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async addListEntry(email, options) {
+    const { listName, item } = options;
+    const result = { data: null, error: null };
+    if (!email) {
+      result.error = "No email provided.";
+      return result;
+    }
+    if (!listName) {
+      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 }) => {
+        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 result;
+    result.data = clean({
+      action: response.action,
+      item: response.item,
+      type: response.item_type
+    });
+    return result;
+  }
+  /**
+   * Get recipient list entries.
+   * @param email - The email address of the recipient whose list will be fetched.
+   * @param listName - The name of the list to fetch. This can be a `blocklist`, `safelist`, `blacklist`, or `whitelist`.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.users.listEntries('name@example.com', 'safelist')
+   * ```
+   */
+  async listEntries(email, listName) {
+    const result = { data: null, error: null };
+    if (!email) {
+      result.error = "No email provided.";
+      return result;
+    }
+    if (!listName) {
+      result.error = "No list name provided.";
+      return result;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/users/${email}/lists/${listName}`, {
+      onResponseError: async ({ response: 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 result;
+    result.data = clean(response.map(({ action, item, item_type }) => ({
+      action,
+      item,
+      type: item_type
+    })));
+    return result;
+  }
+  /**
+   * Delete item from recipient list.
+   * @param email - The email address of the recipient whose list will be modified.
+   * @param options - The options for the list entry to delete.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.users.deleteListEntry('name@example.com', {
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async deleteListEntry(email, options) {
+    const { listName, item } = options;
+    const result = { success: false, error: null };
+    if (!email) {
+      result.error = "No email provided.";
+      return result;
+    }
+    if (!listName) {
+      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) {
+          result.success = true;
+          return;
+        }
+        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.`
+        });
+      }
+    });
+    return result;
+  }
+}
+
+class Service {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Retrieve the condition of the service
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.service.status()
+   * ```
+   */
+  async status() {
+    const result = { success: false, error: null };
+    await this.mailchannels.get("/inbound/v1/status", {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response);
+      }
+    });
+    return result;
+  }
+  /**
+   * Get a list of your subscriptions to MailChannels Inbound
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { data, error } = await mailchannels.service.subscriptions()
+   * ```
+   */
+  async subscriptions() {
+    const result = { data: null, error: null };
+    const response = await this.mailchannels.get("/inbound/v1/subscriptions", {
+      onResponseError: async ({ response: response2 }) => {
+        result.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: "We could not find a customer that matched the customerHandle."
+        });
+      }
+    }).catch((error) => {
+      if (!result.error) {
+        result.error = error instanceof Error ? error.message : "Failed to fetch subscriptions.";
+      }
+      return null;
+    });
+    if (!response) return result;
+    result.data = clean(response);
+    return result;
+  }
+  /**
+   * Submit a false negative or false positive report.
+   * @param options - The report options
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success, error } = await mailchannels.service.report({
+   * // ...
+   * })
+   * ```
+   */
+  async report(options) {
+    const result = { success: false, error: null };
+    const { type, ...payload } = options;
+    await this.mailchannels.post("/inbound/v1/report", {
+      query: {
+        report_type: type
+      },
+      body: payload,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          result.success = true;
+          return;
+        }
+        result.error = getStatusError(response);
+      }
+    });
+    return result;
+  }
+}
+
 class MailChannels extends MailChannelsClient {
   // Modules: Email API
   emails = new Emails(this);
@@ -58,4 +2317,4 @@ class MailChannels extends MailChannelsClient {
   }
 }
 
-export { MailChannels, MailChannelsClient };
+export { Domains, Emails, Lists, MailChannels, MailChannelsClient, Metrics, Service, SubAccounts, Suppressions, Users, Webhooks };