zapsmtp 0.1.0.beta3

data/lib/zapsmtp/generated/resources.rb

@@ -0,0 +1,2818 @@
+# frozen_string_literal: true
+
+# Generated by sdks/codegen. Do not edit: run node sdks/codegen/generate.mjs.
+
+module ZapSMTP
+  # The API's resources, one class per path of zap.<resource>.
+  module Resources
+    # zap.emails.receiving.attachments
+    class EmailsReceivingAttachments
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List attachments.
+      #
+      # List a received email's attachments with signed download links. Requires a full-access key. Each
+      # download_url works for one hour without an API key. Files are always served as downloads; HTML, SVG,
+      # XML and JavaScript are served as binary so they can never run in a browser.
+      #
+      # @param id [String] Received email id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :limit 1-100; when omitted or out of range all attachments are returned.
+      # @option params [String] :after Attachment id; returns attachments after it (ignored if unknown).
+      # @option params [String] :before Attachment id; returns attachments before it (used only when after is
+      #   absent).
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Attachment>]
+      def list(id, params = {}, request_options: {}, **kwargs)
+        @client.request_page(
+          method: :get,
+          path: "/emails/receiving/#{Util.seg("id", id)}/attachments",
+          query: Util.params(params, kwargs),
+          model: Models::Attachment,
+          paging: :after,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve an attachment.
+      #
+      # Retrieve one attachment's metadata and signed download link. Requires a full-access key.
+      #
+      # @param id [String] Received email id
+      # @param aid [String] Attachment id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Attachment]
+      def get(id, aid, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/emails/receiving/#{Util.seg("id", id)}/attachments/#{Util.seg("aid", aid)}",
+          model: Models::Attachment,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.emails.receiving
+    class EmailsReceiving
+      # @return [EmailsReceivingAttachments]
+      attr_reader :attachments
+
+      # @api private
+      def initialize(client)
+        @client = client
+        @attachments = EmailsReceivingAttachments.new(client)
+      end
+
+      # List received emails.
+      #
+      # List received (inbound) emails, newest first. Requires a full-access key. action is default, webhook,
+      # store, reject or spam_reject. in_reply_to_email_id appears only when the message replies to an email
+      # you sent through ZapSMTP.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :limit 1-100; out-of-range falls back to 20. Default: 20.
+      # @option params [String] :before Cursor: an email id or RFC 3339 time; returns messages received before
+      #   it. An email id gives an exact page boundary. Limits: 422 invalid_parameter "before must be an email
+      #   id or RFC 3339 time"
+      # @option params [String] :after Email id or RFC 3339 time. Limits: 422 invalid_parameter "after must be
+      #   an email id or RFC 3339 time"
+      # @option params [String] :q Case-insensitive substring of sender, recipient or subject, or an exact id.
+      # @option params [String] :status One of: received, rejected.
+      # @option params [String] :domain Inbound domain name (exact).
+      # @option params [String] :thread_id Only emails of this conversation (see GET /threads/{id}).
+      # @option params [String] :automated false: only emails a person wrote; true: only automated ones; or
+      #   one type: bounce, out_of_office, auto_reply, auto_generated, bulk. Limits: 422 invalid_parameter for
+      #   other values.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::ReceivedEmail>]
+      def list(params = {}, request_options: {}, **kwargs)
+        @client.request_page(
+          method: :get,
+          path: "/emails/receiving",
+          query: Util.params(params, kwargs),
+          model: Models::ReceivedEmail,
+          paging: :before,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a received email.
+      #
+      # Retrieve a received email with bodies, headers, authentication results and download links. Requires a
+      # full-access key. automated is null for mail a person wrote, else {type, reason}: bounce (delivery
+      # status notification), out_of_office, auto_reply, auto_generated (notifications, null sender) or bulk
+      # (mailing lists). Detected from Auto-Submitted, X-Autoreply, Precedence, List-Id, multipart/report and
+      # well-known subjects; reason names the evidence. tls: the TLS version the sending server used (e.g.
+      # TLSv1_3); empty when the message was not encrypted.
+      #
+      # @param id [String] Received email id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :html_format cid: return html as received (cid: references to inline parts).
+      #   Any other value: inline images are embedded as data: URIs (html_format in the response reports what
+      #   was returned). One of: data_uri, cid. Default: data_uri.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::ReceivedEmail]
+      def get(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :get,
+          path: "/emails/receiving/#{Util.seg("id", id)}",
+          query: Util.params(params, kwargs),
+          model: Models::ReceivedEmail,
+          request_options: request_options
+        )
+      end
+
+      # Delete a received email.
+      #
+      # Permanently erase a received email's content and metadata (GDPR erasure). Requires a full-access live
+      # key; test keys get 403 test_key_restricted. Idempotent: deleting an id that does not exist (but is a
+      # valid UUID) still returns 200 deleted:true.
+      #
+      # @param id [String] Received email id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Deleted]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/emails/receiving/#{Util.seg("id", id)}",
+          model: Models::Deleted,
+          request_options: request_options
+        )
+      end
+
+      # Redeliver to webhooks.
+      #
+      # Re-send the email.received webhook for a stored message. Requires a full-access live key; test keys
+      # get 403 test_key_restricted. The event is re-queued asynchronously (hence 202).
+      #
+      # @param id [String] Received email id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::ReceivedEmailAction]
+      def redeliver(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/emails/receiving/#{Util.seg("id", id)}/redeliver",
+          model: Models::ReceivedEmailAction,
+          request_options: request_options
+        )
+      end
+
+      # Report spam / not spam.
+      #
+      # Report a received email as spam or not spam: your account's spam filter learns from it. Requires a
+      # full-access live key; test keys get 403 test_key_restricted. Each account has its own statistics: your
+      # reports never change another account's filter. The filter starts scoring once it has learned 20 emails
+      # of each kind. Reporting the same email twice is harmless. learned is false when the email has too few
+      # words to learn from.
+      #
+      # @param id [String] Received email id.
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Boolean] :spam true: mail like this is spam; false: it is wanted. Limits: missing →
+      #   422 missing_required_field Required.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::ReceivedEmailAction]
+      def report_spam(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/emails/receiving/#{Util.seg("id", id)}/spam",
+          body: Util.params(params, kwargs),
+          model: Models::ReceivedEmailAction,
+          request_options: request_options
+        )
+      end
+
+      # Reply to a received email.
+      #
+      # Reply to a received email: recipients, subject, sender and threading headers default to the email's,
+      # so the answer lands in the sender's conversation. Requires a full-access key. Live keys: the From
+      # domain must be verified for sending. Our Message-ID of the reply names its thread, so the customer's
+      # answer joins the conversation even from a mail client that keeps only In-Reply-To. Every other rule of
+      # POST /emails applies: suppressions, quotas, tracking, test keys. Loop protection: replies to automated
+      # email need allow_automated, and one conversation takes at most 20 replies an hour.
+      #
+      # @param id [String] Received email id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :text Plain-text body. Either text or html (or a template) is required.
+      # @option params [String] :html HTML body.
+      # @option params [String] :from Default: the address that received the email (e.g. support@acme.com),
+      #   which must be on a verified sending domain. Required when the email came to a managed *.in.zapsmtp.com
+      #   address (those only receive): 422 missing_required_field.
+      # @option params [String, Array<String>] :to Default: the email's Reply-To, else its From. Limits: 422
+      #   missing_required_field when the email has neither.
+      # @option params [Boolean] :reply_all Also copy everyone on the email's To and Cc, except the receiving
+      #   address, the sender you reply from and anyone already addressed. Default: false.
+      # @option params [Boolean] :allow_automated Answer an automated email anyway (see automated on the
+      #   received email). Without it a reply to a bounce, out-of-office, auto-reply or notification is refused
+      #   with 422 automated_message: two auto-responders answering each other is a mail loop. Bulk mail can be
+      #   answered without it. Default: false.
+      # @option params [Boolean] :auto_reply This answer is itself automatic (an acknowledgement, a ticket
+      #   receipt): adds Auto-Submitted: auto-replied and X-Auto-Response-Suppress: All (RFC 3834), so other
+      #   auto-responders do not answer it. Default: false.
+      # @option params [String, Array<String>] :cc Added to the Cc (reply_all adds the email's recipients
+      #   after these).
+      # @option params [String, Array<String>] :bcc Bcc recipients.
+      # @option params [String, Array<String>] :reply_to Default: the receiving address when you reply from
+      #   another one, so the customer's answer comes back to the same inbox.
+      # @option params [String] :subject Default: Re: + the email's subject (kept as is when it already starts
+      #   with Re:).
+      # @option params [Hash{String => String}] :headers Custom headers. In-Reply-To and References are set
+      #   for you (RFC 5322 threading); a value you give wins.
+      # @option params [Array<Hash>] :attachments Attachments; 40 MB total. Limits: 422 invalid_attachment
+      #   with message attachments[i]: set either content or path, not both | content must be base64 | content
+      #   or path is required | filename is required | path must be an http(s) URL | fetching path returned HTTP
+      #   <n> | attachments exceed 40MB in total
+      # @option params [Array<Hash>] :tags Returned in webhooks as data.tags. Limits: at most 20 tags per
+      #   email; name and value must match ^[A-Za-z0-9_-]{1,256}$ (422 invalid_parameter)
+      # @option params [Hash{String => String}] :metadata Returned in webhooks and GET /emails; filter with
+      #   GET /emails?metadata[key]=value. Limits: max 10 keys; keys ^[A-Za-z0-9_-]{1,40}$; values max 500 bytes
+      #   (UTF-8) (422 invalid_parameter)
+      # @option params [String] :stream Limits: other values → 422 invalid_parameter; conflicting with the
+      #   key's stream → 403 restricted_api_key One of: transactional, broadcast. Default: transactional (or the
+      #   key's stream).
+      # @option params [Hash] :tracking Overrides the From domain's open, click and reply tracking defaults
+      #   for this email.
+      # @option params [Hash] :template Render a stored, published template: id = template id or alias.
+      #   Request subject/from override the template's. Cannot be combined with html/text. Limits: missing id →
+      #   422 missing_required_field "template.id is required"; unknown → 422 invalid_parameter "template <id>
+      #   not found"; never published → 422 invalid_parameter; variables.global → 422 invalid_parameter
+      #   (reserved); a value of the wrong type → 422 template_variables_invalid; a required variable without
+      #   value or default → 422 template_variables_missing; anything else the template uses still absent → 422
+      #   template_render_error "missing template variables: a, b"
+      # @option params [String] :scheduled_at RFC 3339 time (e.g. 2026-10-21T15:00:00Z) or relative "in <n>
+      #   <unit>" with unit min|mins|minute|minutes|h|hour|hours|d|day|days. Times in the past send immediately.
+      #   Limits: unparsable → 422 invalid_parameter; more than 7 days ahead → 422 invalid_parameter
+      #   "scheduled_at must be within 7 days"
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SendEmailResponse]
+      def reply(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/emails/receiving/#{Util.seg("id", id)}/reply",
+          body: Util.params(params, kwargs),
+          idempotent: true,
+          model: Models::SendEmailResponse,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.emails.attachments
+    class EmailsAttachments
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List attachments.
+      #
+      # Attachments of a sent email, each with a download link valid for one hour. Requires a full-access key.
+      # Emails sent without attachments return an empty list.
+      #
+      # @param id [String] Email id.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Attachment>]
+      def list(id, request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/emails/#{Util.seg("id", id)}/attachments",
+          model: Models::Attachment,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve an attachment.
+      #
+      # One attachment of a sent email with a fresh download link. Requires a full-access key.
+      #
+      # @param id [String] Email id.
+      # @param aid [String] Attachment id from the list.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Attachment]
+      def get(id, aid, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/emails/#{Util.seg("id", id)}/attachments/#{Util.seg("aid", aid)}",
+          model: Models::Attachment,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.emails
+    class Emails
+      # @return [EmailsReceiving]
+      attr_reader :receiving
+
+      # @return [EmailsAttachments]
+      attr_reader :attachments
+
+      # @api private
+      def initialize(client)
+        @client = client
+        @receiving = EmailsReceiving.new(client)
+        @attachments = EmailsAttachments.new(client)
+      end
+
+      # Send an email.
+      #
+      # Send an email (or schedule it with scheduled_at). Requires a full-access or sending-access key. Live
+      # keys: From domain must be verified by the account. Test keys: any From domain, nothing delivered,
+      # monthly quota not charged. Recipients are deduplicated and lowercased; max 50 across to+cc+bcc.
+      # Message-ID is <id>@<hostname>, or <id>.<thread_id>@<hostname> for a reply that continues a
+      # conversation. The response also carries thread_id: the conversation this email belongs to. An email
+      # with In-Reply-To / References headers (set them in headers) joins the thread of the message it
+      # answers; otherwise it starts a new one. failed_recipients: addresses the mail server refused while it
+      # took the others; they are not sent and not charged. unconfirmed: true: the mail server took the
+      # message but its answer was lost; it counts as sent and must not be retried (its events tell the
+      # outcome). Scheduled emails (scheduled_at): at most 10,000 (256 MB) may wait per account. At send time
+      # the account and the key are checked again: a suspended account or a revoked or expired key fails the
+      # email. With reply tracking on, the response carries reply_to: the tracked address the email carries in
+      # place of its own Reply-To. Human replies are forwarded to the domain’s reply_forward_to, else to the
+      # email’s first Reply-To, else to its From.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :from RFC 5322 address, e.g. "Acme <hello@acme.com>". Domain must be verified
+      #   (live keys). When only an address is given, the domain's from_name (brand settings) is used as display
+      #   name. May be omitted when template is used and the template defines from. Limits: missing → 422
+      #   missing_required_field; unparsable → 422 invalid_parameter "invalid from address"
+      # @option params [String, Array<String>] :to Recipient(s). Limits: at least one; each must parse as an
+      #   address (422 invalid_parameter "invalid to address ...") Required.
+      # @option params [String, Array<String>] :cc Cc recipients.
+      # @option params [String, Array<String>] :bcc Bcc recipients.
+      # @option params [String, Array<String>] :reply_to Reply-To address(es).
+      # @option params [String] :subject Subject line. May be omitted when template is used and the template
+      #   defines a subject. Limits: blank → 422 missing_required_field
+      # @option params [String] :html HTML body. At least one of html/text is required (unless template is
+      #   used). Limits: both empty → 422 missing_required_field "html or text is required"; cannot be combined
+      #   with template (422 invalid_parameter)
+      # @option params [String] :text Plain-text body. When only html is given, a plain-text part is generated
+      #   from it (readable text, links as text (url), hidden elements such as the preheader left out).
+      # @option params [Hash{String => String}] :headers Custom headers. Limits: Reserved headers are rejected
+      #   (422 invalid_parameter "header ... cannot be set"): From, To, Cc, Bcc, Reply-To, Subject, Date,
+      #   Message-Id, Mime-Version, Content-Type, Content-Transfer-Encoding, DKIM-Signature, Return-Path,
+      #   Received, any X-Zap-*, X-ZapRef. Names must be printable ASCII without spaces or ':'.
+      # @option params [Array<Hash>] :attachments Attachments; 40 MB total. Limits: 422 invalid_attachment
+      #   with message attachments[i]: set either content or path, not both | content must be base64 | content
+      #   or path is required | filename is required | path must be an http(s) URL | fetching path returned HTTP
+      #   <n> | attachments exceed 40MB in total
+      # @option params [Array<Hash>] :tags Returned in webhooks as data.tags. Limits: at most 20 tags per
+      #   email; name and value must match ^[A-Za-z0-9_-]{1,256}$ (422 invalid_parameter)
+      # @option params [String] :scheduled_at RFC 3339 time (e.g. 2026-10-21T15:00:00Z) or relative "in <n>
+      #   <unit>" with unit min|mins|minute|minutes|h|hour|hours|d|day|days. Times in the past send immediately.
+      #   Limits: unparsable → 422 invalid_parameter; more than 7 days ahead → 422 invalid_parameter
+      #   "scheduled_at must be within 7 days"
+      # @option params [Hash{String => String}] :metadata Returned in webhooks and GET /emails; filter with
+      #   GET /emails?metadata[key]=value. Limits: max 10 keys; keys ^[A-Za-z0-9_-]{1,40}$; values max 500 bytes
+      #   (UTF-8) (422 invalid_parameter)
+      # @option params [String] :stream Limits: other values → 422 invalid_parameter; conflicting with the
+      #   key's stream → 403 restricted_api_key One of: transactional, broadcast. Default: transactional (or the
+      #   key's stream).
+      # @option params [Hash] :tracking Overrides the From domain's open, click and reply tracking defaults
+      #   for this email.
+      # @option params [Hash] :template Render a stored, published template: id = template id or alias.
+      #   Request subject/from override the template's. Cannot be combined with html/text. Limits: missing id →
+      #   422 missing_required_field "template.id is required"; unknown → 422 invalid_parameter "template <id>
+      #   not found"; never published → 422 invalid_parameter; variables.global → 422 invalid_parameter
+      #   (reserved); a value of the wrong type → 422 template_variables_invalid; a required variable without
+      #   value or default → 422 template_variables_missing; anything else the template uses still absent → 422
+      #   template_render_error "missing template variables: a, b"
+      # @option params [String] :tls required or verified: deliver only over TLS (verified: with a valid
+      #   certificate for the receiving server). Raises the domain's policy, never lowers it.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SendEmailResponse]
+      def send(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/emails",
+          body: Util.params(params, kwargs),
+          idempotent: true,
+          model: Models::SendEmailResponse,
+          request_options: request_options
+        )
+      end
+
+      # Send a batch.
+      #
+      # Send 1-100 emails in one request. Requires a full-access or sending-access key. Test keys follow the
+      # same rules as for sending. Per-email error codes use the same classification as POST /emails
+      # (domain_not_verified, restricted_api_key, rate_limit_exceeded, monthly_quota_exceeded, etc. appear
+      # inside errors[] rather than as the HTTP status). Emails are sent concurrently (up to 16 at a time);
+      # each email may have its own scheduled_at. Body: length 1-100 else 422 invalid_parameter "batch must
+      # contain 1 to 100 emails" An item of data carries reply_to when reply tracking is on for that email.
+      #
+      # @param emails [Array<Hash>] the emails, each with the parameters of emails.send
+      # @param validation [String, nil] strict (default) | permissive (case-insensitive). strict: if any email
+      #   fails validation nothing is sent and 422 is returned. permissive: valid emails are sent; invalid ones
+      #   are reported in errors.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SendBatchResponse]
+      def send_batch(emails, validation: nil, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/emails/batch",
+          body: emails,
+          headers: { "x-batch-validation" => validation },
+          idempotent: true,
+          model: Models::SendBatchResponse,
+          request_options: request_options
+        )
+      end
+
+      # List emails.
+      #
+      # List sent emails, newest first. Requires a full-access key. Use the last item's id as before= for the
+      # next page. metadata may be null when the email has none. last_status and last_event carry the same
+      # value.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :limit 1-100; out-of-range values fall back to 20. Default: 20.
+      # @option params [String] :before Cursor: an email id (UUIDv7) or RFC 3339 time; returns emails accepted
+      #   before it. An email id gives an exact page boundary. Limits: 422 invalid_parameter "before must be an
+      #   email id or RFC 3339 time"
+      # @option params [String] :after Email id or RFC 3339 time; only emails created after it (still newest
+      #   first). Limits: 422 invalid_parameter "after must be an email id or RFC 3339 time"
+      # @option params [String] :status Filter by latest status. status=scheduled lists pending scheduled
+      #   sends instead (different item shape, ordered by scheduled time ascending, has_more always false, other
+      #   filters/cursors ignored). One of: queued, delivered, delivery_delayed, bounced, complained, failed,
+      #   opened, clicked, replied, suppressed, scheduled.
+      # @option params [String] :q Case-insensitive substring of a recipient or subject, or an exact email id.
+      # @option params [Integer] :days Look-back window in days, 1-90 (other values ignored). Always capped by
+      #   the plan's log retention. Default: 30.
+      # @option params [String] :stream One of: transactional, broadcast.
+      # @option params [String] :mode Filter live or test-mode (sandbox) traffic; other values ignored. One
+      #   of: live, test.
+      # @option params [Hash{String => String}] :metadata Exact match on a metadata value, e.g.
+      #   metadata[order_id]=A-1042. Repeatable for several keys.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Email>]
+      def list(params = {}, request_options: {}, **kwargs)
+        @client.request_page(
+          method: :get,
+          path: "/emails",
+          query: Util.params(params, kwargs),
+          model: Models::Email,
+          paging: :before,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve an email.
+      #
+      # Retrieve one email with per-recipient status and its event timeline. Requires a full-access key. Only
+      # data inside the plan's log retention is visible. metadata may be null.
+      #
+      # @param id [String] Email id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Email]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/emails/#{Util.seg("id", id)}",
+          model: Models::Email,
+          request_options: request_options
+        )
+      end
+
+      # Reschedule an email.
+      #
+      # Reschedule a scheduled email. Requires a full-access or sending-access key. Unknown ids return 409
+      # not_cancellable, not 404.
+      #
+      # @param id [String] Scheduled email id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :scheduled_at RFC 3339 or "in <n> <unit>" (see POST /emails). A time in the
+      #   past dispatches as soon as possible. Limits: missing → 422 missing_required_field; unparsable or > 7
+      #   days ahead → 422 invalid_parameter Required.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Email]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/emails/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::Email,
+          request_options: request_options
+        )
+      end
+
+      # Cancel a scheduled email.
+      #
+      # Cancel a scheduled email before it is dispatched. Requires a full-access or sending-access key.
+      #
+      # @param id [String] Scheduled email id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Email]
+      def cancel(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/emails/#{Util.seg("id", id)}/cancel",
+          model: Models::Email,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve email content.
+      #
+      # Retrieve the archived content of a sent email. Requires a full-access key. source is api or smtp; tags
+      # is the URL-encoded tag string. Content is kept for your plan’s log retention.
+      #
+      # @param id [String] Email id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::EmailContent]
+      def get_content(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/emails/#{Util.seg("id", id)}/content",
+          model: Models::EmailContent,
+          request_options: request_options
+        )
+      end
+
+      # Spam-check a draft.
+      #
+      # Score a draft for spam before sending (nothing is sent or stored). Requires a full-access or
+      # sending-access key. Body: from missing or both html and text empty → 422 missing_required_field "from
+      # and html or text are required". Only these six fields are accepted (others → 400).
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :from From address; when its domain is verified by the account the draft is
+      #   DKIM-signed with the real key. Required.
+      # @option params [String, Array<String>] :to Recipient(s); the first is used as envelope recipient.
+      #   Limits: 422 invalid_parameter "to must be a string or an array of strings" Default:
+      #   recipient@example.com.
+      # @option params [String] :subject
+      # @option params [String] :html At least one of html and text is required.
+      # @option params [String] :text
+      # @option params [String] :stream Selects the shared pool used to pick the egress IP when the account
+      #   has no dedicated IP. Default: transactional.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SpamCheck]
+      def spam_check(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/emails/spam-check",
+          body: Util.params(params, kwargs),
+          model: Models::SpamCheck,
+          request_options: request_options
+        )
+      end
+
+      # Spam-check a sent email.
+      #
+      # Score an already sent email (live or test) from the content archive. Requires a full-access key.
+      # Always scored with the transactional pool's IP when the account has no dedicated IP. Availability
+      # follows GET /emails/{id}/content (plan log retention), although the 404 message says 7 days.
+      #
+      # @param id [String] Email id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SpamCheck]
+      def spam_check_sent(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/emails/#{Util.seg("id", id)}/spam-check",
+          model: Models::SpamCheck,
+          request_options: request_options
+        )
+      end
+
+      # Share an email.
+      #
+      # Create a link anyone can open to view a sent email — for a colleague or support. It shows the subject,
+      # sender, recipients and body; never attachments or headers. Requires a full-access live key; test keys
+      # get 403 test_key_restricted. The page renders the body in a sandbox: scripts, forms and external
+      # requests other than images are blocked.
+      #
+      # @param id [String] Email id.
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :expires_in_hours 1–720. Default: 72.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::EmailShare]
+      def share(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/emails/#{Util.seg("id", id)}/share",
+          body: Util.params(params, kwargs),
+          model: Models::EmailShare,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.threads
+    class Threads
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List conversations.
+      #
+      # List conversations (threads with at least one received email), the most recently active first: a
+      # helpdesk inbox. Requires a full-access key. Served from a per-conversation summary kept up to date as
+      # emails arrive: a page costs the same however much email you have. A conversation you started (your
+      # first email) is counted once the customer answers it.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :limit 1-100; out-of-range falls back to 20. Default: 20.
+      # @option params [String] :before Cursor: the last_message_at of the last conversation you have (RFC
+      #   3339). Limits: 422 invalid_parameter otherwise.
+      # @option params [String] :before_id With before: the id of the last conversation you have, so
+      #   conversations active at the same instant are neither skipped nor repeated.
+      # @option params [Boolean] :awaiting_reply true: only conversations whose last human email came in.
+      # @option params [Boolean] :unread true: only conversations with an email received after their read
+      #   mark.
+      # @option params [String] :participant Only conversations this address took part in (case-insensitive).
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Thread>]
+      def list(params = {}, request_options: {}, **kwargs)
+        @client.request_page(
+          method: :get,
+          path: "/threads",
+          query: Util.params(params, kwargs),
+          model: Models::Thread,
+          paging: :thread,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a conversation.
+      #
+      # A conversation: its state (participants, counts, last message, awaiting_reply, unread, metadata) and
+      # its received and sent emails, oldest first. Requires a full-access key. awaiting_reply: the last email
+      # a person wrote came in (automated mail does not count). unread: something was received after read_at
+      # (set with PATCH /threads/{id}). Threads are derived from the standard In-Reply-To / References
+      # headers: no setup. Every received email, webhook email.received and send response carries its
+      # thread_id. Refused messages are not part of a thread. At most 500 emails are listed (has_more); fetch
+      # bodies with GET /emails/receiving/{id} and GET /emails/{id}/content. Emails received before 2026-10-23
+      # have a thread id but are not listed here.
+      #
+      # @param id [String] Thread id (thread_id of any email in it)
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Thread]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/threads/#{Util.seg("id", id)}",
+          model: Models::Thread,
+          request_options: request_options
+        )
+      end
+
+      # Mark read, set metadata.
+      #
+      # Mark a conversation read or unread and set its metadata. Requires a full-access live key; test keys
+      # get 403 test_key_restricted. Omitted fields are kept.
+      #
+      # @param id [String] Thread id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Boolean] :read true sets read_at to now (unread again once a new email arrives); false
+      #   clears it.
+      # @option params [Hash{String => String}] :metadata Your own key-value pairs (a ticket id, a CRM deal),
+      #   replacing the previous ones. Limits: at most 20 keys matching [A-Za-z0-9_-]{1,40}, values up to 500
+      #   bytes (UTF-8) (422 invalid_parameter).
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Thread]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/threads/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::Thread,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.inbound.domains
+    class InboundDomains
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List inbound domains.
+      #
+      # List inbound domains (oldest first). Requires a full-access key. MX target host comes from config
+      # (ZAP_INBOUND_HOST, defaults to the API hostname); managed zone from ZAP_INBOUND_ZONE.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::InboundDomain>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/inbound/domains",
+          model: Models::InboundDomain,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Add an inbound domain.
+      #
+      # Create an inbound domain: a managed address (<slug>.<inbound zone>) or your own domain. Requires a
+      # full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Boolean] :managed true: create an instant managed domain <10 random lowercase
+      #   chars>.<inbound zone>; no DNS needed; name is ignored. Default: False.
+      # @option params [String] :name Required unless managed is true. Your own domain. It (or a parent) must
+      #   be verified for sending by the account. Then publish MX 10 <inbound host> and call verify. Limits:
+      #   invalid → 422 invalid_parameter "invalid domain name"; ZapSMTP-owned names → 422 reserved_domain; not
+      #   verified for sending → 403 domain_not_verified
+      # @option params [Boolean] :reject_spam Refuse messages flagged as spam at SMTP time instead of
+      #   delivering them with is_spam: true. Default: False.
+      # @option params [Boolean] :require_tls Accept encrypted mail only: senders without STARTTLS are refused
+      #   with 530 5.7.0.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::InboundDomain]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/inbound/domains",
+          body: Util.params(params, kwargs),
+          model: Models::InboundDomain,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve an inbound domain.
+      #
+      # Retrieve an inbound domain. Requires a full-access key.
+      #
+      # @param id [String] Inbound domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::InboundDomain]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/inbound/domains/#{Util.seg("id", id)}",
+          model: Models::InboundDomain,
+          request_options: request_options
+        )
+      end
+
+      # Update an inbound domain.
+      #
+      # Update an inbound domain's spam policy. Requires a full-access live key; test keys get 403
+      # test_key_restricted.
+      #
+      # @param id [String] Inbound domain id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Boolean] :reject_spam Refuse flagged spam (550) instead of delivering it with is_spam:
+      #   true.
+      # @option params [Boolean] :require_tls Accept encrypted mail only: senders without STARTTLS are refused
+      #   with 530 5.7.0.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::InboundDomain]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/inbound/domains/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::InboundDomain,
+          request_options: request_options
+        )
+      end
+
+      # Verify MX records.
+      #
+      # Check the domain's MX record now. Requires a full-access live key; test keys get 403
+      # test_key_restricted. mx_verified becomes true as soon as any MX record of the domain points to our
+      # inbound host.
+      #
+      # @param id [String] Inbound domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::InboundDomainCheck]
+      def verify(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/inbound/domains/#{Util.seg("id", id)}/verify",
+          model: Models::InboundDomainCheck,
+          request_options: request_options
+        )
+      end
+
+      # Delete an inbound domain.
+      #
+      # Delete an inbound domain. Requires a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Inbound domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [nil]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/inbound/domains/#{Util.seg("id", id)}",
+          model: nil,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.inbound.routes
+    class InboundRoutes
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List routes.
+      #
+      # List inbound routes in evaluation order (priority ascending, then created_at). Requires a full-access
+      # key.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::InboundRoute>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/inbound/routes",
+          model: Models::InboundRoute,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Create a route.
+      #
+      # Create an inbound route (max 100 per account). Requires a full-access live key; test keys get 403
+      # test_key_restricted.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Label (trimmed).
+      # @option params [Integer] :priority Lower runs first; first match wins. Default: 100.
+      # @option params [String] :match_recipient Glob (case-insensitive, * and ?) e.g. support+*@acme.com, or
+      #   /regex/ (RE2, case-insensitive). Empty matches all. Limits: max 512 chars; must compile (422
+      #   invalid_parameter)
+      # @option params [String] :match_sender Same syntax, matched against the envelope sender. Limits: max
+      #   512 chars; must compile
+      # @option params [String] :match_header Header name to test.
+      # @option params [String] :match_header_value Glob or /regex/ for that header's value. Limits: max 512
+      #   chars; must compile
+      # @option params [String] :action webhook: deliver email.received only to webhook_id; store: keep
+      #   without webhook; forward: keep and forward to forward_id (a confirmed forward destination); reject:
+      #   refuse with 550 at SMTP time. Limits: 422 invalid_parameter "action must be webhook, store, reject or
+      #   forward" Required. One of: webhook, store, forward, reject.
+      # @option params [String, nil] :webhook_id Required when action is webhook. A webhook of this account.
+      #   Cleared for store/reject. Limits: 422 "webhook_id is required for action webhook" / "webhook_id does
+      #   not belong to this account"
+      # @option params [String, nil] :forward_id A confirmed forward destination of this account (action
+      #   forward). Cleared for other actions. Limits: 422 "forward_id is required for action forward" /
+      #   "forward_id does not belong to this account" / "... is not confirmed yet"
+      # @option params [Boolean] :enabled Default: True.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::InboundRoute]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/inbound/routes",
+          body: Util.params(params, kwargs),
+          model: Models::InboundRoute,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a route.
+      #
+      # Retrieve an inbound route. Requires a full-access key.
+      #
+      # @param id [String] Route id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::InboundRoute]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/inbound/routes/#{Util.seg("id", id)}",
+          model: Models::InboundRoute,
+          request_options: request_options
+        )
+      end
+
+      # Update a route.
+      #
+      # Update an inbound route (partial; same fields and validation as create). Requires a full-access live
+      # key; test keys get 403 test_key_restricted. Any subset of the POST /inbound/routes fields. Omitted
+      # fields keep their value; webhook_id: "" clears it. The resulting route must still be valid (e.g.
+      # action webhook needs webhook_id).
+      #
+      # @param id [String] Route id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Label (trimmed).
+      # @option params [Integer] :priority Lower runs first; first match wins.
+      # @option params [String] :match_recipient Glob (case-insensitive, * and ?) e.g. support+*@acme.com, or
+      #   /regex/ (RE2, case-insensitive). Empty matches all. Limits: max 512 chars; must compile (422
+      #   invalid_parameter)
+      # @option params [String] :match_sender Same syntax, matched against the envelope sender. Limits: max
+      #   512 chars; must compile
+      # @option params [String] :match_header Header name to test.
+      # @option params [String] :match_header_value Glob or /regex/ for that header's value. Limits: max 512
+      #   chars; must compile
+      # @option params [String] :action webhook: deliver email.received only to webhook_id; store: keep
+      #   without webhook; forward: keep and forward to forward_id (a confirmed forward destination); reject:
+      #   refuse with 550 at SMTP time. Limits: 422 invalid_parameter "action must be webhook, store, reject or
+      #   forward" One of: webhook, store, forward, reject.
+      # @option params [String, nil] :webhook_id A webhook of this account. Cleared for store/reject. Limits:
+      #   422 "webhook_id is required for action webhook" / "webhook_id does not belong to this account"
+      # @option params [String, nil] :forward_id A confirmed forward destination of this account (action
+      #   forward). Cleared for other actions. Limits: 422 "forward_id is required for action forward" /
+      #   "forward_id does not belong to this account" / "... is not confirmed yet"
+      # @option params [Boolean] :enabled
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::InboundRoute]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/inbound/routes/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::InboundRoute,
+          request_options: request_options
+        )
+      end
+
+      # Delete a route.
+      #
+      # Delete an inbound route. Requires a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Route id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [nil]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/inbound/routes/#{Util.seg("id", id)}",
+          model: nil,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.inbound.forward_destinations
+    class InboundForwardDestinations
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List forward destinations.
+      #
+      # List the addresses received mail can be forwarded to. Requires a full-access key.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::ForwardDestination>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/inbound/forward-destinations",
+          model: Models::ForwardDestination,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Add a forward destination.
+      #
+      # Add a forward destination: we email it a confirmation link; routes can forward there once its owner
+      # confirms. Requires a full-access live key; test keys get 403 test_key_restricted. The confirmation
+      # page asks for a click, so mail scanners that follow links cannot confirm. Forwarded mail keeps its
+      # original From and DKIM, is ARC-signed by us, counts as one sent email and appears in the email log;
+      # spam is never forwarded.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :email A plain address. Not a ZapSMTP receiving address (it would loop).
+      #   Required.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::ForwardDestination]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/inbound/forward-destinations",
+          body: Util.params(params, kwargs),
+          model: Models::ForwardDestination,
+          request_options: request_options
+        )
+      end
+
+      # Resend the confirmation.
+      #
+      # Email a new confirmation link (the previous one stops working). Requires a full-access live key; test
+      # keys get 403 test_key_restricted.
+      #
+      # @param id [String] Forward destination id.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::ForwardDestination]
+      def resend_confirmation(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/inbound/forward-destinations/#{Util.seg("id", id)}/resend",
+          model: Models::ForwardDestination,
+          request_options: request_options
+        )
+      end
+
+      # Remove a forward destination.
+      #
+      # Remove a forward destination; routes forwarding there only store from then on. Requires a full-access
+      # live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Forward destination id.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Deleted]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/inbound/forward-destinations/#{Util.seg("id", id)}",
+          model: Models::Deleted,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.inbound
+    class Inbound
+      # @return [InboundDomains]
+      attr_reader :domains
+
+      # @return [InboundRoutes]
+      attr_reader :routes
+
+      # @return [InboundForwardDestinations]
+      attr_reader :forward_destinations
+
+      # @api private
+      def initialize(client)
+        @client = client
+        @domains = InboundDomains.new(client)
+        @routes = InboundRoutes.new(client)
+        @forward_destinations = InboundForwardDestinations.new(client)
+      end
+
+      # Inbound stats.
+      #
+      # Inbound counters for the last 24 hours. Requires a full-access key.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::InboundStats]
+      def get_stats(request_options: {})
+        @client.request(
+          method: :get,
+          path: "/inbound/stats",
+          model: Models::InboundStats,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.simulator
+    class Simulator
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List simulator addresses.
+      #
+      # List the simulator addresses and the events each produces. Requires a full-access key.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Simulator]
+      def get(request_options: {})
+        @client.request(
+          method: :get,
+          path: "/simulator",
+          model: Models::Simulator,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.stats
+    class Stats
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # Totals.
+      #
+      # Event counts by status over the last N hours (live traffic only). Requires a full-access key. Counts
+      # events (not unique emails), ordered by status name; test-mode traffic excluded.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :hours 1-720; out-of-range falls back to 24. Default: 24.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Stats]
+      def get(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :get,
+          path: "/stats",
+          query: Util.params(params, kwargs),
+          model: Models::Stats,
+          request_options: request_options
+        )
+      end
+
+      # Time series.
+      #
+      # Event counts by status in time buckets. Requires a full-access key. One point per (bucket, status);
+      # empty buckets are not emitted. Test-mode traffic excluded.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :hours 1-720; out-of-range falls back to 24. Bucket size: <=1h → 60 s, <=6h →
+      #   300 s, <=24h → 1800 s, <=168h → 10800 s, otherwise 43200 s. Default: 24.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::StatsTimeseries]
+      def timeseries(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :get,
+          path: "/stats/timeseries",
+          query: Util.params(params, kwargs),
+          model: Models::StatsTimeseries,
+          request_options: request_options
+        )
+      end
+
+      # Breakdown.
+      #
+      # Per-provider delivery, bounce classes, engagement and top clicked links. Requires a full-access key.
+      # Providers are Gmail, Microsoft, Yahoo, Apple and Other. delayed counts emails that were delayed at
+      # least once.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :hours 1-720; out-of-range falls back to 24. Default: 24.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::StatsBreakdown]
+      def breakdown(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :get,
+          path: "/stats/breakdown",
+          query: Util.params(params, kwargs),
+          model: Models::StatsBreakdown,
+          request_options: request_options
+        )
+      end
+
+      # Metrics by domain, stream, tag or provider.
+      #
+      # Delivery and engagement of live mail by sending domain, stream, tag or mailbox provider, with rates
+      # and a time series. Requires a full-access key. Counts are recipients, except delayed, opened and
+      # clicked: unique emails. Delivery and bounce rates are of sent; complaint, open and click rates of
+      # delivered. Test-mode mail is excluded. Kept for 400 days. An out-of-band bounce (a later bounce email
+      # from the remote server) has no sending domain: it is grouped under an empty value. Totals and the
+      # series count each email once whatever the dimension; with dimension=tag an email with several tags
+      # appears in each of its tags' groups.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :from RFC 3339 start. At most 400 days before to. Default: 7 days ago.
+      # @option params [String] :to RFC 3339 end (exclusive). Default: now.
+      # @option params [String] :granularity hour (ranges up to 31 days) or day for series. Default: hour up
+      #   to 48 hours, else day.
+      # @option params [String] :dimension domain, stream, tag or provider: adds groups, one row per value,
+      #   busiest first.
+      # @option params [String] :domain Only this sending (From) domain.
+      # @option params [String] :stream transactional or broadcast.
+      # @option params [String] :provider Gmail, Microsoft, Yahoo, Apple or Other.
+      # @option params [String] :tag Only emails with this tag, as name=value. Cannot be combined with domain,
+      #   stream or provider, and groups only by tag.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Metrics]
+      def metrics(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :get,
+          path: "/metrics",
+          query: Util.params(params, kwargs),
+          model: Models::Metrics,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.domains
+    class Domains
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List domains.
+      #
+      # List sending domains (newest first) with their DNS records. Requires a full-access key. status is
+      # pending or verified. Only DKIM is required to verify a domain; SPF and DMARC are recommended and
+      # reported separately.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Domain>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/domains",
+          model: Models::Domain,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Add a domain.
+      #
+      # Add a sending domain; returns the DNS records to publish. Requires a full-access live key; test keys
+      # get 403 test_key_restricted.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Domain name (lowercased, trailing dot removed). Limits: valid hostname
+      #   <=253 chars, else 422 invalid_parameter "invalid domain name" Required.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Domain]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/domains",
+          body: Util.params(params, kwargs),
+          model: Models::Domain,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a domain.
+      #
+      # Retrieve a sending domain. Requires a full-access key.
+      #
+      # @param id [String] Domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Domain]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/domains/#{Util.seg("id", id)}",
+          model: Models::Domain,
+          request_options: request_options
+        )
+      end
+
+      # Update a domain.
+      #
+      # Set the domain's tracking defaults (opens, clicks, replies) and its outbound TLS policy. Requires a
+      # full-access live key; test keys get 403 test_key_restricted. Fields left out keep their value. The
+      # response is the domain, as in GET /domains/{id}. Reply tracking: each tracked email gets its own
+      # signed Reply-To, e.g. r1-<email id>.<signature>@reply.acme.com, so replies come back tied to the exact
+      # email. Each reply fires email.replied (classified as a person, out-of-office, unsubscribe request,
+      # bounce…) and arrives as a received email; only replies a person wrote are forwarded. The display name
+      # is kept (the Reply-To’s name, else the From name). One reply address takes at most 100 replies a day.
+      #
+      # @param id [String] Domain id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Boolean] :open_tracking Default open tracking for emails from this domain.
+      # @option params [Boolean] :click_tracking Default click tracking for emails from this domain.
+      # @option params [String] :tls Outbound encryption: opportunistic (default: encrypt whenever offered),
+      #   required (TLS or no delivery) or verified (TLS with a valid certificate). Limits: other values → 422
+      #   invalid_parameter "tls must be opportunistic, required or verified"
+      # @option params [Boolean] :reply_tracking Default reply tracking for emails from this domain (override
+      #   per email with tracking.replies). Limits: true without a reply_domain → 422 invalid_parameter
+      #   "reply_tracking needs a reply_domain: add an inbound domain such as reply.<domain> first"
+      # @option params [String] :reply_domain Where tracked reply addresses live: one of your inbound domains,
+      #   MX-verified, equal to this domain or a subdomain of it (e.g. reply.acme.com). "" clears it. Limits:
+      #   otherwise 422 invalid_parameter
+      # @option params [String] :reply_forward_to Where replies a person wrote are forwarded: a plain address
+      #   on one of your verified domains, or a confirmed forward destination; never a receiving address. ""
+      #   (default) forwards to the email’s first Reply-To, else its From. Limits: otherwise 422
+      #   invalid_parameter
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Domain]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/domains/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::Domain,
+          request_options: request_options
+        )
+      end
+
+      # Verify a domain.
+      #
+      # Check DKIM/SPF/DMARC DNS now and update the domain's status. Requires a full-access live key; test
+      # keys get 403 test_key_restricted. found shows, per DNS name, what is published right now. For the root
+      # domain only SPF-type TXT values are listed; a DMARC policy inherited from the parent domain is marked
+      # “(inherited from _dmarc.<domain>)”.
+      #
+      # @param id [String] Domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Domain]
+      def verify(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/domains/#{Util.seg("id", id)}/verify",
+          model: Models::Domain,
+          request_options: request_options
+        )
+      end
+
+      # Delete a domain.
+      #
+      # Delete a sending domain. Requires a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [nil]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/domains/#{Util.seg("id", id)}",
+          model: nil,
+          request_options: request_options
+        )
+      end
+
+      # DMARC reports.
+      #
+      # DMARC aggregate reports about the domain: the address to publish in your DMARC record and what mailbox
+      # providers reported. Requires a full-access key. Add rua to your DMARC record (keep your policy).
+      # Providers send one report a day; reports are kept 400 days. ours marks ZapSMTP sending IPs: another IP
+      # that fails DMARC is a service you have not set up (add its DKIM/SPF) or someone spoofing your domain.
+      #
+      # @param id [String] Domain id.
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :days 1-180; out-of-range falls back to 30. Default: 30.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::DmarcSummary]
+      def get_dmarc(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :get,
+          path: "/domains/#{Util.seg("id", id)}/dmarc",
+          query: Util.params(params, kwargs),
+          model: Models::DmarcSummary,
+          request_options: request_options
+        )
+      end
+
+      # Domain reputation.
+      #
+      # Blocklist (DNSBL) status of a sending domain. Requires a full-access key. Customer domains are checked
+      # automatically every 6 hours (operator-configurable). The exact JSON for codes/labels when empty (null
+      # vs []) depends on the stored arrays; not verified.
+      #
+      # @param id [String] Domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::DomainReputation]
+      def get_reputation(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/domains/#{Util.seg("id", id)}/reputation",
+          model: Models::DomainReputation,
+          request_options: request_options
+        )
+      end
+
+      # Check reputation now.
+      #
+      # Run a blocklist check of the domain now and return its reputation. Requires a full-access live key;
+      # test keys get 403 test_key_restricted. At most once per minute per domain name. No Retry-After header
+      # is set.
+      #
+      # @param id [String] Domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::DomainReputation]
+      def check_reputation(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/domains/#{Util.seg("id", id)}/reputation/check",
+          model: Models::DomainReputation,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve brand settings.
+      #
+      # Brand-in-the-inbox status: sender name, BIMI logo/certificate, DMARC enforcement and per-provider
+      # readiness. Requires a full-access key.
+      #
+      # @param id [String] Domain id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Brand]
+      def get_brand(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/domains/#{Util.seg("id", id)}/brand",
+          model: Models::Brand,
+          request_options: request_options
+        )
+      end
+
+      # Update brand settings.
+      #
+      # Set the default sender name and upload/remove the BIMI logo and certificate. Requires a full-access
+      # live key; test keys get 403 test_key_restricted. Hosted files are served publicly at
+      # /bimi/<domain>/logo.svg and /bimi/<domain>/cert.pem (outside /v1) for verified domains only.
+      #
+      # @param id [String] Domain id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :from_name Display name used when an email's from has only an address. ""
+      #   clears it. Limits: max 70 characters, no < > " or line breaks → 422 invalid_parameter
+      # @option params [String] :logo_svg SVG source; normalized to SVG Tiny PS (fixes reported in logo_fixed,
+      #   warnings in logo_warnings). Limits: max 32 KB and valid SVG → otherwise 422 invalid_logo
+      # @option params [String] :cert_pem VMC/CMC PEM chain (certificate, intermediate, root). Limits: 422
+      #   invalid_certificate
+      # @option params [Boolean] :remove_logo Default: False.
+      # @option params [Boolean] :remove_cert Default: False.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Brand]
+      def update_brand(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :put,
+          path: "/domains/#{Util.seg("id", id)}/brand",
+          body: Util.params(params, kwargs),
+          model: Models::Brand,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.api_keys
+    class ApiKeys
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List API keys.
+      #
+      # List active API keys (newest first); tokens are never returned. Requires a full-access key. Revoked
+      # keys and SMTP credentials are not listed. last_used_at is updated at most every 5 minutes.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::ApiKey>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/api-keys",
+          model: Models::ApiKey,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Create an API key.
+      #
+      # Create an API key; the full key (token) is returned only once. Requires a full-access live key; test
+      # keys get 403 test_key_restricted.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Limits: 1-100 characters (not trimmed) → 422 invalid_parameter "name is
+      #   required (max 100 chars)" Required.
+      # @option params [String] :permission One of: full_access, sending_access. Default: full_access.
+      # @option params [String] :domain_id Restrict sending to one of the account's domains. Only with
+      #   sending_access. Limits: 422 "domain_id can only be used with sending_access" / "unknown domain_id"
+      # @option params [String] :mode test creates a zap_test_ key (see API keys). One of: live, test.
+      #   Default: live.
+      # @option params [String] :stream Restrict the key to one message stream. One of: transactional,
+      #   broadcast.
+      # @option params [String] :expires_at Limits: must be in the future → 422 "expires_at must be in the
+      #   future"
+      # @option params [Integer] :expires_in_days Alternative to expires_at; when > 0 it overrides expires_at.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::CreatedApiKey]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/api-keys",
+          body: Util.params(params, kwargs),
+          model: Models::CreatedApiKey,
+          request_options: request_options
+        )
+      end
+
+      # Revoke an API key.
+      #
+      # Revoke an API key immediately. Requires a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] API key id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [nil]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/api-keys/#{Util.seg("id", id)}",
+          model: nil,
+          request_options: request_options
+        )
+      end
+
+      # Update an API key.
+      #
+      # Rename a key or change its permission and restrictions. The token and the mode never change; the new
+      # rights apply to the next request. Requires a full-access live key; test keys get 403
+      # test_key_restricted.
+      #
+      # @param id [String] API key id.
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name 1–100 characters.
+      # @option params [String] :permission One of: full_access, sending_access.
+      # @option params [String, nil] :domain_id Restrict sending to one verified domain (sending access only).
+      #   null lifts the restriction.
+      # @option params [String, nil] :stream Restrict to one stream. null lifts the restriction. One of:
+      #   transactional, broadcast.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::ApiKey]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/api-keys/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::ApiKey,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.smtp_credentials
+    class SmtpCredentials
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List SMTP credentials.
+      #
+      # List active SMTP credentials plus the plan limit and relay settings. Requires a full-access key. No
+      # has_more field on this list. limit = plan's max SMTP credentials (0 = unlimited). smtp_relay is false
+      # on the Free plan, which sends through the Email API only.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SmtpCredentialList]
+      def list(request_options: {})
+        @client.request(
+          method: :get,
+          path: "/smtp-credentials",
+          model: Models::SmtpCredentialList,
+          request_options: request_options
+        )
+      end
+
+      # Create SMTP credentials.
+      #
+      # Create an SMTP credential; the password is returned only once. Requires a full-access live key; test
+      # keys get 403 test_key_restricted. Password: 40 base62 characters. Credentials are sending-only (always
+      # behave like sending_access, live mode) and cannot call the HTTP API.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Limits: trimmed, 1-100 characters → 422 invalid_parameter "name is
+      #   required (max 100 chars)" Required.
+      # @option params [String] :domain_id Restrict the credential to one of the account's domains. Limits:
+      #   422 invalid_parameter "unknown domain_id"
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SmtpCredential]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/smtp-credentials",
+          body: Util.params(params, kwargs),
+          model: Models::SmtpCredential,
+          request_options: request_options
+        )
+      end
+
+      # Revoke SMTP credentials.
+      #
+      # Revoke an SMTP credential. Requires a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] SMTP credential id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [nil]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/smtp-credentials/#{Util.seg("id", id)}",
+          model: nil,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.webhooks.events
+    class WebhooksEvents
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # Replay an event.
+      #
+      # Re-send a past event (from the last 100 deliveries) to the endpoint now. Requires a full-access live
+      # key; test keys get 403 test_key_restricted. Same body and Zap-Event-Id as the original, signed with
+      # the current secret(s) and a new timestamp. The replay is sent synchronously and not retried. Events
+      # whose body was over 64 KB cannot be replayed.
+      #
+      # @param id [String] Webhook id
+      # @param event [String] Event id (evt_...) from GET /webhooks/{id}/deliveries
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::WebhookTestResult]
+      def replay(id, event, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/webhooks/#{Util.seg("id", id)}/deliveries/#{Util.seg("event", event)}/replay",
+          model: Models::WebhookTestResult,
+          request_options: request_options
+        )
+      end
+
+      # List events.
+      #
+      # Events sent to this endpoint, newest first, each with its outcome and number of attempts (from the
+      # endpoint’s last 100 delivery attempts). Requires a full-access key.
+      #
+      # @param id [String] Webhook id.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::WebhookEventRecord>]
+      def list(id, request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/webhooks/#{Util.seg("id", id)}/events",
+          model: Models::WebhookEventRecord,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve an event.
+      #
+      # One event with its payload and every delivery attempt, oldest first. Requires a full-access key.
+      #
+      # @param id [String] Webhook id.
+      # @param event [String] Event id (Zap-Event-Id).
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::WebhookEventRecord]
+      def get(id, event, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/webhooks/#{Util.seg("id", id)}/events/#{Util.seg("event", event)}",
+          model: Models::WebhookEventRecord,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.webhooks
+    class Webhooks
+      # @return [WebhooksEvents]
+      attr_reader :events
+
+      # @api private
+      def initialize(client)
+        @client = client
+        @events = WebhooksEvents.new(client)
+      end
+
+      # List webhooks.
+      #
+      # List webhook endpoints (newest first); secrets are omitted. Requires a full-access key.
+      # previous_secret_expires_at appears while a rotated secret still signs deliveries.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Webhook>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/webhooks",
+          model: Models::Webhook,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Create a webhook.
+      #
+      # Create a webhook endpoint; the signing secret is returned. Requires a full-access live key; test keys
+      # get 403 test_key_restricted. The secret is also readable later via GET /webhooks/{id}. To send clicks
+      # of one button to this endpoint: {"events": ["email.clicked"], "filter": {"actions":
+      # ["confirm_order"]}}. Endpoints always return filter, with an empty list when there is none.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :url Absolute https:// URL. Limits: 422 invalid_parameter "url must be an
+      #   absolute https:// URL" Required.
+      # @option params [Array<String>] :events Limits: unknown type → 422 invalid_parameter "unknown event
+      #   type <x>; allowed: ..." One of: email.sent, email.delivered, email.delivery_delayed, email.bounced,
+      #   email.complained, email.failed, email.opened, email.clicked, email.suppressed, email.received,
+      #   thread.created, thread.replied, email.replied. Default: all event types.
+      # @option params [Boolean] :include_content email.received carries the message: text, html, headers, and
+      #   download links (valid 24 hours) for the attachments and the raw .eml; text and html are cut at 1 MB in
+      #   total (truncated: true). Default: false.
+      # @option params [Boolean] :batch Send events up to 100 per request (or every second) as a JSON array,
+      #   signed as one body; Zap-Event-Id is the batch id, each event keeps its own id. email.received with the
+      #   full message still arrives alone. Default: false.
+      # @option params [Hash] :filter Narrows email.clicked to some click actions; other event types are not
+      #   affected. Empty or absent: every click. Default: {"actions": []}.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Webhook]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/webhooks",
+          body: Util.params(params, kwargs),
+          model: Models::Webhook,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a webhook.
+      #
+      # Retrieve a webhook endpoint including its signing secret. Requires a full-access key.
+      #
+      # @param id [String] Webhook id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Webhook]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/webhooks/#{Util.seg("id", id)}",
+          model: Models::Webhook,
+          request_options: request_options
+        )
+      end
+
+      # Update a webhook.
+      #
+      # Update a webhook's URL, events, click-action filter or enabled state. Requires a full-access live key;
+      # test keys get 403 test_key_restricted. The response's disabled_reason reflects the value before the
+      # update (the store clears it on re-enable but the returned object is not reloaded).
+      #
+      # @param id [String] Webhook id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :url Limits: absolute https:// URL
+      # @option params [Array<String>] :events Limits: [] → 422 "select at least one event"; unknown type →
+      #   422 "unknown event type <x>" One of: email.sent, email.delivered, email.delivery_delayed,
+      #   email.bounced, email.complained, email.failed, email.opened, email.clicked, email.suppressed,
+      #   email.received, thread.created, thread.replied, email.replied.
+      # @option params [Boolean] :enabled Re-enabling clears disabled_reason. Disabling drops pending
+      #   deliveries.
+      # @option params [Boolean] :include_content email.received carries the message: text, html, headers, and
+      #   download links (valid 24 hours) for the attachments and the raw .eml; text and html are cut at 1 MB in
+      #   total (truncated: true). Default: false.
+      # @option params [Boolean] :batch Send events up to 100 per request (or every second) as a JSON array,
+      #   signed as one body; Zap-Event-Id is the batch id, each event keeps its own id. email.received with the
+      #   full message still arrives alone. Default: false.
+      # @option params [Hash] :filter Narrows email.clicked to some click actions; other event types are not
+      #   affected. Empty or absent: every click. Replaces the whole filter; {"actions": []} removes it.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Webhook]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/webhooks/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::Webhook,
+          request_options: request_options
+        )
+      end
+
+      # Delete a webhook.
+      #
+      # Delete a webhook endpoint. Requires a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Webhook id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [nil]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/webhooks/#{Util.seg("id", id)}",
+          model: nil,
+          request_options: request_options
+        )
+      end
+
+      # Send a test event.
+      #
+      # Send a signed sample event to the endpoint now and report the result. Requires a full-access live key;
+      # test keys get 403 test_key_restricted. Test events are not retried. delivery.error is present when the
+      # attempt failed (e.g. "HTTP 500"); status_code is 0 on network errors. The test attempt is recorded in
+      # the delivery log.
+      #
+      # @param id [String] Webhook id
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :type Limits: 422 invalid_parameter "unknown event type" One of: email.sent,
+      #   email.delivered, email.delivery_delayed, email.bounced, email.complained, email.failed, email.opened,
+      #   email.clicked, email.suppressed, email.received, thread.created, thread.replied, email.replied.
+      #   Default: email.delivered.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::WebhookTestResult]
+      def test(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/webhooks/#{Util.seg("id", id)}/test",
+          body: Util.params(params, kwargs),
+          model: Models::WebhookTestResult,
+          request_options: request_options
+        )
+      end
+
+      # List delivery attempts.
+      #
+      # List the last 100 delivery attempts of a webhook (newest first). Requires a full-access key. attempt
+      # starts at 1. body is the exact payload sent (omitted above 64 KB); error is omitted on success.
+      #
+      # @param id [String] Webhook id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::WebhookDelivery>]
+      def list_deliveries(id, request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/webhooks/#{Util.seg("id", id)}/deliveries",
+          model: Models::WebhookDelivery,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Rotate the signing secret.
+      #
+      # Generate a new signing secret; the old one stays valid for 24 hours. Requires a full-access live key;
+      # test keys get 403 test_key_restricted. During the grace period Zap-Signature carries two v1= entries
+      # (new secret first). Rotating again replaces the previous secret.
+      #
+      # @param id [String] Webhook id
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Webhook]
+      def rotate_secret(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/webhooks/#{Util.seg("id", id)}/rotate-secret",
+          model: Models::Webhook,
+          request_options: request_options
+        )
+      end
+
+      # Checks a webhook request's Zap-Signature and returns its event (see ZapSMTP::Webhook.verify).
+      #
+      # @return [ZapSMTP::WebhookEvent]
+      def verify(payload, headers, secret, **options)
+        ZapSMTP::Webhook.verify(payload, headers, secret, **options)
+      end
+
+      # Checks a webhook request's Zap-Signature and returns its events: every event of a batch, or the one
+      # event (see ZapSMTP::Webhook.verify_events).
+      #
+      # @return [Array<ZapSMTP::WebhookEvent>]
+      def verify_events(payload, headers, secret, **options)
+        ZapSMTP::Webhook.verify_events(payload, headers, secret, **options)
+      end
+    end
+
+    # zap.templates.versions
+    class TemplatesVersions
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List versions.
+      #
+      # List a template’s saved versions, newest first. Requires a full-access key. A version is recorded on
+      # every create, update, publish and restore: kind is saved, published or restored. author is the
+      # teammate’s email, or API key. The newest 50 versions are kept. List items leave out the bodies;
+      # retrieve a version for them.
+      #
+      # @param id [String] Template id or alias.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::TemplateVersion>]
+      def list(id, request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/templates/#{Util.seg("id", id)}/versions",
+          model: Models::TemplateVersion,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a version.
+      #
+      # Retrieve one version with its bodies and design. Requires a full-access key. Empty html, text and from
+      # are left out, and so is design for a code template.
+      #
+      # @param id [String] Template id or alias.
+      # @param vid [String] Version id from the list.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::TemplateVersion]
+      def get(id, vid, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/templates/#{Util.seg("id", id)}/versions/#{Util.seg("vid", vid)}",
+          model: Models::TemplateVersion,
+          request_options: request_options
+        )
+      end
+
+      # Restore a version.
+      #
+      # Copy a version back into the draft. Publishing stays a separate step. Requires a full-access live key;
+      # test keys get 403 test_key_restricted. Restores name, subject, html, text, from and design; alias and
+      # sample variables stay. The restore is recorded as a version of kind restored. Sends keep using the
+      # published version until you publish.
+      #
+      # @param id [String] Template id or alias.
+      # @param vid [String] Version id from the list.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Template]
+      def restore(id, vid, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/templates/#{Util.seg("id", id)}/versions/#{Util.seg("vid", vid)}/restore",
+          model: Models::Template,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.templates
+    class Templates
+      # @return [TemplatesVersions]
+      attr_reader :versions
+
+      # @api private
+      def initialize(client)
+        @client = client
+        @versions = TemplatesVersions.new(client)
+      end
+
+      # List templates.
+      #
+      # List templates (most recently updated first). Requires a full-access key. variables are sample values
+      # for previews; variable_names lists the variables used in the subject and bodies.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Template>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/templates",
+          model: Models::Template,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Create a template.
+      #
+      # Create a template (logic-less Mustache). Requires a full-access live key; test keys get 403
+      # test_key_restricted. Syntax: {{var}} escaped, {{{var}}} raw, {{#list}}…{{/list}} sections,
+      # {{^x}}…{{/x}} inverted sections. Exact ordering of variable_names is determined by the parser; the
+      # example order is illustrative. Body: html and text both empty → 422 missing_required_field; template
+      # syntax errors → 422 template_render_error "<field>: <error>"; a tag that is not a variable name
+      # ({{first name}}, {{#each items}}, {{> footer}}) → 422 template_render_error "html: line L, column C:
+      # {{…}} is not a variable name: …" variable_schema in the response is the saved list after discovery. A
+      # send is checked against the published copy, published.variable_schema.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Limits: trimmed, 1-200 characters → 422 missing_required_field "name is
+      #   required (max 200 chars)" Required.
+      # @option params [String] :alias Stable handle usable instead of the id (template.id in sends,
+      #   /templates/{alias}). Limits: ^[a-z0-9][a-z0-9_-]{0,62}$ → 422 invalid_parameter; duplicate → 409
+      #   conflict
+      # @option params [String] :subject Mustache source.
+      # @option params [String] :html At least one of html and text is required. Mustache source; {{var}} is
+      #   HTML-escaped, {{{var}}} raw.
+      # @option params [String] :text
+      # @option params [String] :from Default From used when a send omits from.
+      # @option params [Hash{String => Object}] :variables Sample variables used by previews. Never used for
+      #   sending; a variable first found in the source takes its sample as example.
+      # @option params [Array<Hash>] :variable_schema Declares the template’s variables (see Variable schema).
+      #   Replaces the declared list when given. On every save, names the source uses that the list lacks are
+      #   added (their sample value as example): a section {{#x}} as optional any, a dotted {{x.y}} as a
+      #   required object, any other name as a required any, never stricter than sends were before, and declared
+      #   names the source no longer uses are kept with unused: true. Limits: at most 200 entries, no
+      #   duplicates, defaults and examples of their type → 422 invalid_parameter "variable_schema: <reason>"
+      # @option params [Object] :design The visual editor’s document (a JSON object with a numeric version),
+      #   stored with the template. null makes it a code template. Changing html without sending design drops
+      #   the design (it no longer describes the HTML). Limits: max 1 MB → 422 invalid_parameter "design is
+      #   larger than 1 MB"; not an object with a numeric version → 422 invalid_parameter
+      # @option params [Boolean] :publish Publish the result in the same call. Without it the template stays a
+      #   draft and is not used for sending until published. Default: false.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Template]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/templates",
+          body: Util.params(params, kwargs),
+          model: Models::Template,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a template.
+      #
+      # Retrieve a template by id or alias. Requires a full-access key. id is what template.id takes when you
+      # send; the alias works too. published is the version sends use (null until the first publish).
+      # published.variable_schema is null for a template last published before variable schemas existed: its
+      # sends need every variable, as before, until it is published again.
+      #
+      # @param id [String] Template id (UUID) or alias
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Template]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/templates/#{Util.seg("id", id)}",
+          model: Models::Template,
+          request_options: request_options
+        )
+      end
+
+      # Update a template.
+      #
+      # Update a template (partial). Requires a full-access live key; test keys get 403 test_key_restricted.
+      # Fields left out keep their value; the same validation as create applies to the result. Every save (and
+      # publish) is kept in the version history: see List versions. has_unpublished_changes is also true when
+      # only the draft’s variable_schema differs from the published one.
+      #
+      # @param id [String] Template id or alias
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Limits: trimmed, 1-200 characters → 422 missing_required_field "name is
+      #   required (max 200 chars)"
+      # @option params [String] :alias Stable handle; "" removes it usable instead of the id (template.id in
+      #   sends, /templates/{alias}). Limits: ^[a-z0-9][a-z0-9_-]{0,62}$ → 422 invalid_parameter; duplicate →
+      #   409 conflict
+      # @option params [String] :subject Mustache source.
+      # @option params [String] :html Mustache source; {{var}} is HTML-escaped, {{{var}}} raw.
+      # @option params [String] :text
+      # @option params [String] :from Default From used when a send omits from.
+      # @option params [Hash{String => Object}] :variables Sample variables used by previews; replaces the
+      #   whole object. Never used for sending; a variable first found in the source takes its sample as
+      #   example.
+      # @option params [Array<Hash>] :variable_schema Declares the template’s variables (see Variable schema).
+      #   Replaces the declared list when given. On every save, names the source uses that the list lacks are
+      #   added (their sample value as example): a section {{#x}} as optional any, a dotted {{x.y}} as a
+      #   required object, any other name as a required any, never stricter than sends were before, and declared
+      #   names the source no longer uses are kept with unused: true. Limits: at most 200 entries, no
+      #   duplicates, defaults and examples of their type → 422 invalid_parameter "variable_schema: <reason>"
+      # @option params [Object] :design The visual editor’s document (a JSON object with a numeric version),
+      #   stored with the template. null makes it a code template. Changing html without sending design drops
+      #   the design (it no longer describes the HTML). Limits: max 1 MB → 422 invalid_parameter "design is
+      #   larger than 1 MB"; not an object with a numeric version → 422 invalid_parameter
+      # @option params [Boolean] :publish Publish the result in the same call. Without it the template stays a
+      #   draft and is not used for sending until published. Default: false.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Template]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/templates/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::Template,
+          request_options: request_options
+        )
+      end
+
+      # Delete a template.
+      #
+      # Delete a template. Requires a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Template id or alias
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Deleted]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/templates/#{Util.seg("id", id)}",
+          model: Models::Deleted,
+          request_options: request_options
+        )
+      end
+
+      # Render a template.
+      #
+      # Preview a stored template with given variables (defaults to its sample variables). Requires a
+      # full-access key. Missing variables do not fail the preview; they are listed in missing_variables.
+      #
+      # @param id [String] Template id or alias
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Hash{String => Object}] :variables Variables to render with; when omitted the
+      #   template's stored sample variables are used.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::RenderedTemplate]
+      def render(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/templates/#{Util.seg("id", id)}/render",
+          body: Util.params(params, kwargs),
+          model: Models::RenderedTemplate,
+          request_options: request_options
+        )
+      end
+
+      # Render unsaved source.
+      #
+      # Validate and preview unsaved template source. Requires a full-access key.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :subject
+      # @option params [String] :html
+      # @option params [String] :text
+      # @option params [Hash{String => Object}] :variables Default: {}.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::RenderedTemplate]
+      def render_source(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/templates/render",
+          body: Util.params(params, kwargs),
+          model: Models::RenderedTemplate,
+          request_options: request_options
+        )
+      end
+
+      # Publish a template.
+      #
+      # Make the current draft the version sends use. Until a template is published, sending with it fails.
+      # Requires a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Template id or alias.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Template]
+      def publish(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/templates/#{Util.seg("id", id)}/publish",
+          model: Models::Template,
+          request_options: request_options
+        )
+      end
+
+      # Duplicate a template.
+      #
+      # Copy a template’s draft into a new, unpublished template named “… (copy)”, without the alias. Requires
+      # a full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Template id or alias.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Template]
+      def duplicate(id, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/templates/#{Util.seg("id", id)}/duplicate",
+          model: Models::Template,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.suppressions
+    class Suppressions
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List suppressions.
+      #
+      # List suppressed addresses, newest first, with cursor pagination. Requires a full-access key. reason is
+      # hard_bounce, complaint, unsubscribe or manual; source_id is the email that caused it (null when added
+      # by hand). Pass next_cursor as after for the next page. unsubscribe stops only broadcast email (stream:
+      # broadcast); transactional email to the address still goes out. Every other reason stops all email to
+      # it.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :limit 1-1000; out-of-range falls back to 100. Default: 100.
+      # @option params [String] :after Opaque cursor from next_cursor. Limits: 422 invalid_parameter "invalid
+      #   after cursor"
+      # @option params [String] :before Legacy: RFC 3339 timestamp; returns entries created before it. Ignored
+      #   when after is set. Limits: 422 invalid_parameter "before must be RFC3339"
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Suppression>]
+      def list(params = {}, request_options: {}, **kwargs)
+        @client.request_page(
+          method: :get,
+          path: "/suppressions",
+          query: Util.params(params, kwargs),
+          model: Models::Suppression,
+          paging: :cursor,
+          request_options: request_options
+        )
+      end
+
+      # Add a suppression.
+      #
+      # Add an address to the suppression list. Requires a full-access live key; test keys get 403
+      # test_key_restricted. Idempotent: an existing entry keeps its reason, except that an unsubscribe entry
+      # becomes manual when you add it as manual (a later bounce or complaint upgrades it the same way). The
+      # response echoes the requested reason with 201.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :email Address (stored lowercased). Limits: 422 invalid_parameter "invalid
+      #   email" Required.
+      # @option params [String] :reason manual: no email at all; unsubscribe: no broadcast email
+      #   (transactional email still goes out). Limits: 422 invalid_parameter "reason must be manual or
+      #   unsubscribe" One of: manual, unsubscribe. Default: manual.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Suppression]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/suppressions",
+          body: Util.params(params, kwargs),
+          model: Models::Suppression,
+          request_options: request_options
+        )
+      end
+
+      # Remove a suppression.
+      #
+      # Remove an address from the suppression list. Requires a full-access live key; test keys get 403
+      # test_key_restricted.
+      #
+      # @param email [String] Address (URL-encoded; matched case-insensitively)
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [nil]
+      def delete(email, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/suppressions/#{Util.seg("email", email)}",
+          model: nil,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a suppression.
+      #
+      # Check whether one address is suppressed, and why. Requires a full-access key. unsubscribe stops only
+      # broadcast email (stream: broadcast); transactional email to the address still goes out. Every other
+      # reason stops all email to it.
+      #
+      # @param email [String] The address (case-insensitive, URL-encoded).
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Suppression]
+      def get(email, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/suppressions/#{Util.seg("email", email)}",
+          model: Models::Suppression,
+          request_options: request_options
+        )
+      end
+
+      # Add suppressions in bulk.
+      #
+      # Add up to 1,000 addresses in one call. Duplicates are ignored; existing entries keep their reason (an
+      # unsubscribe becomes manual when added as manual); sends see the change immediately. Requires a
+      # full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Array<String>] :emails 1–1,000 addresses. Required.
+      # @option params [String] :reason manual: no email at all; unsubscribe: no broadcast email
+      #   (transactional email still goes out). One of: manual, unsubscribe. Default: manual.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SuppressionBatch]
+      def create_batch(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/suppressions/batch",
+          body: Util.params(params, kwargs),
+          model: Models::SuppressionBatch,
+          request_options: request_options
+        )
+      end
+
+      # Remove suppressions in bulk.
+      #
+      # Remove up to 1,000 addresses in one call. Addresses that are not on the list are ignored. Requires a
+      # full-access live key; test keys get 403 test_key_restricted.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Array<String>] :emails 1–1,000 addresses. Required.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::SuppressionBatch]
+      def delete_batch(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/suppressions/batch/remove",
+          body: Util.params(params, kwargs),
+          model: Models::SuppressionBatch,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.dedicated_ips
+    class DedicatedIps
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List dedicated IPs.
+      #
+      # List the account's dedicated IPs with warm-up progress and current blocklist listings. Requires a
+      # full-access key. status is warming, active or paused. During warm-up, warmup_day and daily_cap show
+      # the current day and today’s volume limit. blocklists lists current listings of the IP.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::DedicatedIp>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/dedicated-ips",
+          model: Models::DedicatedIp,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.logs
+    class Logs
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List logs.
+      #
+      # List the API requests made with your keys, newest first. Bodies are on Retrieve a log. Entries appear
+      # within seconds and are kept for your plan’s log retention. Requires a full-access key. Requests made
+      # with API keys are logged; the dashboard’s own calls are not. The X-Request-Id header of every response
+      # is the id of its log entry.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [Integer] :limit 1–100. Default: 20.
+      # @option params [String] :before A log id: return older entries.
+      # @option params [String] :after A log id: return newer entries.
+      # @option params [String] :status An exact status (422) or a class: 2xx, 4xx, 5xx.
+      # @option params [String] :method HTTP method.
+      # @option params [String] :path Path prefix, e.g. /v1/emails.
+      # @option params [String] :api_key_id Only requests made with this key.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Log>]
+      def list(params = {}, request_options: {}, **kwargs)
+        @client.request_page(
+          method: :get,
+          path: "/logs",
+          query: Util.params(params, kwargs),
+          model: Models::Log,
+          paging: :logs,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a log.
+      #
+      # Retrieve one request with its request and response bodies. Bodies are capped at 16 KB; API keys,
+      # passwords and signing secrets are always replaced with [redacted]. Requires a full-access key.
+      #
+      # @param id [String] Log id (the X-Request-Id of the response).
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Log]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/logs/#{Util.seg("id", id)}",
+          model: Models::Log,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.usage
+    class Usage
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # Retrieve usage.
+      #
+      # This month’s sending against your plan: emails sent, included volume, limit, overage and, on the Free
+      # plan, today’s count. Requires a full-access key. limit is null on paid plans without a spending cap:
+      # email keeps flowing and extra volume is billed. The Free plan adds daily_limit and sent_today.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Usage]
+      def get(request_options: {})
+        @client.request(method: :get, path: "/usage", model: Models::Usage, request_options: request_options)
+      end
+    end
+
+    # zap.template_modules
+    class TemplateModules
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List modules.
+      #
+      # List saved modules (reusable rows for the visual editor), most recently updated first. Requires a
+      # full-access key. All modules of the account in one page (has_more is always false).
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::TemplateModule>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/template-modules",
+          model: Models::TemplateModule,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Save a module.
+      #
+      # Save rows as a module that every template of the account can insert. Requires a full-access live key;
+      # test keys get 403 test_key_restricted. Inserting a module copies its rows into the template: changing
+      # the module later does not change templates that already use it.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Limits: trimmed, 1-200 characters → 422 missing_required_field Required.
+      # @option params [String] :category Groups modules in the editor’s palette. Limits: trimmed, max 100
+      #   characters → 422 missing_required_field Default: "".
+      # @option params [Object] :design The saved rows: {"rows": [...]} with at least one row in the visual
+      #   editor’s format (copy rows from a template’s design). Limits: max 1 MB → 422 invalid_parameter
+      #   Required.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::TemplateModule]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/template-modules",
+          body: Util.params(params, kwargs),
+          model: Models::TemplateModule,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve a module.
+      #
+      # Retrieve a module. Requires a full-access key.
+      #
+      # @param id [String] Module id.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::TemplateModule]
+      def get(id, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/template-modules/#{Util.seg("id", id)}",
+          model: Models::TemplateModule,
+          request_options: request_options
+        )
+      end
+
+      # Update a module.
+      #
+      # Rename, recategorize or replace a module’s rows. Requires a full-access live key; test keys get 403
+      # test_key_restricted. Fields left out keep their value.
+      #
+      # @param id [String] Module id.
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name Limits: trimmed, 1-200 characters → 422 missing_required_field
+      # @option params [String] :category Groups modules in the editor’s palette. Limits: trimmed, max 100
+      #   characters → 422 missing_required_field
+      # @option params [Object] :design The saved rows: {"rows": [...]} with at least one row in the visual
+      #   editor’s format (copy rows from a template’s design). Limits: max 1 MB → 422 invalid_parameter
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::TemplateModule]
+      def update(id, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/template-modules/#{Util.seg("id", id)}",
+          body: Util.params(params, kwargs),
+          model: Models::TemplateModule,
+          request_options: request_options
+        )
+      end
+
+      # Delete a module.
+      #
+      # Delete a module. Templates that inserted it keep their copy. Requires a full-access live key; test
+      # keys get 403 test_key_restricted.
+      #
+      # @param id [String] Module id.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Deleted]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/template-modules/#{Util.seg("id", id)}",
+          model: Models::Deleted,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.template_assets
+    class TemplateAssets
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List images.
+      #
+      # List the account’s template images, newest first. Requires a full-access key. All images of the
+      # account in one page (has_more is always false).
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::TemplateAsset>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/template-assets",
+          model: Models::TemplateAsset,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Upload an image.
+      #
+      # Upload an image for use in templates, as a multipart file or by URL; returns its public URL. Requires
+      # a full-access live key; test keys get 403 test_key_restricted. PNG, JPEG, GIF or WebP, up to 5 MB and
+      # 40 megapixels; the file content decides the type, not its name. PNG and JPEG images wider than 1,200
+      # px are scaled down to 1,200 px (twice a 600 px email); GIF (animations included) and WebP are kept as
+      # they are. width and height are those of the stored image. The URL is public (anyone with it can load
+      # the image) and long-lived: use it in <img src> of any template. The name keeps letters, digits, spaces
+      # and . _ ( ) -, up to 200 characters. Each account holds up to 2,000 images and 1 GB.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :url JSON upload: an http(s) URL we download the image from (private and
+      #   internal addresses are refused). Limits: unreachable, not HTTP 200 or not a URL → 422
+      #   invalid_parameter Required.
+      # @option params [String] :name JSON upload: the file name shown in the image library. Default: the last
+      #   segment of the URL.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::TemplateAsset]
+      def upload(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/template-assets",
+          body: Util.params(params, kwargs),
+          model: Models::TemplateAsset,
+          request_options: request_options
+        )
+      end
+
+      # Upload an image, from a file: PNG, JPEG, GIF or WebP bytes sent as multipart/form-data.
+      #
+      # @param file [String, Pathname, IO] a file path, or an IO (File, StringIO, Tempfile) to read
+      # @param name [String, nil] the file name shown in the image library
+      # @param filename [String, nil] the file name sent with the upload (default: name, else the file's own
+      #   name)
+      # @param request_options [Hash] :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::TemplateAsset]
+      def upload_file(file, name: nil, filename: nil, request_options: {})
+        @client.request(
+          method: :post,
+          path: "/template-assets",
+          form: Util.upload_form("file", file, name: name, filename: filename),
+          model: Models::TemplateAsset,
+          request_options: request_options
+        )
+      end
+
+      # Delete an image.
+      #
+      # Delete an image. Its URL stops working, also in emails already sent. Requires a full-access live key;
+      # test keys get 403 test_key_restricted.
+      #
+      # @param id [String] Image id.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Deleted]
+      def delete(id, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/template-assets/#{Util.seg("id", id)}",
+          model: Models::Deleted,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.template_timers
+    class TemplateTimers
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a countdown timer.
+      #
+      # Create a countdown timer image: an animated GIF that shows the time left whenever the email is opened.
+      # Requires a full-access live key; test keys get 403 test_key_restricted. Nothing is stored: the URL
+      # carries the signed settings, so changing it breaks the image. Put it in an <img> of a template (the
+      # visual editor’s timer block does this for you). Each open renders one frame per second for a minute,
+      # then the last frame stays; after end it shows zeros. Renders are shared for 5 seconds, so a broadcast
+      # opened by many recipients at once costs one render.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :end When the countdown reaches zero. Limits: missing → 422 invalid_parameter
+      #   "end is required"; not RFC 3339 → 400 validation_error Required.
+      # @option params [Integer] :width Image width in px, 200-600; the height follows. Limits: otherwise 422
+      #   invalid_parameter "w must be 200–600" Default: 600.
+      # @option params [String] :digit_color Digit colour, hex RRGGBB or RRGGBBAA (a leading # is allowed).
+      #   Limits: otherwise 422 invalid_parameter "fg: colour must be RRGGBB or RRGGBBAA" Required.
+      # @option params [String] :label_color Label colour, same format. Limits: 422 invalid_parameter "lc: …"
+      #   Required.
+      # @option params [String] :background Background colour, same format; alpha 00 (e.g. ffffff00) is
+      #   transparent. Limits: 422 invalid_parameter "bg: …" Required.
+      # @option params [Array<String>] :labels Exactly 4 labels under days, hours, minutes and seconds, each
+      #   up to 12 characters, without |. "" hides one label; four empty labels hide the label row. Limits: 422
+      #   invalid_parameter "l must hold 4 labels separated by |" / "labels are limited to 12 characters"
+      #   Default: ["days", "hours", "minutes", "seconds"].
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::TemplateTimer]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/template-timers",
+          body: Util.params(params, kwargs),
+          model: Models::TemplateTimer,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.actions
+    class Actions
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List actions.
+      #
+      # List every action of the account: the ones you declared, the ones links named in the last 30 days, and
+      # the ones templates and webhook filters use. Sorted by name. Requires a full-access key. declared is
+      # false for an action that links use but nobody described; created_at and updated_at are then null.
+      # clicks_7d, clicks_30d and unique_clickers_30d (distinct email and recipient pairs) count the last 7
+      # and 30 days; last_click_at is null without a click in 30 days. templates counts the templates whose
+      # draft or published HTML names the action; webhooks lists the ids of the endpoints filtered on it.
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Action>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/actions",
+          model: Models::Action,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Declare an action.
+      #
+      # Declare an action and describe it. Optional: links work with any valid name, declared or not. Requires
+      # a full-access live key; test keys get 403 test_key_restricted. The response does not count activity:
+      # the stats are zero and templates is 0 here. Read them with GET /actions/{name}.
+      #
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :name The name links carry in data-zap-action: lowercase letters, digits, _, .
+      #   and -, starting with a letter or digit, up to 64 characters. Limits: other names → 422
+      #   invalid_parameter Required.
+      # @option params [String] :description What the button does, for your team. Limits: at most 500 bytes →
+      #   422 invalid_parameter
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Action]
+      def create(params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :post,
+          path: "/actions",
+          body: Util.params(params, kwargs),
+          model: Models::Action,
+          request_options: request_options
+        )
+      end
+
+      # Retrieve an action.
+      #
+      # Retrieve one action from the catalogue, with its activity and where it is used. Requires a full-access
+      # key.
+      #
+      # @param name [String] Action name, as written in data-zap-action.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Action]
+      def get(name, request_options: {})
+        @client.request(
+          method: :get,
+          path: "/actions/#{Util.seg("name", name)}",
+          model: Models::Action,
+          request_options: request_options
+        )
+      end
+
+      # Describe an action.
+      #
+      # Change an action’s description. An action that links use but nobody declared is declared by this call.
+      # Requires a full-access live key; test keys get 403 test_key_restricted. Like create, the response
+      # carries zero stats; read them with GET /actions/{name}.
+      #
+      # @param name [String] Action name, as written in data-zap-action.
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :description The new description; leaving it out sets it to empty. Limits: at
+      #   most 500 bytes → 422 invalid_parameter
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Action]
+      def update(name, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :patch,
+          path: "/actions/#{Util.seg("name", name)}",
+          body: Util.params(params, kwargs),
+          model: Models::Action,
+          request_options: request_options
+        )
+      end
+
+      # Delete an action.
+      #
+      # Delete an action’s declaration. Links that name it keep working: clicks are still tracked and still
+      # reach webhooks filtered on it. Requires a full-access live key; test keys get 403 test_key_restricted.
+      # While links or webhooks still use it, the action stays in the catalogue with declared: false.
+      #
+      # @param name [String] Action name, as written in data-zap-action.
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Deleted]
+      def delete(name, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/actions/#{Util.seg("name", name)}",
+          model: Models::Deleted,
+          request_options: request_options
+        )
+      end
+    end
+
+    # zap.variables
+    class Variables
+      # @api private
+      def initialize(client)
+        @client = client
+      end
+
+      # List variables.
+      #
+      # The variable catalogue: every variable the account’s templates can use, with where each is used.
+      # System variables first, then global ones, then template variables, each sorted by name. Requires a
+      # full-access key. kind is system (filled by ZapSMTP), global (set for the account, written
+      # {{global.key}}) or template (a template’s own). A global variable that templates use but that has no
+      # value yet is listed without value; sends with those templates fail until you set it. A template
+      # variable lists in types every type its templates declare, and per template its type, required, default
+      # and unused (declared, but the source no longer names it).
+      #
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Page<ZapSMTP::Models::Variable>]
+      def list(request_options: {})
+        @client.request_page(
+          method: :get,
+          path: "/variables",
+          model: Models::Variable,
+          paging: nil,
+          request_options: request_options
+        )
+      end
+
+      # Set a global variable.
+      #
+      # Create or replace a global variable. Every template that uses it renders the new value from the next
+      # send on. Requires a full-access live key; test keys get 403 test_key_restricted. The response does not
+      # list the templates using the variable; GET /variables does.
+      #
+      # @param key [String] The key, used as {{global.key}}: letters, digits, _ and -, starting with a letter
+      #   or _, up to 64; global is reserved. Limits: other keys → 422 invalid_parameter
+      # @param params [Hash] the parameters below, also accepted as keyword arguments
+      # @option params [String] :value The value, always a string. Limits: at most 10 KB → 422
+      #   invalid_parameter Default: "".
+      # @option params [String] :description What it is for. Limits: at most 500 bytes → 422 invalid_parameter
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Variable]
+      def set_global(key, params = {}, request_options: {}, **kwargs)
+        @client.request(
+          method: :put,
+          path: "/variables/global/#{Util.seg("key", key)}",
+          body: Util.params(params, kwargs),
+          model: Models::Variable,
+          request_options: request_options
+        )
+      end
+
+      # Delete a global variable.
+      #
+      # Delete a global variable. Sends with a template that still uses it then fail with 422
+      # template_render_error until it is set again. Requires a full-access live key; test keys get 403
+      # test_key_restricted.
+      #
+      # @param key [String] The key, used as {{global.key}}: letters, digits, _ and -, starting with a letter
+      #   or _, up to 64; global is reserved. Limits: other keys → 422 invalid_parameter
+      # @param request_options [Hash] :idempotency_key, :headers, :timeout and :max_retries for this call
+      # @return [ZapSMTP::Models::Deleted]
+      def delete_global(key, request_options: {})
+        @client.request(
+          method: :delete,
+          path: "/variables/global/#{Util.seg("key", key)}",
+          model: Models::Deleted,
+          request_options: request_options
+        )
+      end
+    end
+  end
+end