mailchannels-sdk 0.3.6

package/dist/shared/mailchannels-sdk.BDB65ygx.d.ts

@@ -0,0 +1,1136 @@
+import { FetchOptions } from 'ofetch';
+
+declare class MailChannelsClient {
+    #private;
+    private static BASE_URL;
+    constructor(key: string);
+    protected _fetch<T>(path: string, options?: FetchOptions<"json">): Promise<T>;
+    post<T>(path: string, options?: Omit<FetchOptions<"json">, "method">): Promise<T>;
+    get<T>(path: string, options?: Omit<FetchOptions<"json">, "method">): Promise<T>;
+    delete<T>(path: string, options?: Omit<FetchOptions<"json">, "method">): Promise<T>;
+    put<T>(path: string, options?: Omit<FetchOptions<"json">, "method">): Promise<T>;
+}
+
+interface EmailsSendRecipient {
+  /**
+   * The email address of the recipient.
+   */
+  email: string;
+  /**
+   * The name of the recipient.
+   */
+  name?: string;
+}
+
+interface EmailsSendAttachment {
+  /**
+   * The attachment data, encoded in base64.
+   */
+  content: string;
+  /**
+   * The name of the attachment file.
+   */
+  filename: string;
+  /**
+   * The MIME type of the attachment.
+   */
+  type: string;
+}
+
+interface EmailsSendTracking {
+  /**
+   * Track when a recipient clicks a link in your email.
+   * @default false
+   */
+  click?: boolean;
+  /**
+   * Track when a recipient opens your email. Please note that some email clients may not support open tracking.
+   * @default false
+   */
+  open?: boolean;
+}
+
+interface EmailsSendOptionsBase {
+  /**
+   * An array of attachments to be sent with the email.
+   */
+  attachments?: EmailsSendAttachment[];
+  /**
+   * 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
+   * [
+   *   { email: 'email1@example.com', name: 'Example1' },
+   *   { email: 'email2@example.com', name: 'Example2' }
+   * ]
+   * @example
+   * { email: 'email@example.com', name: 'Example' }
+   * @example
+   * ['email1@example.com', 'email2@example.com']
+   * @example
+   * 'email@example.com'
+   * @example
+   * 'Name <email@example.com>'
+   */
+  bcc?: EmailsSendRecipient[] | EmailsSendRecipient | string[] | string;
+  /**
+   * The CC 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
+   * [
+   *   { email: 'email1@example.com', name: 'Example1' },
+   *   { email: 'email2@example.com', name: 'Example2' }
+   * ]
+   * @example
+   * { email: 'email@example.com', name: 'Example' }
+   * @example
+   * ['email1@example.com', 'email2@example.com']
+   * @example
+   * 'email@example.com'
+   * @example
+   * 'Name <email@example.com>'
+   */
+  cc?: EmailsSendRecipient[] | EmailsSendRecipient | string[] | string;
+  /**
+   * The DKIM settings for the email.
+   */
+  dkim?: {
+    /**
+     * Domain used for DKIM signing.
+     */
+    domain: string;
+    /**
+     * DKIM private key encoded in Base64.
+     */
+    privateKey: string;
+    /**
+     * DKIM selector in the domain DNS records.
+     */
+    selector: string;
+  };
+  /**
+   * The sender of the email. Can be a string or an object with email and name properties.
+   * @example
+   * { email: 'email@example.com', name: 'Example' }
+   * @example
+   * 'email@example.com'
+   * @example
+   * 'Name <email@example.com>'
+   */
+  from: EmailsSendRecipient | string;
+  /**
+   * The recipient 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
+   * [
+   *   { email: 'email1@example.com', name: 'Example1' },
+   *   { email: 'email2@example.com', name: 'Example2' },
+   * ]
+   * @example
+   * { email: 'email@example.com', name: 'Example' }
+   * @example
+   * ['email1@example.com', 'email2@example.com']
+   * @example
+   * 'email@example.com'
+   * @example
+   * 'Name <email@example.com>'
+   */
+  to: EmailsSendRecipient[] | EmailsSendRecipient | string[] | string;
+  /**
+   * Adjust open and click tracking for the message. Please note that enabling tracking for your messages requires a subscription that supports open and click tracking.
+   */
+  tracking?: EmailsSendTracking;
+  /**
+   * A single `replyTo` recipient object, or a single email address.
+   * @example
+   * { email: 'email@example.com', name: 'Example' }
+   * @example
+   * 'email@example.com'
+   * @example
+   * 'Name <email@example.com>'
+   */
+  replyTo?: EmailsSendRecipient | string;
+  /**
+   * The subject of the email.
+   */
+  subject: string;
+  /**
+   * Data to be used if the email is a mustache template, key-value pairs of variables to set for template rendering. Keys must be strings.
+   *
+   * the values can be one of the following types:
+   * - string
+   * - number
+   * - boolean
+   * - list, whose values are all of permitted types
+   * - map, whose keys must be strings, and whose values are all of permitted types
+   */
+  mustaches?: Record<string, unknown>;
+}
+
+type EmailsSendOptions = EmailsSendOptionsBase & (
+  | {
+    /**
+     * The HTML content of the email
+     * @example
+     * '<p>Hello World</p>'
+     */
+    html: string;
+    /**
+     * The plain text content of the email (optional when html is provided)
+     * @example
+     * 'Hello World'
+     */
+    text?: string;
+  }
+  | {
+    /**
+     * The HTML content of the email (optional when text is provided)
+     * @example
+     * '<p>Hello World</p>'
+     */
+    html?: string;
+    /**
+     * The plain text content of the email
+     * @example
+     * 'Hello World'
+     */
+    text: string;
+  }
+);
+
+interface EmailsSendResponse {
+  /**
+   * Indicates if the email was successfully sent
+   */
+  success: boolean;
+  /**
+   * Fully rendered message if `dryRun` was set to `true`
+   */
+  data?: string[];
+  error: string | null;
+}
+
+interface EmailsCheckDomainDkim {
+  /**
+   * Domain used for DKIM signing.
+   */
+  domain: string;
+  /**
+   * DKIM private key encoded in Base64.
+   */
+  privateKey: string;
+  /**
+   * DKIM selector in the domain DNS records.
+   */
+  selector: string;
+}
+
+interface EmailsCheckDomainOptions {
+  /**
+   * Up to 10 DKIM checks are allowed.
+   */
+  dkim: EmailsCheckDomainDkim[] | EmailsCheckDomainDkim;
+  /**
+   * Domain used for sending emails.
+   */
+  domain: string;
+  /**
+   * `X-MailChannels-Sender-Id` header value in emails via MailChannels.
+   */
+  senderId: string;
+}
+
+type EmailsCheckDomainVerdict = "passed" | "failed" | "soft failed" | "temporary error" | "permanent error" | "neutral" | "none" | "unknown";
+
+interface EmailsCheckDomainResponse {
+  /**
+   * The results of the domain checks.
+   */
+  results: {
+    dkim: {
+      domain: string;
+      selector: string;
+      /**
+       * A human-readable explanation of DKIM check.
+       */
+      reason?: string;
+      verdict: Extract<EmailsCheckDomainVerdict, "passed" | "failed">;
+    }[];
+    domainLockdown: {
+      /**
+       * A human-readable explanation of Domain Lockdown check.
+       */
+      reason?: string;
+      verdict: Extract<EmailsCheckDomainVerdict, "passed" | "failed">;
+    };
+    spf: {
+      /**
+       * A human-readable explanation of SPF check.
+       */
+      reason?: string;
+      verdict: EmailsCheckDomainVerdict;
+    };
+    references?: string[];
+  } | null;
+  /**
+   * Link to SPF, Domain Lockdown or DKIM references, displayed if any verdict is not passed.
+   */
+  error: string | null;
+}
+
+declare class Emails {
+    protected mailchannels: MailChannelsClient;
+    constructor(mailchannels: MailChannelsClient);
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    send(options: EmailsSendOptions, dryRun?: boolean): Promise<EmailsSendResponse>;
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    checkDomain(options: EmailsCheckDomainOptions): Promise<EmailsCheckDomainResponse>;
+}
+
+interface SuccessResponse {
+  /**
+   * Whether the operation was successful.
+   */
+  success: boolean;
+  error: string | null;
+}
+
+interface WebhooksListResponse {
+  webhooks: string[];
+  error: string | null;
+}
+
+interface WebhooksSigningKeyResponse {
+  key: string | 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.
+     * @example
+     * ```ts
+     * const mailchannels = new MailChannels('your-api-key')
+     * const { success } = mailchannels.webhooks.enroll('https://example.com/api/webhooks/mailchannels')
+     * ```
+     */
+    enroll(endpoint: string): Promise<SuccessResponse>;
+    /**
+     * Retrieves all registered webhook endpoints associated with the customer.
+     * @example
+     * ```ts
+     * const mailchannels = new MailChannels('your-api-key')
+     * const { webhooks } = await mailchannels.webhooks.list()
+     * ```
+     */
+    list(): Promise<WebhooksListResponse>;
+    /**
+     * Deletes all registered webhook endpoints for the customer.
+     * @example
+     * ```ts
+     * const mailchannels = new MailChannels('your-api-key')
+     * const { success } = await mailchannels.webhooks.delete()
+     * ```
+     */
+    delete(): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    getSigningKey(id: string): Promise<WebhooksSigningKeyResponse>;
+}
+
+interface SubAccountsAccount {
+  /**
+   * If the sub-account is enabled.
+   */
+  enabled: boolean;
+  /**
+   * The handle for the sub-account.
+   */
+  handle: string;
+}
+
+interface SubAccountsCreateResponse {
+  account: SubAccountsAccount | null;
+  error: string | null;
+}
+
+interface SubAccountsListOptions {
+  /**
+   * Possible values are `1` to `1000`.
+   * @default 1000
+   */
+  limit?: number;
+  /**
+   * The offset for pagination.
+   * @default 0
+   */
+  offset?: number;
+}
+
+interface SubAccountsListResponse {
+  accounts: SubAccountsAccount[];
+  error: string | null;
+}
+
+interface SubAccountsApiKey {
+  /**
+   * The API key ID for the sub-account.
+   */
+  id: number;
+  /**
+   * API key for the sub-account.
+   */
+  value: string;
+}
+
+interface SubAccountsCreateApiKeyResponse {
+  key: SubAccountsApiKey | null;
+  error: string | null;
+}
+
+interface SubAccountsListApiKeyResponse {
+  keys: SubAccountsApiKey[];
+  error: string | null;
+}
+
+interface SubAccountsSmtpPassword {
+  /**
+   * Whether the SMTP password is enabled.
+   */
+  enabled: boolean;
+  /**
+   * The SMTP password ID for the sub-account.
+   */
+  id: number;
+  /**
+   * SMTP password for the sub-account.
+   */
+  value: string;
+}
+
+interface SubAccountsCreateSmtpPasswordResponse {
+  password: SubAccountsSmtpPassword | null;
+  error: string | null;
+}
+
+interface SubAccountsListSmtpPasswordResponse {
+  passwords: SubAccountsSmtpPassword[];
+  error: string | null;
+}
+
+declare class SubAccounts {
+    protected mailchannels: MailChannelsClient;
+    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}`.
+     * @example
+     * ```ts
+     * const mailchannels = new MailChannels('your-api-key')
+     * const { account } = await mailchannels.subAccounts.create('validhandle123')
+     * ```
+     */
+    create(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.
+     * @example
+     * ```ts
+     * const mailchannels = new MailChannels('your-api-key')
+     * const { accounts } = await mailchannels.subAccounts.list()
+     * ```
+     */
+    list(options?: SubAccountsListOptions): Promise<SubAccountsListResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    delete(handle: string): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    suspend(handle: string): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    activate(handle: string): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    createApiKey(handle: string): Promise<SubAccountsCreateApiKeyResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    listApiKeys(handle: string): Promise<SubAccountsListApiKeyResponse>;
+    /**
+     * 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)
+     * ```
+     */
+    deleteApiKey(handle: string, id: number): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    createSmtpPassword(handle: string): Promise<SubAccountsCreateSmtpPasswordResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    listSmtpPasswords(handle: string): Promise<SubAccountsListSmtpPasswordResponse>;
+    /**
+     * 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)
+     * ```
+     */
+    deleteSmtpPassword(handle: string, id: number): Promise<SuccessResponse>;
+}
+
+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 Service {
+    protected mailchannels: MailChannelsClient;
+    constructor(mailchannels: MailChannelsClient);
+    /**
+     * Retrieve the condition of the service
+     * @example
+     * ```ts
+     * const mailchannels = new MailChannels('your-api-key')
+     * const { success } = await mailchannels.service.status()
+     * ```
+     */
+    status(): Promise<SuccessResponse>;
+    /**
+     * Get a list of your subscriptions to MailChannels Inbound
+     * @example
+     * ```ts
+     * const mailchannels = new MailChannels('your-api-key')
+     * const { subscriptions } = await mailchannels.service.subscriptions()
+     * ```
+     */
+    subscriptions(): Promise<ServiceSubscriptionsResponse>;
+    /**
+     * Submit a false negative or false positive report.
+     * @param options - The report options
+     */
+    report(options: ServiceReportOptions): Promise<SuccessResponse>;
+}
+
+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 DomainsData {
+  /**
+   * The domain name.
+   */
+  domain: string;
+  /**
+   * The abuse policy settings for the domain. These settings determine how spam messages are handled.
+   */
+  settings?: Partial<{
+    /**
+     * The abuse policy.
+     */
+    abusePolicy: "block" | "flag" | "quarantine";
+    /**
+     * If `true`, this abuse policy overrides the recipient abuse policy.
+     */
+    abusePolicyOverride: boolean;
+    /**
+     * The spam header name to use if the abuse policy is set to `flag`.
+     */
+    spamHeaderName: string;
+    /**
+     * The spam header value to use if the abuse policy is set to `flag`.
+     */
+    spamHeaderValue: string;
+  }>;
+  /**
+   * A list of email addresses that are the domain admins for the domain.
+   */
+  admins?: string[] | null;
+  /**
+   * The locations of mail servers to which messages will be delivered after filtering.
+   */
+  downstreamAddresses?: {
+    /**
+     * The priority of the downstream address. Only addresses with the highest priority (the lowest numerical value) are selected.
+     */
+    priority: number;
+    /**
+     * Downstream addresses are selected in proportion to their weights. For example, if there are two downstream addresses, A with weight 40, and B with weight 10, then A is selected 80% of the time and B is selected 20% of the time.
+     */
+    weight: number;
+    /**
+     * TCP port on which the downstream mail server is listening.
+     */
+    port: number;
+    /**
+     * The canonical hostname of the host providing the service, ending in a dot.
+     */
+    target: string;
+  }[] | null;
+  /**
+   * A list of aliases for the domain. Mail is accepted for these domains and routed to the `downstreamAddresses` defined for the domain. Must be <= 255 characters
+   */
+  aliases?: string[] | null;
+  /**
+   * The subscription `handle` that identifies the subscription that this domain should be provisioned against. Subscription handles can be retrieved from the `subscriptions` service method.
+   */
+  subscriptionHandle: string;
+}
+
+interface DomainsProvisionOptions {
+  /**
+   * If present and set to true, the domain will be associated with the api-key that created it. This means that this api-key must be used for inbound-api actions involving this domain (for example adding safe/block list entries, etc).
+   */
+  associateKey?: boolean;
+  /**
+   * If present and set to true, the settings (domain settings, downstream addresses, aliases and admins) for the domain will be overwritten with the ones in the request if the domain already exists, unless a section is not included in the request or there is problem updating a setting in which case the previous settings are carried forward.
+   */
+  overwrite?: boolean;
+}
+
+type DomainsBulkProvisionOptions = DomainsProvisionOptions & Pick<DomainsData, "subscriptionHandle">;
+
+interface DomainsProvisionResponse {
+  data: DomainsData | null;
+  error: string | null;
+}
+
+interface DomainsBulkProvisionResponse {
+  /**
+   * If the request was processed successfully, this does not necessarily mean all the domains in the request were successfully provisioned.
+   */
+  results: {
+    /**
+     * Domains that were successfully provisioned or updated.
+     */
+    successes: {
+      domain: DomainsData;
+      code: number;
+      comment?: string;
+    }[];
+    /**
+     * Domains that were not successfully provisioned.
+     */
+    errors: {
+      domain: DomainsData;
+      code: number;
+      comment?: string;
+    }[];
+  } | null;
+  error: string | null;
+}
+
+interface DomainsListOptions {
+  /**
+   * A list of domains to fetch. If this parameter is present, only domains whose name matches an item in this list are returned.
+   */
+  domains?: string[];
+  /**
+   * The maximum number of domains included in the response. Possible values are 1 to 5000
+   * @default 10
+   */
+  limit?: number;
+  /**
+   * Offset into the list of domains to return.
+   * @default 0
+   */
+  offset?: number;
+}
+
+interface DomainsListResponse {
+  /**
+   * A list of domains
+   */
+  domains: DomainsData[];
+  /**
+   * The total number of domains that are accessible with the given API key that match the list of domains in the 'domains' parameter. If there is no 'domains' parameter, this field is the total number of domains that are accessible with with this API key. A domain is accessible with a given API key if it is associated with that API key, or if it is not associated with any API key.
+   */
+  total: number;
+  error: string | null;
+}
+
+interface DomainsCreateLoginLinkResponse {
+  /**
+   * If a user browses to this URL, they will be automatically logged in as a domain admin.
+   */
+  link: string | null;
+  error: string | null;
+}
+
+interface DomainsListDownstreamAddressesOptions {
+  /**
+   * The number of records to return.
+   * @default 10
+   */
+  limit?: number;
+  /**
+   * The offset into the records to return.
+   * @default 0
+   */
+  offset?: number;
+}
+
+interface DomainsDownstreamAddress {
+  /**
+   * TCP port on which the downstream mail server is listening.
+   */
+  port: number;
+  /**
+   * The priority of the downstream address. Only addresses with the highest priority (the lowest numerical value) are selected.
+   */
+  priority: number;
+  /**
+   * The canonical hostname of the host providing the service, ending in a dot.
+   */
+  target: string;
+  /**
+   * Downstream addresses are selected in proportion to their weights. For example, if there are two downstream addresses, A with weight 40, and B with weight 10, then A is selected 80% of the time and B is selected 20% of the time.
+   */
+  weight: number;
+}
+
+interface DomainsListDownstreamAddressesResponse {
+  records: DomainsDownstreamAddress[];
+  error: string | null;
+}
+
+declare class Domains {
+    protected mailchannels: MailChannelsClient;
+    constructor(mailchannels: MailChannelsClient);
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    provision(options: DomainsProvisionOptions & DomainsData): Promise<DomainsProvisionResponse>;
+    /**
+     * 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'
+     *   }
+     * ])
+     * ```
+     */
+    bulkProvision(options: DomainsBulkProvisionOptions, domains: Omit<DomainsData, "subscriptionHandle">[]): Promise<DomainsBulkProvisionResponse>;
+    /**
+     * 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()
+     * ```
+     */
+    list(options?: DomainsListOptions): Promise<DomainsListResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    delete(domain: string): Promise<SuccessResponse>;
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    addListEntry(domain: string, options: ListEntryOptions): Promise<ListEntryResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    listEntries(domain: string, listName: ListNames): Promise<ListEntriesResponse>;
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    deleteListEntry(domain: string, options: ListEntryOptions): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    createLoginLink(domain: string): Promise<DomainsCreateLoginLinkResponse>;
+    /**
+     * 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
+     *   }
+     * ])
+     * ```
+     */
+    setDownstreamAddress(domain: string, records?: DomainsDownstreamAddress[]): Promise<SuccessResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    listDownstreamAddresses(domain: string, options?: DomainsListDownstreamAddressesOptions): Promise<DomainsListDownstreamAddressesResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    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 Users {
+    protected mailchannels: MailChannelsClient;
+    constructor(mailchannels: MailChannelsClient);
+    /**
+     * 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
+     * })
+     * ```
+     */
+    create(email: string, options?: UsersCreateOptions): Promise<UsersCreateResponse>;
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    addListEntry(email: string, options: ListEntryOptions): Promise<ListEntryResponse>;
+    /**
+     * 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')
+     * ```
+     */
+    listEntries(email: string, listName: ListNames): Promise<ListEntriesResponse>;
+    /**
+     * 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'
+     * })
+     * ```
+     */
+    deleteListEntry(email: string, options: ListEntryOptions): Promise<SuccessResponse>;
+}
+
+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>;
+}
+
+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 };