mailchannels-sdk 0.4.7 → 0.5.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,2053 @@ 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.";
+  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(", ");
+  }
+  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, "");
+
+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 data = { 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;
+    }
+    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;
+    }
+    if (!text && !html) {
+      data.error = "No email content provided";
+      return data;
+    }
+    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) {
+          data.success = true;
+          return;
+        }
+        data.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 = {
+      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
+      }))
+    };
+    return data;
+  }
+  /**
+   * 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 data = { results: 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 }) => {
+        data.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 = {
+      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 data;
+  }
+  /**
+   * 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 { key, error } = await mailchannels.emails.createDkimKey('example.com', {
+   *   selector: 'mailchannels'
+   * })
+   * ```
+   */
+  async createDkimKey(domain, options) {
+    const data = { key: null, error: null };
+    if (!options.selector || options.selector.length > 63) {
+      data.error = "Selector must be between 1 and 63 characters.";
+    }
+    if (data.error) return data;
+    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 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.Conflict]: "Key pair already created for customer_handle, domain, and selector."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.key = {
+      algorithm: response.algorithm,
+      createdAt: response.created_at,
+      dnsRecords: response.dkim_dns_records,
+      domain: response.domain,
+      length: response.key_length,
+      publicKey: response.public_key,
+      selector: response.selector,
+      status: response.status,
+      statusModifiedAt: response.status_modified_at
+    };
+    return data;
+  }
+  /**
+   * Search for DKIM keys by customer handle and 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', {
+   *   includeDnsRecord: true
+   * })
+   * ```
+   */
+  async getDkimKeys(domain, options) {
+    const data = { keys: [], 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;
+    }
+    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 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.keys = response.keys.map((key) => ({
+      algorithm: key.algorithm,
+      createdAt: key.created_at,
+      dnsRecords: key.dkim_dns_records,
+      domain: key.domain,
+      length: key.key_length,
+      publicKey: key.public_key,
+      selector: key.selector,
+      status: key.status,
+      statusModifiedAt: key.status_modified_at
+    }));
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.emails.updateDkimKey('example.com', {
+   *   selector: 'mailchannels',
+   *   status: 'retired'
+   * })
+   */
+  async updateDkimKey(domain, options) {
+    const data = { success: false, error: null };
+    if (!options.selector || options.selector.length > 63) {
+      data.error = "Selector must be between 1 and 63 characters.";
+      return data;
+    }
+    const payload = {
+      status: options.status
+    };
+    await this.mailchannels.patch(`/tx/v1/domains/${domain}/dkim-keys/${options.selector}`, {
+      body: payload,
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.NotFound]: "Specified key pair not found, or the DKIM domain or selector path parameter is missing."
+        });
+      }
+    });
+    return data;
+  }
+}
+
+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 } = mailchannels.webhooks.enroll('https://example.com/api/webhooks/mailchannels')
+   * ```
+   */
+  async enroll(endpoint) {
+    const data = { success: false, error: null };
+    if (!endpoint) {
+      data.error = "No endpoint provided.";
+      return data;
+    }
+    if (endpoint.length > 8e3) {
+      data.error = "The endpoint exceeds the maximum length of 8000 characters.";
+      return data;
+    }
+    await this.mailchannels.post("/tx/v1/webhook", {
+      query: {
+        endpoint
+      },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response, {
+          [ErrorCode.Conflict]: `Endpoint '${endpoint}' is already enrolled to receive notifications.`
+        });
+      }
+    });
+    return data;
+  }
+  /**
+   * Retrieves all registered webhook endpoints associated with the customer.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { webhooks } = await mailchannels.webhooks.list()
+   * ```
+   */
+  async list() {
+    const data = { webhooks: [], error: null };
+    const response = await this.mailchannels.get("/tx/v1/webhook", {
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2);
+      }
+    }).catch(() => []);
+    data.webhooks = response.map(({ webhook }) => webhook);
+    return data;
+  }
+  /**
+   * Deletes all registered webhook endpoints for the customer.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success } = await mailchannels.webhooks.delete()
+   * ```
+   */
+  async delete() {
+    const data = { success: false, error: null };
+    await this.mailchannels.delete("/tx/v1/webhook", {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (!response.ok) {
+          data.error = getStatusError(response);
+          return;
+        }
+        data.success = true;
+      }
+    });
+    return data;
+  }
+  /**
+   * 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 { key } = await mailchannels.webhooks.getSigningKey('key-id')
+   * ```
+   */
+  async getSigningKey(id) {
+    const data = { key: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/webhook/public-key", {
+      query: {
+        id
+      },
+      onResponseError: ({ response: response2 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.NotFound]: `The key '${id}' is not found.`
+        });
+      }
+    }).catch(() => null);
+    data.key = response?.key || null;
+    return data;
+  }
+  /**
+   * 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 { allPassed, results } = await mailchannels.webhooks.validate('optional-request-id')
+   * ```
+   */
+  async validate(requestId) {
+    const data = { allPassed: false, results: [], error: null };
+    if (requestId && requestId.length > 28) {
+      data.error = "The request id should not exceed 28 characters.";
+      return data;
+    }
+    const response = await this.mailchannels.post("/tx/v1/webhook/validate", {
+      body: {
+        request_id: requestId
+      },
+      onResponseError: ({ response: response2 }) => {
+        data.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;
+  }
+}
+
+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 { account } = await mailchannels.subAccounts.create('My Company', 'validhandle123')
+   * ```
+   */
+  async create(companyName, handle) {
+    const data = { account: 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;
+    }
+    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;
+      }
+    }
+    const response = await this.mailchannels.post("/tx/v1/sub-account", {
+      body: {
+        company_name: companyName,
+        handle
+      },
+      onResponseError: ({ response: response2 }) => {
+        data.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 = {
+      companyName: response.company_name,
+      enabled: response.enabled,
+      handle: response.handle
+    };
+    return data;
+  }
+  /**
+   * 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 { accounts } = 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 response = await this.mailchannels.get("/tx/v1/sub-account", {
+      query: options,
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2);
+      }
+    }).catch(() => []);
+    data.accounts = response.map((account) => ({
+      companyName: account.company_name,
+      enabled: account.enabled,
+      handle: account.handle
+    }));
+    return data;
+  }
+  /**
+   * 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')
+   * ```
+   */
+  async delete(handle) {
+    const data = { success: false, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    await this.mailchannels.delete(`/tx/v1/sub-account/${handle}`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (!response.ok) {
+          data.error = getStatusError(response);
+          return;
+        }
+        data.success = true;
+      }
+    });
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.subAccounts.suspend('validhandle123')
+   * ```
+   */
+  async suspend(handle) {
+    const data = { success: false, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    await this.mailchannels.post(`/tx/v1/sub-account/${handle}/suspend`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response, {
+          [ErrorCode.NotFound]: `The specified sub-account '${handle}' does not exist.`
+        });
+      }
+    });
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.subAccounts.activate('validhandle123')
+   * ```
+   */
+  async activate(handle) {
+    const data = { success: false, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    await this.mailchannels.post(`/tx/v1/sub-account/${handle}/activate`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.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 data;
+  }
+  /**
+   * 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 { key } = await mailchannels.subAccounts.createApiKey('validhandle123')
+   * ```
+   */
+  async createApiKey(handle) {
+    const data = { key: null, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    const response = await this.mailchannels.post(`/tx/v1/sub-account/${handle}/api-key`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.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 = {
+      id: response.id,
+      value: response.key
+    };
+    return data;
+  }
+  /**
+   * 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 { keys } = await mailchannels.subAccounts.listApiKeys('validhandle123')
+   * ```
+   */
+  async listApiKeys(handle, options) {
+    const data = { keys: [], 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;
+    }
+    const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/api-key`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    }).catch(() => []);
+    data.keys = response.map((key) => ({
+      id: key.id,
+      value: key.key
+    }));
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.subAccounts.deleteApiKey('validhandle123', 1)
+   * ```
+   */
+  async deleteApiKey(handle, id) {
+    const data = { success: false, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    await this.mailchannels.delete(`/tx/v1/sub-account/${handle}/api-key/${id}`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Missing or invalid API key ID."
+        });
+      }
+    });
+    return data;
+  }
+  /**
+   * 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 { password } = await mailchannels.subAccounts.createSmtpPassword('validhandle123')
+   * ```
+   */
+  async createSmtpPassword(handle) {
+    const data = { password: null, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    const response = await this.mailchannels.post(`/tx/v1/sub-account/${handle}/smtp-password`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.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 = {
+      enabled: response.enabled,
+      id: response.id,
+      value: response.smtp_password
+    };
+    return data;
+  }
+  /**
+   * 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 { passwords } = await mailchannels.subAccounts.listSmtpPasswords('validhandle123')
+   * ```
+   */
+  async listSmtpPasswords(handle) {
+    const data = { passwords: [], error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/smtp-password`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    }).catch(() => []);
+    data.passwords = response.map((password) => ({
+      enabled: password.enabled,
+      id: password.id,
+      value: password.smtp_password
+    }));
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.subAccounts.deleteSmtpPassword('validhandle123', 1)
+   * ```
+   */
+  async deleteSmtpPassword(handle, id) {
+    const data = { success: false, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    await this.mailchannels.delete(`/tx/v1/sub-account/${handle}/smtp-password/${id}`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Missing or invalid SMTP password ID."
+        });
+      }
+    });
+    return data;
+  }
+  /**
+   * 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 { limit } = await mailchannels.subAccounts.getLimit('validhandle123')
+   * ```
+   */
+  async getLimit(handle) {
+    const data = { limit: null, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/limit`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.limit = response;
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.subAccounts.setLimit('validhandle123', { sends: 1000 })
+   * ```
+   */
+  async setLimit(handle, limit) {
+    const data = { success: false, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    await this.mailchannels.put(`/tx/v1/sub-account/${handle}/limit`, {
+      body: limit,
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    });
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.subAccounts.deleteLimit('validhandle123')
+   * ```
+   */
+  async deleteLimit(handle) {
+    const data = { success: false, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    await this.mailchannels.delete(`/tx/v1/sub-account/${handle}/limit`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    });
+    return data;
+  }
+  /**
+   * 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 { usage } = await mailchannels.subAccounts.getUsage('validhandle123')
+   * ```
+   */
+  async getUsage(handle) {
+    const data = { usage: null, error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      return data;
+    }
+    const response = await this.mailchannels.get(`/tx/v1/sub-account/${handle}/usage`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.usage = {
+      endDate: response.period_end_date,
+      startDate: response.period_start_date,
+      total: response.total_usage
+    };
+    return data;
+  }
+}
+
+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 { engagement } = await mailchannels.metrics.engagement()
+   * ```
+   */
+  async engagement(options) {
+    const data = { engagement: 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 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.engagement = {
+      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 data;
+  }
+  /**
+   * 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 { performance } = await mailchannels.metrics.performance()
+   * ```
+   */
+  async performance(options) {
+    const data = { performance: 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 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.performance = {
+      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 data;
+  }
+  /**
+   * 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 { behaviour } = await mailchannels.metrics.recipientBehaviour()
+   * ```
+   */
+  async recipientBehaviour(options) {
+    const data = { behaviour: 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 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.behaviour = {
+      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 data;
+  }
+  /**
+   * 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 { volume } = await mailchannels.metrics.volume()
+   * ```
+   */
+  async volume(options) {
+    const data = { volume: 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 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.volume = {
+      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 data;
+  }
+  /**
+   * Retrieves usage statistics during the current billing period.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { usage } = await mailchannels.metrics.usage()
+   * ```
+   */
+  async usage() {
+    const data = { usage: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/usage", {
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2);
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.usage = {
+      endDate: response.period_end_date,
+      startDate: response.period_start_date,
+      total: response.total_usage
+    };
+    return data;
+  }
+}
+
+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 } = await mailchannels.suppressions.create({
+   * // ...
+   * });
+   */
+  async create(options) {
+    const data = { 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))
+      }))
+    };
+    await this.mailchannels.post("/tx/v1/suppression-list", {
+      body: payload,
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.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 data;
+  }
+  /**
+   * 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 } = await mailchannels.suppressions.delete('name@example.com', 'api');
+   * ```
+   */
+  async delete(recipient, source) {
+    const data = { success: false, error: null };
+    await this.mailchannels.delete(`/tx/v1/suppression-list/recipients/${recipient}`, {
+      query: {
+        source
+      },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    });
+    return data;
+  }
+  /**
+   * 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();
+   * ```
+   * @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 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 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.list = 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;
+  }
+}
+
+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 } = await mailchannels.domains.provision({
+   *   domain: 'example.com',
+   *   subscriptionHandle: 'your-subscription-handle'
+   * })
+   * ```
+   */
+  async provision(options) {
+    const { associateKey, overwrite, ...payload } = options;
+    const data = { 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 }) => {
+        data.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;
+  }
+  /**
+   * 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 { results } = 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 data = { results: null, error: null };
+    if (!domains || !domains.length) {
+      data.error = "No domains provided.";
+      return data;
+    }
+    if (domains.length > 1e3) {
+      data.error = "The maximum number of domains to be provisioned is 1000.";
+      return data;
+    }
+    const response = await this.mailchannels.post("/inbound/v1/domains/batch", {
+      query: {
+        subscriptionHandle,
+        "associate-key": associateKey,
+        "overwrite": overwrite
+      },
+      body: { domains },
+      onResponseError: async ({ response: response2 }) => {
+        data.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;
+  }
+  /**
+   * 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 { domains } = 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 response = await this.mailchannels.get("/inbound/v1/domains", {
+      query: options,
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2);
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.domains = response.domains;
+    data.total = response.total;
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.domains.delete('example.com')
+   * ```
+   */
+  async delete(domain) {
+    const data = { success: false, error: null };
+    if (!domain) {
+      data.error = "No domain provided.";
+      return data;
+    }
+    await this.mailchannels.delete(`/inbound/v1/domains/${domain}`, {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.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 data;
+  }
+  /**
+   * 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 { entry } = await mailchannels.domains.addListEntry('example.com', {
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async addListEntry(domain, options) {
+    const { listName, item } = options;
+    const data = { entry: null, error: null };
+    if (!domain) {
+      data.error = "No domain provided.";
+      return data;
+    }
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    const response = await this.mailchannels.post(`/inbound/v1/domains/${domain}/lists/${listName}`, {
+      body: { item },
+      onResponseError: async ({ response: response2 }) => {
+        data.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 = {
+      action: response.action,
+      item: response.item,
+      type: response.item_type
+    };
+    return data;
+  }
+  /**
+   * 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 { entries } = await mailchannels.domains.listEntries('example.com', 'safelist')
+   * ```
+   */
+  async listEntries(domain, listName) {
+    const data = { entries: [], error: null };
+    if (!domain) {
+      data.error = "No domain provided.";
+      return data;
+    }
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/lists/${listName}`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.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 }) => ({
+      action,
+      item,
+      type: item_type
+    }));
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.domains.deleteListEntry('example.com', {
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async deleteListEntry(domain, options) {
+    const { listName, item } = options;
+    const data = { success: false, error: null };
+    if (!domain) {
+      data.error = "No domain provided.";
+      return data;
+    }
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    await this.mailchannels.delete(`/inbound/v1/domains/${domain}/lists/${listName}`, {
+      query: { item },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.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 data;
+  }
+  /**
+   * 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 { link } = await mailchannels.domains.createLoginLink('example.com')
+   * ```
+   */
+  async createLoginLink(domain) {
+    const data = { link: null, error: null };
+    if (!domain) {
+      data.error = "No domain provided.";
+      return data;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/login-link`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.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;
+  }
+  /**
+   * 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 } = await mailchannels.domains.setDownstreamAddress('example.com', [
+   *   {
+   *     port: 25,
+   *     priority: 10,
+   *     target: 'example.com.',
+   *     weight: 10
+   *   }
+   * ])
+   * ```
+   */
+  async setDownstreamAddress(domain, records = []) {
+    const data = { success: false, error: null };
+    if (!domain) {
+      data.error = "No domain provided.";
+      return data;
+    }
+    if (records.length > 10) {
+      data.error = "The maximum of records to be set is 10.";
+      return data;
+    }
+    await this.mailchannels.put(`/inbound/v1/domains/${domain}/downstream-address`, {
+      body: { records },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.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 data;
+  }
+  /**
+   * 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 { records } = await mailchannels.domains.listDownstreamAddresses('example.com')
+   * ```
+   */
+  async listDownstreamAddresses(domain, options) {
+    const data = { records: [], 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;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/domains/${domain}/downstream-address`, {
+      query: options,
+      onResponseError: async ({ response: response2 }) => {
+        data.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;
+  }
+  /**
+   * 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 } = await mailchannels.domains.updateApiKey('example.com', 'your-api-key')
+   * ```
+   */
+  async updateApiKey(domain, key) {
+    const data = { success: false, error: null };
+    if (!domain) {
+      data.error = "No domain provided.";
+      return data;
+    }
+    if (!key) {
+      data.error = "No API key provided.";
+      return data;
+    }
+    await this.mailchannels.put(`/inbound/v1/domains/${domain}/api-key`, {
+      body: { apiKey: key },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.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 data;
+  }
+  /**
+   * 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 { results } = await mailchannels.domains.bulkCreateLoginLinks(['example.com', 'example2.com'])
+   * ```
+   */
+  async bulkCreateLoginLinks(domains) {
+    const data = { results: null, error: null };
+    if (!domains || !domains.length) {
+      data.error = "No domains provided.";
+      return data;
+    }
+    if (domains.length > 1e3) {
+      data.error = "The maximum number of domains to create login links for is 1000.";
+      return data;
+    }
+    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, {
+          [ErrorCode.BadRequest]: "Bad Request."
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.results = response;
+    return data;
+  }
+}
+
+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 { entry } = await mailchannels.lists.addListEntry({
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async addListEntry(options) {
+    const { listName, item } = options;
+    const data = { entry: null, error: null };
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    const response = await this.mailchannels.post(`/inbound/v1/lists/${listName}`, {
+      body: { item },
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2);
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.entry = {
+      action: response.action,
+      item: response.item,
+      type: response.item_type
+    };
+    return data;
+  }
+  /**
+   * 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 { entries } = await mailchannels.lists.listEntries('safelist')
+   * ```
+   */
+  async listEntries(listName) {
+    const data = { entries: [], error: null };
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/lists/${listName}`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2);
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.entries = response.map(({ action, item, item_type }) => ({
+      action,
+      item,
+      type: item_type
+    }));
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.lists.deleteListEntry({
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async deleteListEntry(options) {
+    const { listName, item } = options;
+    const data = { success: false, error: null };
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    await this.mailchannels.delete(`/inbound/v1/lists/${listName}`, {
+      query: { item },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response);
+      }
+    });
+    return data;
+  }
+}
+
+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 { user } = await mailchannels.users.create("name@example.com", {
+   *   admin: true
+   * })
+   * ```
+   */
+  async create(email, options) {
+    const { admin, filter, listEntries } = options || {};
+    const data = { user: null, error: null };
+    if (!email) {
+      data.error = "No email address provided.";
+      return data;
+    }
+    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 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.BadRequest]: `The email address '${email}' is invalid.`
+        });
+      }
+    }).catch(() => null);
+    if (!response) return data;
+    data.user = {
+      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 data;
+  }
+  /**
+   * 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 { entry } = await mailchannels.users.addListEntry('name@example.com', {
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async addListEntry(email, options) {
+    const { listName, item } = options;
+    const data = { entry: null, error: null };
+    if (!email) {
+      data.error = "No email provided.";
+      return data;
+    }
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    const response = await this.mailchannels.post(`/inbound/v1/users/${email}/lists/${listName}`, {
+      body: { item },
+      onResponseError: async ({ response: response2 }) => {
+        data.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 = {
+      action: response.action,
+      item: response.item,
+      type: response.item_type
+    };
+    return data;
+  }
+  /**
+   * 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 { entries } = await mailchannels.users.listEntries('name@example.com', 'safelist')
+   * ```
+   */
+  async listEntries(email, listName) {
+    const data = { entries: [], error: null };
+    if (!email) {
+      data.error = "No email provided.";
+      return data;
+    }
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    const response = await this.mailchannels.get(`/inbound/v1/users/${email}/lists/${listName}`, {
+      onResponseError: async ({ response: response2 }) => {
+        data.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 }) => ({
+      action,
+      item,
+      type: item_type
+    }));
+    return data;
+  }
+  /**
+   * 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 } = await mailchannels.users.deleteListEntry('name@example.com', {
+   *   listName: 'safelist',
+   *   item: 'name@domain.com'
+   * })
+   * ```
+   */
+  async deleteListEntry(email, options) {
+    const { listName, item } = options;
+    const data = { success: false, error: null };
+    if (!email) {
+      data.error = "No email provided.";
+      return data;
+    }
+    if (!listName) {
+      data.error = "No list name provided.";
+      return data;
+    }
+    await this.mailchannels.delete(`/inbound/v1/users/${email}/lists/${listName}`, {
+      query: { item },
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.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 data;
+  }
+}
+
+class Service {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Retrieve the condition of the service
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { success } = await mailchannels.service.status()
+   * ```
+   */
+  async status() {
+    const data = { success: false, error: null };
+    await this.mailchannels.get("/inbound/v1/status", {
+      ignoreResponseError: true,
+      onResponse: async ({ response }) => {
+        if (response.ok) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response);
+      }
+    });
+    return data;
+  }
+  /**
+   * Get a list of your subscriptions to MailChannels Inbound
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { subscriptions } = await mailchannels.service.subscriptions()
+   * ```
+   */
+  async subscriptions() {
+    const data = { subscriptions: [], error: null };
+    const response = await this.mailchannels.get("/inbound/v1/subscriptions", {
+      onResponseError: async ({ response: response2 }) => {
+        data.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: "We could not find a customer that matched the customerHandle."
+        });
+      }
+    }).catch(() => []);
+    data.subscriptions = response;
+    return data;
+  }
+  /**
+   * 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 data = { 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) {
+          data.success = true;
+          return;
+        }
+        data.error = getStatusError(response);
+      }
+    });
+    return data;
+  }
+}
+
 class MailChannels extends MailChannelsClient {
   // Modules: Email API
   emails = new Emails(this);
@@ -58,4 +2104,4 @@ class MailChannels extends MailChannelsClient {
   }
 }
 
-export { MailChannels, MailChannelsClient };
+export { Domains, Emails, Lists, MailChannels, MailChannelsClient, Metrics, Service, SubAccounts, Suppressions, Users, Webhooks };