sentdm 0.31.0 → 0.33.0

data/rbi/sentdm/models/webhook_list_events_response.rbi

@@ -39,9 +39,22 @@ module Sentdm
       attr_accessor :error_message
 
       # The exact event body that was delivered, or attempted, for this record. One of
-      # the three webhook envelopes: a message status change, an inbound message, or a
-      # template status change. Read field and event to tell which, the same way your
-      # endpoint does.
+      # the six webhook envelopes:
+      #
+      # message — an outbound message changed status. message with event:
+      # message.received — someone replied to you. templates — a template was approved,
+      # rejected, paused or similar. channel — one of your markets moved in provisioning
+      # or compliance. contact — a consent signal: opt-in, opt-out or help. link — a
+      # tracked short link was clicked or a hosted file downloaded, or one expired or
+      # was revoked.
+      #
+      # Read field and event to tell which, the same way your endpoint does. The two
+      # message envelopes are the reason that is two fields and not one: they share a
+      # field and differ by event.
+      #
+      # Treat the list as open. It has grown twice — channel and then link — and a
+      # handler that rejects an envelope it does not recognise will break on the next
+      # addition rather than ignore it.
       sig do
         returns(
           T.nilable(
@@ -57,7 +70,10 @@ module Sentdm
             T.any(
               Sentdm::MessageEvent::OrHash,
               Sentdm::InboundMessageEvent::OrHash,
-              Sentdm::TemplateEvent::OrHash
+              Sentdm::TemplateEvent::OrHash,
+              Sentdm::ChannelEvent::OrHash,
+              Sentdm::ContactEvent::OrHash,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::OrHash
             )
         ).void
       end
@@ -92,7 +108,10 @@ module Sentdm
             T.any(
               Sentdm::MessageEvent::OrHash,
               Sentdm::InboundMessageEvent::OrHash,
-              Sentdm::TemplateEvent::OrHash
+              Sentdm::TemplateEvent::OrHash,
+              Sentdm::ChannelEvent::OrHash,
+              Sentdm::ContactEvent::OrHash,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::OrHash
             ),
           event_type: String,
           http_status_code: T.nilable(Integer),
@@ -108,9 +127,22 @@ module Sentdm
         delivery_status: nil,
         error_message: nil,
         # The exact event body that was delivered, or attempted, for this record. One of
-        # the three webhook envelopes: a message status change, an inbound message, or a
-        # template status change. Read field and event to tell which, the same way your
-        # endpoint does.
+        # the six webhook envelopes:
+        #
+        # message — an outbound message changed status. message with event:
+        # message.received — someone replied to you. templates — a template was approved,
+        # rejected, paused or similar. channel — one of your markets moved in provisioning
+        # or compliance. contact — a consent signal: opt-in, opt-out or help. link — a
+        # tracked short link was clicked or a hosted file downloaded, or one expired or
+        # was revoked.
+        #
+        # Read field and event to tell which, the same way your endpoint does. The two
+        # message envelopes are the reason that is two fields and not one: they share a
+        # field and differ by event.
+        #
+        # Treat the list as open. It has grown twice — channel and then link — and a
+        # handler that rejects an envelope it does not recognise will break on the next
+        # addition rather than ignore it.
         event_data: nil,
         event_type: nil,
         http_status_code: nil,
@@ -142,9 +174,22 @@ module Sentdm
       end
 
       # The exact event body that was delivered, or attempted, for this record. One of
-      # the three webhook envelopes: a message status change, an inbound message, or a
-      # template status change. Read field and event to tell which, the same way your
-      # endpoint does.
+      # the six webhook envelopes:
+      #
+      # message — an outbound message changed status. message with event:
+      # message.received — someone replied to you. templates — a template was approved,
+      # rejected, paused or similar. channel — one of your markets moved in provisioning
+      # or compliance. contact — a consent signal: opt-in, opt-out or help. link — a
+      # tracked short link was clicked or a hosted file downloaded, or one expired or
+      # was revoked.
+      #
+      # Read field and event to tell which, the same way your endpoint does. The two
+      # message envelopes are the reason that is two fields and not one: they share a
+      # field and differ by event.
+      #
+      # Treat the list as open. It has grown twice — channel and then link — and a
+      # handler that rejects an envelope it does not recognise will break on the next
+      # addition rather than ignore it.
       module EventData
         extend Sentdm::Internal::Type::Union
 
@@ -153,10 +198,437 @@ module Sentdm
             T.any(
               Sentdm::MessageEvent,
               Sentdm::InboundMessageEvent,
-              Sentdm::TemplateEvent
+              Sentdm::TemplateEvent,
+              Sentdm::ChannelEvent,
+              Sentdm::ContactEvent,
+              Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload
             )
           end
 
+        class SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload < Sentdm::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload,
+                Sentdm::Internal::AnyHash
+              )
+            end
+
+          # The specific event within the family, for example message.delivered,
+          # message.received or contact.opt_out. Absent on events that have no subtype, so
+          # treat it as optional.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :event
+
+          # The event family, for example message, templates or contact. Route on this
+          # first, then on event for the specific change.
+          sig { returns(T.nilable(String)) }
+          attr_reader :field
+
+          sig { params(field: String).void }
+          attr_writer :field
+
+          # Body of a link event: something happened to a tracked link Sent published on the
+          # customer's behalf. A link points either at a URL the customer supplied or at a
+          # file Sent hosts for them; LinkKind says which. Delivered when an eligible
+          # request is served, or when a published link reaches the end of its life.
+          #
+          # A click is a request, not a read receipt. link.clicked means the redirect was
+          # served; link.downloaded means bytes went out. Neither proves a person saw
+          # anything — messaging providers and link scanners fetch URLs on their own, which
+          # is what TrafficClass exists to tell apart. Filter on it before reporting a
+          # click-through rate; treat likely_human as a hint, never as delivery
+          # confirmation.
+          #
+          # RecordId identifies the link; the X-Webhook-Event-ID header identifies the
+          # delivery. One link is hit many times, so those are the two keys a subscriber
+          # needs: group by the first, deduplicate on the second — exactly as on every other
+          # family. The payload carries no event identifier of its own, for the same reason
+          # none of the others do.
+          #
+          # Nothing here identifies the visitor. No IP address and no visitor token crosses
+          # this boundary. Country, Device and Browser are coarse buckets derived at the
+          # edge and are absent whenever the request did not supply enough to derive them.
+          sig do
+            returns(
+              T.nilable(
+                Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload
+              )
+            )
+          end
+          attr_reader :payload
+
+          sig do
+            params(
+              payload:
+                T.nilable(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload::OrHash
+                )
+            ).void
+          end
+          attr_writer :payload
+
+          # The event-specific body.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :request_id
+
+          # When Sent emitted the event, in UTC (yyyy-MM-ddTHH:mm:ssZ). This is the emission
+          # time, not the time the underlying change happened. Use the timestamp inside the
+          # payload for the latter.
+          sig { returns(T.nilable(String)) }
+          attr_reader :timestamp
+
+          sig { params(timestamp: String).void }
+          attr_writer :timestamp
+
+          # The envelope Sent POSTs to a subscribed webhook endpoint. Every event shares
+          # this shape and varies only in Payload.
+          sig do
+            params(
+              event: T.nilable(String),
+              field: String,
+              payload:
+                T.nilable(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload::OrHash
+                ),
+              request_id: T.nilable(String),
+              timestamp: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The specific event within the family, for example message.delivered,
+            # message.received or contact.opt_out. Absent on events that have no subtype, so
+            # treat it as optional.
+            event: nil,
+            # The event family, for example message, templates or contact. Route on this
+            # first, then on event for the specific change.
+            field: nil,
+            # Body of a link event: something happened to a tracked link Sent published on the
+            # customer's behalf. A link points either at a URL the customer supplied or at a
+            # file Sent hosts for them; LinkKind says which. Delivered when an eligible
+            # request is served, or when a published link reaches the end of its life.
+            #
+            # A click is a request, not a read receipt. link.clicked means the redirect was
+            # served; link.downloaded means bytes went out. Neither proves a person saw
+            # anything — messaging providers and link scanners fetch URLs on their own, which
+            # is what TrafficClass exists to tell apart. Filter on it before reporting a
+            # click-through rate; treat likely_human as a hint, never as delivery
+            # confirmation.
+            #
+            # RecordId identifies the link; the X-Webhook-Event-ID header identifies the
+            # delivery. One link is hit many times, so those are the two keys a subscriber
+            # needs: group by the first, deduplicate on the second — exactly as on every other
+            # family. The payload carries no event identifier of its own, for the same reason
+            # none of the others do.
+            #
+            # Nothing here identifies the visitor. No IP address and no visitor token crosses
+            # this boundary. Country, Device and Browser are coarse buckets derived at the
+            # edge and are absent whenever the request did not supply enough to derive them.
+            payload: nil,
+            # The event-specific body.
+            request_id: nil,
+            # When Sent emitted the event, in UTC (yyyy-MM-ddTHH:mm:ssZ). This is the emission
+            # time, not the time the underlying change happened. Use the timestamp inside the
+            # payload for the latter.
+            timestamp: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                event: T.nilable(String),
+                field: String,
+                payload:
+                  T.nilable(
+                    Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload
+                  ),
+                request_id: T.nilable(String),
+                timestamp: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Payload < Sentdm::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Sentdm::Models::WebhookListEventsResponse::EventData::SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload::Payload,
+                  Sentdm::Internal::AnyHash
+                )
+              end
+
+            # The link's public identifier — the eight-character code in the short URL, for
+            # example A78B2BU0. Unique across both kinds, and never reused, so it is the
+            # stable key to group one link's events by.
+            sig { returns(String) }
+            attr_accessor :record_id
+
+            # Where the request appeared to come from, as an ISO 3166-1 alpha-2 code. Named
+            # separately from the country on a channel event, which is a destination market
+            # the customer registered for — this one is a property of a single visitor and is
+            # absent when the edge could not resolve it.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :access_country
+
+            # How the request was served, when the edge recorded it. Free text describing the
+            # outcome — show it to a human rather than branching on it.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :access_outcome
+
+            # The requesting browser family, for example chrome or safari, or unknown. Derived
+            # from the user agent.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :browser
+
+            # How many bytes were served, for a file access. A ranged request reports the
+            # bytes in that range, not the size of the file, so several accesses of one file
+            # can each report a part.
+            sig { returns(T.nilable(Integer)) }
+            attr_accessor :bytes_served
+
+            # The channel the message carrying this link went out on: sms, whatsapp, or rcs.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :channel
+
+            # The organization the link belongs to. Always the parent account, never a sender
+            # profile — read SenderProfileId for that.
+            #
+            # This family publishes the owner as an explicit pair rather than the single
+            # account_id the other families use. The pair says which organization and which
+            # profile without the subscriber deriving either, which is the trade: one more key
+            # against not having to know that account_id silently becomes the profile when one
+            # exists.
+            sig { returns(T.nilable(String)) }
+            attr_reader :customer_id
+
+            sig { params(customer_id: String).void }
+            attr_writer :customer_id
+
+            # The requesting device class: mobile, tablet, desktop or unknown. Derived from
+            # the user agent.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :device
+
+            # What the link points at: url for a destination the customer supplied, file for
+            # media Sent hosts. Always present, and implied by the event — link.clicked is
+            # always url and link.downloaded always file — but published as its own field so a
+            # subscriber can branch on the kind without parsing the event name, the same
+            # separation the channel family keeps between its event and its status.
+            sig { returns(T.nilable(String)) }
+            attr_reader :link_kind
+
+            sig { params(link_kind: String).void }
+            attr_writer :link_kind
+
+            # The message the link was published in.
+            #
+            # The event can arrive before the message is readable through GET /v3/messages: a
+            # provider may fetch a link within milliseconds of the send, and nothing here
+            # waits for the message row. Retry the read rather than treating an unknown id as
+            # an error.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :message_id
+
+            # When the access or lifecycle change actually happened, in UTC
+            # (yyyy-MM-ddTHH:mm:ssZ). The envelope's timestamp is when Sent emitted the event;
+            # this is when the thing occurred, and the two differ by the ingest delay.
+            sig { returns(T.nilable(String)) }
+            attr_reader :occurred_at
+
+            sig { params(occurred_at: String).void }
+            attr_writer :occurred_at
+
+            # The caller-supplied label tying this link back to a position in the message, for
+            # example body:0 for the first link in the body. Present when the link was created
+            # with one.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :reference_key
+
+            # The host of the page that linked here, when the request supplied one. The host
+            # only — never a full referring URL.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :referrer_host
+
+            # The HTTP method of the request that was served, for an access event. Omitted on
+            # link.expired and link.revoked, which describe no request.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :request_method
+
+            # The sender profile that owns the link, or null when the organization owns it
+            # directly. Always on the wire so a handler reads one shape rather than branching
+            # on whether the key arrived.
+            #
+            # sender_profile_id, not profile_id: the API already publishes
+            # messaging_profile_id and sending_phone_number_profile_id for provider-side
+            # profiles, which are a different thing entirely. The unqualified name would read
+            # as one of those.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :sender_profile_id
+
+            # The HTTP status Sent answered the request with: 302 for a link, 200 or 206 for a
+            # file. Omitted on lifecycle events.
+            sig { returns(T.nilable(Integer)) }
+            attr_accessor :status_code
+
+            # A coarse guess at what made the request: likely_human, provider (a messaging
+            # platform prefetching the link), bot, or unknown. Derived from the user agent, so
+            # it is a hint for filtering noise rather than a fact to bill or report on.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :traffic_class
+
+            # Body of a link event: something happened to a tracked link Sent published on the
+            # customer's behalf. A link points either at a URL the customer supplied or at a
+            # file Sent hosts for them; LinkKind says which. Delivered when an eligible
+            # request is served, or when a published link reaches the end of its life.
+            #
+            # A click is a request, not a read receipt. link.clicked means the redirect was
+            # served; link.downloaded means bytes went out. Neither proves a person saw
+            # anything — messaging providers and link scanners fetch URLs on their own, which
+            # is what TrafficClass exists to tell apart. Filter on it before reporting a
+            # click-through rate; treat likely_human as a hint, never as delivery
+            # confirmation.
+            #
+            # RecordId identifies the link; the X-Webhook-Event-ID header identifies the
+            # delivery. One link is hit many times, so those are the two keys a subscriber
+            # needs: group by the first, deduplicate on the second — exactly as on every other
+            # family. The payload carries no event identifier of its own, for the same reason
+            # none of the others do.
+            #
+            # Nothing here identifies the visitor. No IP address and no visitor token crosses
+            # this boundary. Country, Device and Browser are coarse buckets derived at the
+            # edge and are absent whenever the request did not supply enough to derive them.
+            sig do
+              params(
+                record_id: String,
+                access_country: T.nilable(String),
+                access_outcome: T.nilable(String),
+                browser: T.nilable(String),
+                bytes_served: T.nilable(Integer),
+                channel: T.nilable(String),
+                customer_id: String,
+                device: T.nilable(String),
+                link_kind: String,
+                message_id: T.nilable(String),
+                occurred_at: String,
+                reference_key: T.nilable(String),
+                referrer_host: T.nilable(String),
+                request_method: T.nilable(String),
+                sender_profile_id: T.nilable(String),
+                status_code: T.nilable(Integer),
+                traffic_class: T.nilable(String)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # The link's public identifier — the eight-character code in the short URL, for
+              # example A78B2BU0. Unique across both kinds, and never reused, so it is the
+              # stable key to group one link's events by.
+              record_id:,
+              # Where the request appeared to come from, as an ISO 3166-1 alpha-2 code. Named
+              # separately from the country on a channel event, which is a destination market
+              # the customer registered for — this one is a property of a single visitor and is
+              # absent when the edge could not resolve it.
+              access_country: nil,
+              # How the request was served, when the edge recorded it. Free text describing the
+              # outcome — show it to a human rather than branching on it.
+              access_outcome: nil,
+              # The requesting browser family, for example chrome or safari, or unknown. Derived
+              # from the user agent.
+              browser: nil,
+              # How many bytes were served, for a file access. A ranged request reports the
+              # bytes in that range, not the size of the file, so several accesses of one file
+              # can each report a part.
+              bytes_served: nil,
+              # The channel the message carrying this link went out on: sms, whatsapp, or rcs.
+              channel: nil,
+              # The organization the link belongs to. Always the parent account, never a sender
+              # profile — read SenderProfileId for that.
+              #
+              # This family publishes the owner as an explicit pair rather than the single
+              # account_id the other families use. The pair says which organization and which
+              # profile without the subscriber deriving either, which is the trade: one more key
+              # against not having to know that account_id silently becomes the profile when one
+              # exists.
+              customer_id: nil,
+              # The requesting device class: mobile, tablet, desktop or unknown. Derived from
+              # the user agent.
+              device: nil,
+              # What the link points at: url for a destination the customer supplied, file for
+              # media Sent hosts. Always present, and implied by the event — link.clicked is
+              # always url and link.downloaded always file — but published as its own field so a
+              # subscriber can branch on the kind without parsing the event name, the same
+              # separation the channel family keeps between its event and its status.
+              link_kind: nil,
+              # The message the link was published in.
+              #
+              # The event can arrive before the message is readable through GET /v3/messages: a
+              # provider may fetch a link within milliseconds of the send, and nothing here
+              # waits for the message row. Retry the read rather than treating an unknown id as
+              # an error.
+              message_id: nil,
+              # When the access or lifecycle change actually happened, in UTC
+              # (yyyy-MM-ddTHH:mm:ssZ). The envelope's timestamp is when Sent emitted the event;
+              # this is when the thing occurred, and the two differ by the ingest delay.
+              occurred_at: nil,
+              # The caller-supplied label tying this link back to a position in the message, for
+              # example body:0 for the first link in the body. Present when the link was created
+              # with one.
+              reference_key: nil,
+              # The host of the page that linked here, when the request supplied one. The host
+              # only — never a full referring URL.
+              referrer_host: nil,
+              # The HTTP method of the request that was served, for an access event. Omitted on
+              # link.expired and link.revoked, which describe no request.
+              request_method: nil,
+              # The sender profile that owns the link, or null when the organization owns it
+              # directly. Always on the wire so a handler reads one shape rather than branching
+              # on whether the key arrived.
+              #
+              # sender_profile_id, not profile_id: the API already publishes
+              # messaging_profile_id and sending_phone_number_profile_id for provider-side
+              # profiles, which are a different thing entirely. The unqualified name would read
+              # as one of those.
+              sender_profile_id: nil,
+              # The HTTP status Sent answered the request with: 302 for a link, 200 or 206 for a
+              # file. Omitted on lifecycle events.
+              status_code: nil,
+              # A coarse guess at what made the request: likely_human, provider (a messaging
+              # platform prefetching the link), bot, or unknown. Derived from the user agent, so
+              # it is a hint for filtering noise rather than a fact to bill or report on.
+              traffic_class: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  record_id: String,
+                  access_country: T.nilable(String),
+                  access_outcome: T.nilable(String),
+                  browser: T.nilable(String),
+                  bytes_served: T.nilable(Integer),
+                  channel: T.nilable(String),
+                  customer_id: String,
+                  device: T.nilable(String),
+                  link_kind: String,
+                  message_id: T.nilable(String),
+                  occurred_at: String,
+                  reference_key: T.nilable(String),
+                  referrer_host: T.nilable(String),
+                  request_method: T.nilable(String),
+                  sender_profile_id: T.nilable(String),
+                  status_code: T.nilable(Integer),
+                  traffic_class: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+          end
+        end
+
         sig do
           override.returns(
             T::Array[

data/rbi/sentdm/models.rbi

@@ -31,10 +31,18 @@ module Sentdm
 
   BrandsBrandData = Sentdm::Models::BrandsBrandData
 
+  ChannelEvent = Sentdm::Models::ChannelEvent
+
+  ChannelEventPayload = Sentdm::Models::ChannelEventPayload
+
   ContactCreateParams = Sentdm::Models::ContactCreateParams
 
   ContactDeleteParams = Sentdm::Models::ContactDeleteParams
 
+  ContactEvent = Sentdm::Models::ContactEvent
+
+  ContactEventPayload = Sentdm::Models::ContactEventPayload
+
   ContactListParams = Sentdm::Models::ContactListParams
 
   ContactMessageSummary = Sentdm::Models::ContactMessageSummary

data/rbi/sentdm/resources/messages.rbi

@@ -13,9 +13,17 @@ module Sentdm
     # **A message needs a sender.** What you can send, where, and at what cost is
     # decided by the markets under **Channels** — so a recipient in a country you hold
     # no sender for is refused here rather than queued.
+    #
+    # **A message can be resent on its id.** `POST /v3/messages/{id}/resend` puts a
+    # finished message — typically one BLOCKED for insufficient balance — back through
+    # the send pipeline. It is a new attempt, not a free retry: every policy runs
+    # again, the message is billed again, and its status webhooks fire again. A
+    # FILTERED message is never resendable.
     class Messages
       # Retrieves the activity log for a specific message. Activities track the message
-      # lifecycle including acceptance, processing, sending, delivery, and any errors.
+      # lifecycle including acceptance, processing, sending, delivery, and any errors. A
+      # SCHEDULED entry carries scheduled_at, the release instant in UTC as it stood at
+      # that moment. Other entries have no scheduled_at key.
       sig do
         params(
           id: String,
@@ -34,7 +42,11 @@ module Sentdm
       end
 
       # Retrieves the current status and details of a message by ID. Includes delivery
-      # status, timestamps, and error information if applicable.
+      # status, timestamps, and error information if applicable. A message that is or
+      # was held for a later time (a send you scheduled with scheduled_at, or a
+      # quiet-hours hold) is returned as a ScheduledMessageResponse: the same fields
+      # plus scheduled_at, the release instant in UTC. A message sent immediately has no
+      # scheduled_at key.
       sig do
         params(
           id: String,
@@ -61,11 +73,24 @@ module Sentdm
       # insufficient balance, a template not approved for sending, or free-form content
       # with no open conversation with the contact. The send is accepted with 202 and
       # the affected messages are reported as BLOCKED on GET /messages/{id} and the
-      # message.blocked webhook.
+      # message.blocked webhook. To send later, set scheduled_at (ISO-8601 with an
+      # explicit UTC offset; a value without one is rejected) between 1 minute and 30
+      # days ahead: the response is a ScheduledSendMessageResponse (the same fields plus
+      # scheduled_at; status is still QUEUED), each message then moves to SCHEDULED, is
+      # held and released at that time (within a few minutes), and a message.scheduled
+      # webhook fires once it is held. Balance and template approval are evaluated at
+      # release, not at acceptance. Quiet hours are not checked when the request is
+      # accepted: if the time falls inside a legally protected quiet-hours window for a
+      # recipient, that message is moved to the next allowed time at release and a
+      # second message.scheduled webhook reports the new scheduled_at. An account may
+      # hold at most 1,000,000 scheduled messages at once (429 LIMIT_001).
       sig do
         params(
           channel: T.nilable(T::Array[String]),
+          media_urls: T.nilable(T::Array[String]),
           sandbox: T::Boolean,
+          scheduled_at: T.nilable(Time),
+          subject: T.nilable(String),
           template: T.nilable(Sentdm::MessageSendParams::Template::OrHash),
           text: T.nilable(String),
           to: T::Array[String],
@@ -79,9 +104,39 @@ module Sentdm
         # produces a separate message per recipient. "sent" = auto-detect. Defaults to
         # ["sent"] (auto-detect) if omitted.
         channel: nil,
+        # Body param: Attachments for this send, as publicly fetchable https URLs. Used by
+        # the MMS channel and ignored by every other one.
+        #
+        # Supplying these replaces the media on the template's mms body rather than adding
+        # to it, so a template can hold a default creative while a caller still sends
+        # something recipient-specific.
+        #
+        # Their presence is also what makes a message eligible for MMS on an auto-detect
+        # send: a message with nothing attached is delivered as SMS, because an MMS with
+        # no media is a more expensive text message.
+        #
+        # The recipient's carrier fetches each URL after the send is accepted, so it must
+        # stay publicly reachable — a link that expires, or one behind auth, arrives as a
+        # failed message.
+        media_urls: nil,
         # Body param: Sandbox flag - when true, the operation is simulated without side
         # effects Useful for testing integrations without actual execution
         sandbox: nil,
+        # Body param: Optional future send time as an ISO-8601 timestamp with an explicit
+        # UTC offset, e.g. 2026-10-01T09:00:00+02:00 or 2026-10-01T07:00:00Z. A value
+        # without an offset is rejected (400) rather than read in the server's zone. The
+        # offset only fixes the instant: it is stored and echoed in UTC as scheduled_at.
+        # Omit to send now. Must be at least one minute ahead and at most 30 days ahead.
+        # Accepted messages report SCHEDULED and are released for delivery at this time.
+        # Quiet hours, balance and template approval are evaluated at release, not at
+        # acceptance: a message whose time falls inside a recipient's protected
+        # quiet-hours window is moved to the next allowed time and a second
+        # message.scheduled webhook reports the new scheduled_at.
+        scheduled_at: nil,
+        # Body param: Subject line for this send, overriding the template's. MMS only;
+        # ignored on every other channel. Most handsets render it above the body, some
+        # ignore it entirely.
+        subject: nil,
         # Body param: SDK-style template reference: resolve by ID or by name, with
         # optional parameters.
         template: nil,