mailchannels-sdk 0.3.7 → 0.4.0

package/dist/shared/{mailchannels-sdk.BDB65ygx.d.ts → mailchannels-sdk.DUD1k4jz.d.ts}

@@ -55,6 +55,10 @@ interface EmailsSendOptionsBase {
    * An array of attachments to be sent with the email.
    */
   attachments?: EmailsSendAttachment[];
+  /**
+   * The campaign identifier. If specified, this ID will be included in all relevant webhooks. It can be up to 48 UTF-8 characters long and must not contain spaces.
+   */
+  campaignId?: string;
   /**
    * The BCC recipients of the email. Can be an array of email addresses or an array of objects with email and name properties or a single email address string or an object with email and name properties.
    * @example
@@ -162,6 +166,13 @@ interface EmailsSendOptionsBase {
    * - map, whose keys must be strings, and whose values are all of permitted types
    */
   mustaches?: Record<string, unknown>;
+  /**
+   * Mark these messages as transactional or non-transactional. In order for a message to be marked as non-transactional, it must have exactly one recipient per personalization, and it must be DKIM signed. 400 Bad Request will be returned if there are more than one recipient in any personalization for non-transactional messages. If a message is marked as non-transactional, it changes the sending process as follows:
+   *
+   * List-Unsubscribe headers will be added.
+   * @default true
+   */
+  transactional?: boolean;
 }
 
 type EmailsSendOptions = EmailsSendOptionsBase & (
@@ -332,12 +343,46 @@ interface WebhooksSigningKeyResponse {
   error: string | null;
 }
 
+interface WebhooksValidateResponse {
+  /**
+   * Indicates whether all webhook validations passed
+   */
+  allPassed: boolean;
+  /**
+   * Detailed results for each tested webhook, including whether it returned a 2xx status code, along with its response status code and body.
+   */
+  results: {
+    /**
+     * Indicates whether the webhook responded with a 2xx HTTP status code
+     */
+    result: "passed" | "failed";
+    /**
+     * The webhook that was validated
+     */
+    webhook: string;
+    /**
+     * The HTTP response returned by the webhook, including status code and response body. A null value indicates no response was received. Possible reasons include timeouts, connection failures, or other network-related issues.
+     */
+    response: {
+      /**
+       * Response body from webhook. Returns an error if unprocessable or too large.
+       */
+      body?: string;
+      /**
+       * HTTP status code returned by the webhook
+       */
+      status: number;
+    } | null;
+  }[];
+  error: string | null;
+}
+
 declare class Webhooks {
     protected mailchannels: MailChannelsClient;
     constructor(mailchannels: MailChannelsClient);
     /**
      * 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')
@@ -373,9 +418,23 @@ declare class Webhooks {
      * ```
      */
     getSigningKey(id: string): Promise<WebhooksSigningKeyResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    validate(requestId?: string): Promise<WebhooksValidateResponse>;
 }
 
 interface SubAccountsAccount {
+  /**
+   * The name of the company associated with the sub-account.
+   */
+  companyName: string;
   /**
    * If the sub-account is enabled.
    */
@@ -455,20 +514,53 @@ interface SubAccountsListSmtpPasswordResponse {
   error: string | null;
 }
 
+interface SubAccountsLimit {
+  sends: number;
+}
+
+interface SubAccountsLimitResponse {
+  limit: SubAccountsLimit | null;
+  error: string | null;
+}
+
+interface SubAccountsUsage {
+  /**
+   * The end date of the current billing period (ISO 8601 format).
+   * @example "2025-04-11"
+   */
+  endDate?: string;
+  /**
+   * The start date of the current billing period (ISO 8601 format).
+   * @example "2025-03-12"
+   */
+  startDate?: string;
+  /**
+   * The total usage for the current billing period.
+   */
+  total: number;
+}
+
+interface SubAccountsUsageResponse {
+  usage: SubAccountsUsage | null;
+  error: string | null;
+}
+
 declare class SubAccounts {
     protected mailchannels: MailChannelsClient;
+    private static readonly COMPANY_PATTERN;
     private static readonly HANDLE_PATTERN;
     constructor(mailchannels: MailChannelsClient);
     /**
-     * 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')
      * ```
      */
-    create(handle?: string): Promise<SubAccountsCreateResponse>;
+    create(companyName: string, handle?: string): Promise<SubAccountsCreateResponse>;
     /**
      * 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.
@@ -570,104 +662,343 @@ declare class SubAccounts {
      * ```
      */
     deleteSmtpPassword(handle: string, id: number): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    getLimit(handle: string): Promise<SubAccountsLimitResponse>;
+    /**
+     * 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 })
+     * ```
+     */
+    setLimit(handle: string, limit: SubAccountsLimit): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    deleteLimit(handle: string): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    getUsage(handle: string): Promise<SubAccountsUsageResponse>;
 }
 
-interface ServiceSubscriptionsResponse {
-  subscriptions: {
-    active: boolean;
-    activeAccountsCount: number;
-    handle: string;
-    limits: {
-      featureHandle: string;
-      value: string;
-    }[];
-    plan: {
-      handle: string;
-      name: string;
-    };
-  }[];
+interface MetricsEngagement {
+  buckets: {
+    click: MetricsBucket[];
+    clickTrackingDelivered: MetricsBucket[];
+    open: MetricsBucket[];
+    openTrackingDelivered: MetricsBucket[];
+  };
+  click: number;
+  clickTrackingDelivered: number;
+  endTime: string;
+  open: number;
+  openTrackingDelivered: number;
+  startTime: string;
+}
+
+interface MetricsEngagementResponse {
+  engagement: MetricsEngagement | null;
   error: string | null;
 }
 
-interface ServiceReportOptions {
+interface MetricsPerformance {
   /**
-   * The report type. It can be either `false_negative` or `false_positive`.
+   * Count of messages bounced during the specified time range.
    */
-  type: "false_negative" | "false_positive";
+  bounced: number;
+  buckets: {
+    bounced: MetricsBucket[];
+    delivered: MetricsBucket[];
+    processed: MetricsBucket[];
+  };
   /**
-   * The full, unaltered message content in accordance with the RFC 2822 specifications without dot stuffing.
+   * Count of messages delivered during the specified time range.
    */
-  messageContent: string;
+  delivered: number;
   /**
-   * The SMTP envelope information
+   * The end of the time range for retrieving message performance metrics (exclusive).
    */
-  smtpEnvelopeInformation?: {
-    ehlo: string;
-    mailFrom: string;
-    rcptTo: string;
+  endTime: string;
+  /**
+   * Count of messages processed during the specified time range.
+   */
+  processed: number;
+  /**
+   * The beginning of the time range for retrieving message performance metrics (inclusive).
+   */
+  startTime: string;
+}
+
+interface MetricsPerformanceResponse {
+  performance: MetricsPerformance | null;
+  error: string | null;
+}
+
+interface MetricsRecipientBehaviour {
+  buckets: {
+    unsubscribeDelivered: MetricsBucket[];
+    unsubscribed: MetricsBucket[];
   };
   /**
-   * The sending host information.
+   * The end of the time range for retrieving recipient behaviour metrics (exclusive).
    */
-  sendingHostInformation?: {
-    name: string;
+  endTime: string;
+  /**
+   * The beginning of the time range for retrieving recipient behaviour metrics (inclusive).
+   */
+  startTime: string;
+  /**
+   * Count of recipients of delivered messages that include at least one of the unsubscribe link or unsubscribe headers. Since the unsubscribe feature requires exactly one recipient per message, this count also represents the total number of delivered messages.
+   */
+  unsubscribeDelivered: number;
+  /**
+   * Count of unsubscribed events by recipients.
+   */
+  unsubscribed: number;
+}
+
+interface MetricsRecipientBehaviourResponse {
+  behaviour: MetricsRecipientBehaviour | null;
+  error: string | null;
+}
+
+interface MetricsVolume {
+  buckets: {
+    delivered: MetricsBucket[];
+    dropped: MetricsBucket[];
+    processed: MetricsBucket[];
   };
+  /**
+   * Count of messages delivered during the specified time range.
+   */
+  delivered: number;
+  /**
+   * Count of messages dropped during the specified time range.
+   */
+  dropped: number;
+  /**
+   * The end of the time range for retrieving message volume metrics (exclusive).
+   */
+  endTime: string;
+  /**
+   * Count of messages processed during the specified time range.
+   */
+  processed: number;
+  /**
+   * The beginning of the time range for retrieving message volume metrics (inclusive).
+   */
+  startTime: string;
+}
+
+interface MetricsVolumeResponse {
+  volume: MetricsVolume | null;
+  error: string | null;
 }
 
-declare class Service {
+interface MetricsUsageResponse {
+  usage: {
+    /**
+     * The end date of the current billing period (ISO 8601 format).
+     * @example "2025-04-11"
+     */
+    endDate: string;
+    /**
+     * The start date of the current billing period (ISO 8601 format).
+     * @example "2025-03-12"
+     */
+    startDate: string;
+    /**
+     * The total usage for the current billing period.
+     */
+    total: number;
+  } | null;
+  error: string | null;
+}
+
+interface MetricsBucket {
+  /**
+   * The number of events or occurrences aggregated within this time period.
+   */
+  count: number;
+  /**
+   * The starting date and time of the time period this bucket represents.
+   */
+  periodStart: string;
+}
+
+interface MetricsOptions {
+  /**
+   * The beginning of the time range for retrieving message metrics (inclusive). Formats: `YYYY-MM-DD` or `YYYY-MM-DDTHH:MM:SSZ`. Defaults to one month ago if not provided.
+   * @example "2025-05-26"
+   */
+  startTime?: string;
+  /**
+   * The end of the time range for retrieving message metrics (exclusive). Formats: `YYYY-MM-DD` or `YYYY-MM-DDTHH:MM:SSZ`. Defaults to the current time if not provided.
+   * @example "2025-05-31T15:16:17Z"
+   */
+  endTime?: string;
+  /**
+   * The ID of the campaign to filter metrics by. If not provided, metrics for all campaigns will be returned.
+   */
+  campaignId?: string;
+  /**
+   * The interval for aggregating metrics data.
+   * @default "day"
+   */
+  interval?: "hour" | "day" | "week" | "month";
+}
+
+declare class Metrics {
     protected mailchannels: MailChannelsClient;
     constructor(mailchannels: MailChannelsClient);
     /**
-     * Retrieve the condition of the service
+     * 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 { success } = await mailchannels.service.status()
+     * const { engagement } = await mailchannels.metrics.engagement()
      * ```
      */
-    status(): Promise<SuccessResponse>;
+    engagement(options?: MetricsOptions): Promise<MetricsEngagementResponse>;
     /**
-     * Get a list of your subscriptions to MailChannels Inbound
+     * 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 { subscriptions } = await mailchannels.service.subscriptions()
+     * const { performance } = await mailchannels.metrics.performance()
      * ```
      */
-    subscriptions(): Promise<ServiceSubscriptionsResponse>;
+    performance(options?: MetricsOptions): Promise<MetricsPerformanceResponse>;
     /**
-     * Submit a false negative or false positive report.
-     * @param options - The report options
+     * 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()
+     * ```
      */
-    report(options: ServiceReportOptions): Promise<SuccessResponse>;
+    recipientBehaviour(options?: MetricsOptions): Promise<MetricsRecipientBehaviourResponse>;
+    /**
+     * 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()
+     * ```
+     */
+    volume(options?: MetricsOptions): Promise<MetricsVolumeResponse>;
+    /**
+     * Retrieves usage statistics during the current billing period.
+     * @example
+     * ```ts
+     * const mailchannels = new MailChannels('your-api-key')
+     * const { usage } = await mailchannels.metrics.usage()
+     * ```
+     */
+    usage(): Promise<MetricsUsageResponse>;
 }
 
-type ListNames = "blocklist" | "safelist" | "blacklist" | "whitelist";
+type SuppressionsTypes = "transactional" | "non-transactional";
 
-interface ListEntryOptions {
+interface SuppressionsCreateOptions {
   /**
-   * This can be a `blocklist`, `safelist`, `blacklist`, or `whitelist`.
+   * If true, the parent account creates suppression entries for all associated sub-accounts. This field is only applicable to parent accounts. Sub-accounts cannot create entries for other sub-accounts.
+   * @default false
    */
-  listName: ListNames;
+  addToSubAccounts?: boolean;
   /**
-   *  This can be a domain, email address, or IP address. The type of the entry is automatically determined based on the value.
+   * The total number of suppression entries to create, for the parent and/or its sub-accounts, must not exceed `1000`.
    */
-  item: string;
-}
+  entries: {
+    /**
+     * Must be less than `1024` characters.
+     */
+    notes?: string;
+    /**
+     * The email address to suppress. Must be a valid email address format and less than `255` characters.
+     */
+    recipient: string;
+    /**
+     * An array of types of suppression to apply to the recipient.
+     * @default ["non-transactional"]
+     */
+    types?: SuppressionsTypes[];
+  }[];
+}
+
+type SuppressionsSource = "api" | "unsubscribe_link" | "list_unsubscribe" | "hard_bounce" | "spam_complaint" | "all";
 
-interface ListEntry {
-  action: Extract<ListNames, "blocklist" | "safelist">;
-  item: string;
-  type: "domain" | "email_address" | "ip_address";
+interface SuppressionsListOptions {
+  /**
+   * The email address of the suppression entry to search for. If provided, the search will return the suppression entry associated with this recipient. If not provided, the search will return all suppression entries for the account.
+   */
+  recipient?: string;
+  /**
+   * The source of the suppression entries to filter by. If not provided, suppression entries from all sources will be returned.
+   */
+  source?: Exclude<SuppressionsSource, "all">;
+  /**
+   * The date and/or time before which the suppression entries were created. Format: `YYYY-MM-DD` or `YYYY-MM-DDTHH:MM:SSZ`
+   */
+  createdBefore?: string;
+  /**
+   * The date and/or time after which the suppression entries were created. Format: `YYYY-MM-DD` or `YYYY-MM-DDTHH:MM:SSZ`
+   */
+  createdAfter?: string;
+  /**
+   * The maximum number of suppression entries to return. Must be between `1` and `1000`.
+   * @default 1000
+   */
+  limit?: number;
+  /**
+   * The number of suppression entries to skip before returning results.
+   * @default 0
+   */
+  offset?: number;
 }
 
-interface ListEntryResponse {
-  entry: ListEntry | null;
-  error: string | null;
+interface SuppressionsListEntry {
+  createdAt: string;
+  notes?: string;
+  /**
+   * The email address that is suppressed.
+   */
+  recipient: string;
+  sender?: string;
+  source: SuppressionsSource;
+  types: SuppressionsTypes[];
 }
 
-interface ListEntriesResponse {
-  entries: ListEntry[];
+interface SuppressionsListResponse {
+  list: SuppressionsListEntry[];
   error: string | null;
 }
 
@@ -849,6 +1180,151 @@ interface DomainsListDownstreamAddressesResponse {
   error: string | null;
 }
 
+type ListNames = "blocklist" | "safelist" | "blacklist" | "whitelist";
+
+interface ListEntryOptions {
+  /**
+   * This can be a `blocklist`, `safelist`, `blacklist`, or `whitelist`.
+   */
+  listName: ListNames;
+  /**
+   *  This can be a domain, email address, or IP address. The type of the entry is automatically determined based on the value.
+   */
+  item: string;
+}
+
+interface ListEntry {
+  action: Extract<ListNames, "blocklist" | "safelist">;
+  item: string;
+  type: "domain" | "email_address" | "ip_address";
+}
+
+interface ListEntryResponse {
+  entry: ListEntry | null;
+  error: string | null;
+}
+
+interface ListEntriesResponse {
+  entries: ListEntry[];
+  error: string | null;
+}
+
+interface UsersCreateOptions {
+  /**
+   * Flag to indicate if the user is a domain admin or a regular user
+   * @default false
+   */
+  admin?: boolean;
+  /**
+   * Whether or not to filter mail for this recipient. There are three valid values.
+   * - `false` -  Filtering policy will be applied to messages intended for this recipient. If this would exceed the protected-addresses limit, return an error.
+   * - `true` - Filtering policy will not be applied to messages intended for this recipient.
+   * - `compute` - Filtering policy will be applied to messages intended for this recipient. If this would exceed the protected-addresses limit, filtering policy will not be applied, and no error will be returned.
+   * @default 'compute'
+   */
+  filter?: boolean | "compute";
+  /**
+   * safelist and blocklist entries to be added
+   */
+  listEntries?: {
+    blocklist?: string[];
+    safelist?: string[];
+  };
+}
+
+interface UsersCreateResponse {
+  user: {
+    email: string;
+    roles: string[];
+    filter?: boolean;
+    listEntries: {
+      item: string;
+      type: "domain" | "email_address" | "ip_address";
+      action: "safelist" | "blocklist";
+    }[];
+  } | null;
+  error: string | null;
+}
+
+interface ServiceSubscriptionsResponse {
+  subscriptions: {
+    active: boolean;
+    activeAccountsCount: number;
+    handle: string;
+    limits: {
+      featureHandle: string;
+      value: string;
+    }[];
+    plan: {
+      handle: string;
+      name: string;
+    };
+  }[];
+  error: string | null;
+}
+
+interface ServiceReportOptions {
+  /**
+   * The report type. It can be either `false_negative` or `false_positive`.
+   */
+  type: "false_negative" | "false_positive";
+  /**
+   * The full, unaltered message content in accordance with the RFC 2822 specifications without dot stuffing.
+   */
+  messageContent: string;
+  /**
+   * The SMTP envelope information
+   */
+  smtpEnvelopeInformation?: {
+    ehlo: string;
+    mailFrom: string;
+    rcptTo: string;
+  };
+  /**
+   * The sending host information.
+   */
+  sendingHostInformation?: {
+    name: string;
+  };
+}
+
+declare class Suppressions {
+    protected mailchannels: MailChannelsClient;
+    constructor(mailchannels: MailChannelsClient);
+    /**
+     * 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 response = await mailchannels.suppressions.create({
+     * // ...
+     * });
+     */
+    create(options: SuppressionsCreateOptions): Promise<SuccessResponse>;
+    /**
+     * 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 response = await mailchannels.suppressions.delete('name@example.com', 'api');
+     * ```
+     */
+    delete(recipient: string, source?: SuppressionsSource): Promise<SuccessResponse>;
+    /**
+     * 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 response = await mailchannels.suppressions.list();
+     * ```
+     * @param options - Options to filter and customize the suppression entries retrieval.
+     */
+    list(options?: SuppressionsListOptions): Promise<SuppressionsListResponse>;
+}
+
 declare class Domains {
     protected mailchannels: MailChannelsClient;
     constructor(mailchannels: MailChannelsClient);
@@ -997,41 +1473,45 @@ declare class Domains {
     updateApiKey(domain: string, key: string): Promise<SuccessResponse>;
 }
 
-interface UsersCreateOptions {
-  /**
-   * Flag to indicate if the user is a domain admin or a regular user
-   * @default false
-   */
-  admin?: boolean;
-  /**
-   * Whether or not to filter mail for this recipient. There are three valid values.
-   * - `false` -  Filtering policy will be applied to messages intended for this recipient. If this would exceed the protected-addresses limit, return an error.
-   * - `true` - Filtering policy will not be applied to messages intended for this recipient.
-   * - `compute` - Filtering policy will be applied to messages intended for this recipient. If this would exceed the protected-addresses limit, filtering policy will not be applied, and no error will be returned.
-   * @default 'compute'
-   */
-  filter?: boolean | "compute";
-  /**
-   * safelist and blocklist entries to be added
-   */
-  listEntries?: {
-    blocklist?: string[];
-    safelist?: string[];
-  };
-}
-
-interface UsersCreateResponse {
-  user: {
-    email: string;
-    roles: string[];
-    filter?: boolean;
-    listEntries: {
-      item: string;
-      type: "domain" | "email_address" | "ip_address";
-      action: "safelist" | "blocklist";
-    }[];
-  } | null;
-  error: string | null;
+declare class Lists {
+    protected mailchannels: MailChannelsClient;
+    constructor(mailchannels: MailChannelsClient);
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    addListEntry(options: ListEntryOptions): Promise<ListEntryResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    listEntries(listName: ListNames): Promise<ListEntriesResponse>;
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    deleteListEntry(options: ListEntryOptions): Promise<SuccessResponse>;
 }
 
 declare class Users {
@@ -1091,46 +1571,40 @@ declare class Users {
     deleteListEntry(email: string, options: ListEntryOptions): Promise<SuccessResponse>;
 }
 
-declare class Lists {
+declare class Service {
     protected mailchannels: MailChannelsClient;
     constructor(mailchannels: MailChannelsClient);
     /**
-     * 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()
      * ```
      */
-    addListEntry(options: ListEntryOptions): Promise<ListEntryResponse>;
+    status(): Promise<SuccessResponse>;
     /**
-     * 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()
      * ```
      */
-    listEntries(listName: ListNames): Promise<ListEntriesResponse>;
+    subscriptions(): Promise<ServiceSubscriptionsResponse>;
     /**
-     * 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({
+     * // ...
      * })
      * ```
      */
-    deleteListEntry(options: ListEntryOptions): Promise<SuccessResponse>;
+    report(options: ServiceReportOptions): Promise<SuccessResponse>;
 }
 
-export { Domains as D, Emails as E, Lists as L, MailChannelsClient as M, SubAccounts as S, Users as U, Webhooks as W, Service as a };
-export type { DomainsProvisionResponse as A, DomainsBulkProvisionResponse as B, DomainsListOptions as C, DomainsListResponse as F, DomainsCreateLoginLinkResponse as G, DomainsListDownstreamAddressesOptions as H, DomainsDownstreamAddress as I, DomainsListDownstreamAddressesResponse as J, ServiceSubscriptionsResponse as K, ServiceReportOptions as N, SuccessResponse as O, ListNames as P, ListEntryOptions as Q, ListEntry as R, ListEntryResponse as T, ListEntriesResponse as V, EmailsSendRecipient as b, EmailsSendAttachment as c, EmailsSendTracking as d, EmailsSendOptionsBase as e, EmailsSendOptions as f, EmailsSendResponse as g, EmailsCheckDomainDkim as h, EmailsCheckDomainOptions as i, EmailsCheckDomainVerdict as j, EmailsCheckDomainResponse as k, SubAccountsAccount as l, SubAccountsCreateResponse as m, SubAccountsListOptions as n, SubAccountsListResponse as o, SubAccountsApiKey as p, SubAccountsCreateApiKeyResponse as q, SubAccountsListApiKeyResponse as r, SubAccountsSmtpPassword as s, SubAccountsCreateSmtpPasswordResponse as t, SubAccountsListSmtpPasswordResponse as u, WebhooksListResponse as v, WebhooksSigningKeyResponse as w, DomainsData as x, DomainsProvisionOptions as y, DomainsBulkProvisionOptions as z };
+export { Domains as D, Emails as E, Lists as L, MailChannelsClient as M, SubAccounts as S, Users as U, Webhooks as W, Metrics as a, Suppressions as b, Service as c };
+export type { SuppressionsListResponse as $, SubAccountsLimit as A, SubAccountsLimitResponse as B, SubAccountsUsage as C, SubAccountsUsageResponse as F, MetricsBucket as G, MetricsOptions as H, MetricsEngagement as I, MetricsEngagementResponse as J, MetricsPerformance as K, MetricsPerformanceResponse as N, MetricsRecipientBehaviour as O, MetricsRecipientBehaviourResponse as P, MetricsVolume as Q, MetricsVolumeResponse as R, MetricsUsageResponse as T, SuppressionsTypes as V, SuppressionsCreateOptions as X, SuppressionsSource as Y, SuppressionsListOptions as Z, SuppressionsListEntry as _, DomainsData as a0, DomainsProvisionOptions as a1, DomainsBulkProvisionOptions as a2, DomainsProvisionResponse as a3, DomainsBulkProvisionResponse as a4, DomainsListOptions as a5, DomainsListResponse as a6, DomainsCreateLoginLinkResponse as a7, DomainsListDownstreamAddressesOptions as a8, DomainsDownstreamAddress as a9, DomainsListDownstreamAddressesResponse as aa, ListNames as ab, ListEntryOptions as ac, ListEntry as ad, ListEntryResponse as ae, ListEntriesResponse as af, UsersCreateOptions as ag, UsersCreateResponse as ah, ServiceSubscriptionsResponse as ai, ServiceReportOptions as aj, SuccessResponse as ak, EmailsSendRecipient as d, EmailsSendAttachment as e, EmailsSendTracking as f, EmailsSendOptionsBase as g, EmailsSendOptions as h, EmailsSendResponse as i, EmailsCheckDomainDkim as j, EmailsCheckDomainOptions as k, EmailsCheckDomainVerdict as l, EmailsCheckDomainResponse as m, WebhooksListResponse as n, WebhooksSigningKeyResponse as o, WebhooksValidateResponse as p, SubAccountsAccount as q, SubAccountsCreateResponse as r, SubAccountsListOptions as s, SubAccountsListResponse as t, SubAccountsApiKey as u, SubAccountsCreateApiKeyResponse as v, SubAccountsListApiKeyResponse as w, SubAccountsSmtpPassword as x, SubAccountsCreateSmtpPasswordResponse as y, SubAccountsListSmtpPasswordResponse as z };