mailchannels-sdk 0.3.6

package/dist/modules.mjs

@@ -0,0 +1,1358 @@
+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 = {}) => {
+  return errors[response.status] || response._data?.message || "Unknown error.";
+};
+
+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 } = 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, 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,
+      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
+      }],
+      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
+    };
+    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 20MB. This includes the message itself, headers, and the combined size of any attachments."
+        });
+      }
+    }).catch(() => null);
+    data.data = response?.data;
+    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 = Array.isArray(dkim) ? dkim : [dkim];
+    const data = { results: null, error: null };
+    const payload = {
+      dkim_settings: dkimOptions.map(({ domain: domain2, privateKey, selector }) => ({
+        dkim_domain: domain2,
+        dkim_private_key: stripPemHeaders(privateKey),
+        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(({ dkim_domain, dkim_selector, reason, verdict }) => ({
+        domain: dkim_domain,
+        selector: dkim_selector,
+        reason,
+        verdict
+      })),
+      domainLockdown: response.check_results.domain_lockdown,
+      spf: response.check_results.spf,
+      references: response.references
+    };
+    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.
+   * @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;
+    }
+    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;
+  }
+}
+
+class SubAccounts {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  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.
+   * @param handle - The handle of the sub-account to create. Sub-account handle must match the pattern `[a-z0-9]{3,128}`.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { account } = await mailchannels.subAccounts.create('validhandle123')
+   * ```
+   */
+  async create(handle) {
+    const data = { account: null, error: null };
+    if (handle) {
+      const isValidHandle = SubAccounts.HANDLE_PATTERN.test(handle);
+      if (!isValidHandle) {
+        data.error = "Invalid handle. Sub-account handle must match the pattern [a-z0-9]{3,128}";
+        return data;
+      }
+    }
+    const response = await this.mailchannels.post("/tx/v1/sub-account", {
+      body: handle ? { handle } : void 0,
+      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);
+    data.account = response;
+    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;
+    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.
+   * @example
+   * ```ts
+   * const mailchannels = new MailChannels('your-api-key')
+   * const { keys } = await mailchannels.subAccounts.listApiKeys('validhandle123')
+   * ```
+   */
+  async listApiKeys(handle) {
+    const data = { keys: [], error: null };
+    if (!handle) {
+      data.error = "No handle provided.";
+      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;
+  }
+}
+
+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
+   */
+  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 Domains {
+  constructor(mailchannels) {
+    this.mailchannels = mailchannels;
+  }
+  /**
+   * Provision a single domain to use MailChannels Inbound.
+   * @param options - The domain data to provision.
+   * @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 - The list of domains 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 addreses 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;
+  }
+}
+
+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 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;
+  }
+}
+
+export { Domains, Emails, Lists, Service, SubAccounts, Users, Webhooks };