mailchannels-sdk 0.3.7 → 0.4.1

package/dist/modules.mjs

@@ -9,7 +9,16 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   return ErrorCode2;
 })(ErrorCode || {});
 const getStatusError = (response, errors = {}) => {
-  return errors[response.status] || response._data?.message || "Unknown error.";
+  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) => {
@@ -84,6 +93,7 @@ class Emails {
     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),
@@ -100,7 +110,8 @@ class Emails {
       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
+      } : void 0,
+      transactional: options.transactional
     };
     const response = await this.mailchannels.post("/tx/v1/send", {
       query: { "dry-run": dryRun },
@@ -181,7 +192,7 @@ class Webhooks {
   }
   /**
    * Enrolls the customer to receive event notifications via webhooks.
-   * @param endpoint - The URL to receive event notifications.
+   * @param endpoint - The URL to receive event notifications. Must be no longer than `8000` characters.
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
@@ -194,6 +205,10 @@ class Webhooks {
       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
@@ -276,33 +291,75 @@ class Webhooks {
     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.
-   * @param handle - The handle of the sub-account to create. Sub-account handle must match the 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('validhandle123')
+   * const { account } = await mailchannels.subAccounts.create('My Company', 'validhandle123')
    * ```
    */
-  async create(handle) {
+  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 match the pattern [a-z0-9]{3,128}";
+        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: handle ? { handle } : void 0,
+      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.",
@@ -310,7 +367,12 @@ class SubAccounts {
         });
       }
     }).catch(() => null);
-    data.account = response;
+    if (!response) return data;
+    data.account = {
+      companyName: response.company_name,
+      enabled: response.enabled,
+      handle: response.handle
+    };
     return data;
   }
   /**
@@ -338,7 +400,11 @@ class SubAccounts {
         data.error = getStatusError(response2);
       }
     }).catch(() => []);
-    data.accounts = response;
+    data.accounts = response.map((account) => ({
+      companyName: account.company_name,
+      enabled: account.enabled,
+      handle: account.handle
+    }));
     return data;
   }
   /**
@@ -606,76 +672,430 @@ class SubAccounts {
     });
     return data;
   }
-}
-
-class Service {
-  constructor(mailchannels) {
-    this.mailchannels = mailchannels;
+  /**
+   * 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;
   }
   /**
-   * Retrieve the condition of the service
+   * 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.service.status()
+   * const { success } = await mailchannels.subAccounts.setLimit('validhandle123', { sends: 1000 })
    * ```
    */
-  async status() {
+  async setLimit(handle, limit) {
     const data = { success: false, error: null };
-    await this.mailchannels.get("/inbound/v1/status", {
+    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);
+        data.error = getStatusError(response, {
+          [ErrorCode.BadRequest]: "Bad Request.",
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
+        });
       }
     });
     return data;
   }
   /**
-   * Get a list of your subscriptions to MailChannels Inbound
+   * 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 { subscriptions } = await mailchannels.service.subscriptions()
+   * const { success } = await mailchannels.subAccounts.deleteLimit('validhandle123')
    * ```
    */
-  async subscriptions() {
-    const data = { subscriptions: [], error: null };
-    const response = await this.mailchannels.get("/inbound/v1/subscriptions", {
+  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]: "We could not find a customer that matched the customerHandle."
+          [ErrorCode.NotFound]: `Sub-account with handle '${handle}' not found.`
         });
       }
-    }).catch(() => []);
-    data.subscriptions = response;
+    }).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;
+  }
   /**
-   * Submit a false negative or false positive report.
-   * @param options - The report options
+   * 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 report(options) {
-    const data = { success: false, error: null };
-    const { type, ...payload } = options;
-    await this.mailchannels.post("/inbound/v1/report", {
+  async engagement(options) {
+    const data = { engagement: null, error: null };
+    const response = await this.mailchannels.get("/tx/v1/metrics/engagement", {
       query: {
-        report_type: type
+        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);
+        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 {
@@ -969,7 +1389,7 @@ class Domains {
     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.
+   * 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
@@ -1084,6 +1504,138 @@ class Domains {
     });
     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: [], 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 {
@@ -1256,93 +1808,71 @@ class Users {
   }
 }
 
-class Lists {
+class Service {
   constructor(mailchannels) {
     this.mailchannels = mailchannels;
   }
   /**
-   * Add item to account-level list
-   * @param options - The options for the list entry to add.
+   * Retrieve the condition of the service
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { entry } = await mailchannels.lists.addListEntry({
-   *   listName: 'safelist',
-   *   item: 'name@domain.com'
-   * })
+   * const { success } = await mailchannels.service.status()
    * ```
    */
-  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);
+  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);
       }
-    }).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`.
+   * Get a list of your subscriptions to MailChannels Inbound
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { entries } = await mailchannels.lists.listEntries('safelist')
+   * const { subscriptions } = await mailchannels.service.subscriptions()
    * ```
    */
-  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}`, {
+  async subscriptions() {
+    const data = { subscriptions: [], error: null };
+    const response = await this.mailchannels.get("/inbound/v1/subscriptions", {
       onResponseError: async ({ response: response2 }) => {
-        data.error = getStatusError(response2);
+        data.error = getStatusError(response2, {
+          [ErrorCode.NotFound]: "We could not find a customer that matched the customerHandle."
+        });
       }
-    }).catch(() => null);
-    if (!response) return data;
-    data.entries = response.map(({ action, item, item_type }) => ({
-      action,
-      item,
-      type: item_type
-    }));
+    }).catch(() => []);
+    data.subscriptions = response;
     return data;
   }
   /**
-   * Delete item from account-level list.
-   * @param options - The options for the list entry to delete.
+   * Submit a false negative or false positive report.
+   * @param options - The report options
    * @example
    * ```ts
    * const mailchannels = new MailChannels('your-api-key')
-   * const { success } = await mailchannels.lists.deleteListEntry({
-   *   listName: 'safelist',
-   *   item: 'name@domain.com'
+   * const { success, error } = await mailchannels.service.report({
+   * // ...
    * })
    * ```
    */
-  async deleteListEntry(options) {
-    const { listName, item } = options;
+  async report(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,
+    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;
@@ -1355,4 +1885,4 @@ class Lists {
   }
 }
 
-export { Domains, Emails, Lists, Service, SubAccounts, Users, Webhooks };
+export { Domains, Emails, Lists, Metrics, Service, SubAccounts, Suppressions, Users, Webhooks };