sentdm 0.35.0 → 0.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb2a3192ac350b8b789c39c41c5c98b4dcd1df0b714d0d3f0540e88205a0b57d
-  data.tar.gz: 5d97dab3605f998f583ea137599413f498de456598e57d257591df8afb173e14
+  metadata.gz: d680fc6fd1a90e7cfbb949b51b2318a9a5be626e7f5629eac8e94aa891efb518
+  data.tar.gz: 51a7542758dea2afa3873d000f47d003c4212ad54808c9a1ee6b97551f14a93d
 SHA512:
-  metadata.gz: 65df0bbbe671b490469b171d4b241b1d4fc5d088b271390c3a727227f046fddb138c61be3bee853f2a8b26a8e910aae0a41c0f0b46ef01ffedee44e5fc1002b6
-  data.tar.gz: 0fc42b03c73246deaf5cb6711e0431a4469b6eb172c6d1a3cf2a8d7f63621aa4cda7708d7054d61afa042d571d07377b9e1b94437cc2e65aed7099a16eadd77c
+  metadata.gz: 1fd26499de108ec871956cbc8f6219506a2c08cb6ce1f9aa105c2509518faf6b99eda7cfd5dda5781f2b584fbbeca3618692667ac6fe46b1cc2a4e033114f6ee
+  data.tar.gz: 3bf07498b8d470a63f9f543b4bf0e68b88141ae345c7a7700994fb6beaf89731a01a0ddc41198275d0d64f1e8ffa8026487b14c74a6e9f9194c4b3659462223d

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.37.0](https://github.com/sentdm/sent-dm-ruby/compare/v0.36.0...v0.37.0) (2026-10-09)
+
+
+### Features
+
+* **api:** sync generated SDKs from the committed spec ([c38a90b](https://github.com/sentdm/sent-dm-ruby/commit/c38a90bc1459c97d364720a4d37db3a30f5ea396))
+* **api:** sync OpenAPI spec from production ([6697158](https://github.com/sentdm/sent-dm-ruby/commit/66971588cd75f6b148a1e63e9c43f6d54abb0680))
+
+## [0.36.0](https://github.com/sentdm/sent-dm-ruby/compare/v0.35.0...v0.36.0) (2026-10-06)
+
+
+### Features
+
+* **api:** sync generated SDKs from the committed spec ([fc29692](https://github.com/sentdm/sent-dm-ruby/commit/fc29692de765a72b716a46c4920c603e2b617a95))
+* **api:** sync OpenAPI spec from production ([989362a](https://github.com/sentdm/sent-dm-ruby/commit/989362a3142f3d926e68793f163d21e85d3cf346))
+
 ## [0.35.0](https://github.com/sentdm/sent-dm-ruby/compare/v0.34.0...v0.35.0) (2026-10-01)
 
 

data/README.md

@@ -17,7 +17,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "sentdm", "~> 0.35.0"
+gem "sentdm", "~> 0.37.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/sentdm/client.rb

@@ -89,6 +89,11 @@ module Sentdm
     # 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.
+    #
+    # **A scheduled message can be called off.** `POST /v3/messages/{id}/cancel`
+    # cancels a send you scheduled with `scheduled_at`, as long as it has not been
+    # released yet. Cancelling is free, fires `message.cancelled`, and is final — a
+    # cancelled message cannot be resent.
     # @return [Sentdm::Resources::Messages]
     attr_reader :messages
 

data/lib/sentdm/models/call.rb

@@ -39,8 +39,9 @@ module Sentdm
 
       # @!attribute failure_reason
       #   Why the call did not complete: callback_timeout, invalid_answer,
-      #   insufficient_balance, destination_blocked, rejected or no_answer. Null while the
-      #   call is live, when it completed, and when it failed without a recorded reason
+      #   insufficient_balance, destination_blocked, callback_not_configured, rejected or
+      #   no_answer. Null while the call is live, when it completed, and when it failed
+      #   without a recorded reason
       #
       #   @return [String, nil]
       optional :failure_reason, String, nil?: true
@@ -77,7 +78,7 @@ module Sentdm
       optional :started_at, Time
 
       # @!attribute status
-      #   initiated, ringing, answered, completed, failed, no_answer or rejected
+      #   INITIATED, RINGING, ANSWERED, COMPLETED, FAILED, NO_ANSWER or REJECTED
       #
       #   @return [String, nil]
       optional :status, String
@@ -123,7 +124,7 @@ module Sentdm
       #
       #   @param started_at [Time] When the call was placed (UTC)
       #
-      #   @param status [String] initiated, ringing, answered, completed, failed, no_answer or rejected
+      #   @param status [String] INITIATED, RINGING, ANSWERED, COMPLETED, FAILED, NO_ANSWER or REJECTED
       #
       #   @param timeline [Array<Sentdm::Models::CallTimelineEntry>, nil] When the call entered each status, oldest first. Only returned when reading one
       #

data/lib/sentdm/models/call_timeline_entry.rb

@@ -4,7 +4,7 @@ module Sentdm
   module Models
     class CallTimelineEntry < Sentdm::Internal::Type::BaseModel
       # @!attribute status
-      #   initiated, ringing, answered, completed, failed, no_answer or rejected
+      #   INITIATED, RINGING, ANSWERED, COMPLETED, FAILED, NO_ANSWER or REJECTED
       #
       #   @return [String, nil]
       optional :status, String
@@ -18,7 +18,7 @@ module Sentdm
       # @!method initialize(status: nil, timestamp: nil)
       #   When a call entered a status
       #
-      #   @param status [String] initiated, ringing, answered, completed, failed, no_answer or rejected
+      #   @param status [String] INITIATED, RINGING, ANSWERED, COMPLETED, FAILED, NO_ANSWER or REJECTED
       #
       #   @param timestamp [Time] When the call entered this status (UTC)
     end

data/lib/sentdm/models/message_event_payload.rb

@@ -72,14 +72,19 @@ module Sentdm
       # @!attribute schedule_reason
       #   message.scheduled only: why the message is held, either because you scheduled it
       #   or because the recipient is inside a protected quiet-hours window. Omitted on
-      #   every other event.
+      #   every other event, including message.cancelled — that is a property of the hold,
+      #   not of the cancellation, and repeating it there would read as "why was this
+      #   cancelled", which it does not answer.
       #
       #   @return [String, nil]
       optional :schedule_reason, String, nil?: true
 
       # @!attribute scheduled_at
-      #   message.scheduled only: when the held message will be released for delivery, in
-      #   UTC (yyyy-MM-ddTHH:mm:ssZ). Omitted on every other event.
+      #   message.scheduled and message.cancelled only, in UTC (yyyy-MM-ddTHH:mm:ssZ): on
+      #   message.scheduled it is when the held message will be released for delivery, on
+      #   message.cancelled the release instant that was called off — the same instant,
+      #   before and after. A consumer that recorded a future send from the first event
+      #   has what it needs to un-record it from the second. Omitted on every other event.
       #
       #   @return [String, nil]
       optional :scheduled_at, String, nil?: true
@@ -131,7 +136,7 @@ module Sentdm
       #
       #   @param schedule_reason [String, nil] message.scheduled only: why the message is held, either because you scheduled it
       #
-      #   @param scheduled_at [String, nil] message.scheduled only: when the held message will be released for delivery, in
+      #   @param scheduled_at [String, nil] message.scheduled and message.cancelled only, in UTC (yyyy-MM-ddTHH:mm:ssZ): on
       #
       #   @param template_id [String, nil] The template the message was sent from, when it was sent from one.
       #

data/lib/sentdm/models/message_retrieve_activities_response.rb

@@ -116,10 +116,12 @@ module Sentdm
           optional :reason_code, String, nil?: true
 
           # @!attribute scheduled_at
-          #   SCHEDULED activities only: when the held message will be released for delivery,
-          #   in UTC. Same wire name as on the send response, the message and the webhook.
-          #   Omitted on every other activity. A message that quiet hours moved at release has
-          #   two SCHEDULED entries, each carrying the instant as it stood at that moment.
+          #   SCHEDULED and CANCELLED activities only, in UTC: on a SCHEDULED entry, when the
+          #   held message will be released for delivery; on a CANCELLED entry, the instant
+          #   that was called off. Same wire name as on the send response, the message and the
+          #   webhook. Omitted on every other activity. A message that quiet hours moved at
+          #   release has two SCHEDULED entries, each carrying the instant as it stood at that
+          #   moment.
           #
           #   @return [Time, nil]
           optional :scheduled_at, Time, nil?: true
@@ -161,7 +163,7 @@ module Sentdm
           #   @param reason_code [String, nil] Why the message reached this status, as a stable platform code such as
           #   DELIVERY\_
           #
-          #   @param scheduled_at [Time, nil] SCHEDULED activities only: when the held message will be released for delivery,
+          #   @param scheduled_at [Time, nil] SCHEDULED and CANCELLED activities only, in UTC: on a SCHEDULED entry, when the
           #
           #   @param status [String] Activity status. Outbound: QUEUED, PROCESSED, ROUTED, SCHEDULED, SENT, DELIVERED
           #

data/lib/sentdm/models/message_send_params.rb

@@ -15,6 +15,33 @@ module Sentdm
       #   @return [Array<String>, nil]
       optional :channel, Sentdm::Internal::Type::ArrayOf[String], nil?: true
 
+      # @!attribute channels
+      #   Which of your own numbers to send from, keyed by channel, each channel holding a
+      #   list of entries: {"sms": [{"country": "US", "from": ["+12125550000",
+      #   "+14155550000"]}, {"from": ["+447700800001"]}]}. Any real channel may be a key;
+      #   sent, which is auto-detect rather than a channel, is rejected. country and
+      #   strategy are accepted and stored but not acted on yet: every entry's numbers
+      #   apply to every recipient on that channel.
+      #
+      #   This does not choose channels — Channel does, and the two combine: "channel":
+      #   ["sms"] with an sms list sends on SMS from those numbers. Each list only narrows
+      #   which of its own channel's routes may win, so with Channel left at auto-detect a
+      #   recipient best served by a channel with no list still goes out on it. Routing
+      #   itself is unchanged: the same rules are scored and ranked the same way, with
+      #   routes pinned to numbers you did not list removed from the running.
+      #
+      #   Every number must be an active sender on your account. The request itself is
+      #   still accepted (202) if one is not — like every other send-time rule, that is
+      #   decided per message, so each affected message is recorded BLOCKED with error
+      #   code BUSINESS_029 and reported on GET /v3/messages and the status webhook.
+      #
+      #   @return [Hash{Symbol=>Array<Sentdm::Models::MessageSendParams::Channel>}, nil]
+      optional :channels,
+               -> {
+                 Sentdm::Internal::Type::HashOf[Sentdm::Internal::Type::ArrayOf[Sentdm::MessageSendParams::Channel]]
+               },
+               nil?: true
+
       # @!attribute media_urls
       #   Attachments for this send, as publicly fetchable https URLs. Used by the MMS
       #   channel and ignored by every other one.
@@ -93,12 +120,14 @@ module Sentdm
       #   @return [String, nil]
       optional :x_profile_id, String
 
-      # @!method initialize(channel: nil, media_urls: nil, sandbox: nil, scheduled_at: nil, subject: nil, template: nil, text: nil, to: nil, idempotency_key: nil, x_profile_id: nil, request_options: {})
+      # @!method initialize(channel: nil, channels: nil, media_urls: nil, sandbox: nil, scheduled_at: nil, subject: nil, template: nil, text: nil, to: nil, idempotency_key: nil, x_profile_id: nil, request_options: {})
       #   Some parameter documentations has been truncated, see
       #   {Sentdm::Models::MessageSendParams} for more details.
       #
       #   @param channel [Array<String>, nil] Channels to broadcast on, e.g. ["whatsapp", "sms"].
       #
+      #   @param channels [Hash{Symbol=>Array<Sentdm::Models::MessageSendParams::Channel>}, nil] Which of your own numbers to send from, keyed by channel, each channel holding a
+      #
       #   @param media_urls [Array<String>, nil] Attachments for this send, as publicly fetchable https URLs. Used by the MMS cha
       #
       #   @param sandbox [Boolean] Sandbox flag - when true, the operation is simulated without side effects
@@ -119,6 +148,44 @@ module Sentdm
       #
       #   @param request_options [Sentdm::RequestOptions, Hash{Symbol=>Object}]
 
+      class Channel < Sentdm::Internal::Type::BaseModel
+        # @!attribute country
+        #   Recipient country this entry is meant for (ISO 3166-1 alpha-2, e.g. US).
+        #   Optional. Accepted and stored, not acted on yet.
+        #
+        #   @return [String, nil]
+        optional :country, String, nil?: true
+
+        # @!attribute from
+        #   Sender numbers in E.164. Each must be an active sender on your account for this
+        #   channel. That is account state rather than request shape, so it is decided per
+        #   message: the request is accepted with 202 and a message naming an unusable
+        #   number is recorded BLOCKED with error code BUSINESS_029.
+        #
+        #   @return [Array<String>, nil]
+        optional :from, Sentdm::Internal::Type::ArrayOf[String], nil?: true
+
+        # @!attribute strategy
+        #   How to pick a number from From, e.g. sticky or geo. Optional. Accepted and
+        #   stored, not acted on yet.
+        #
+        #   @return [String, nil]
+        optional :strategy, String, nil?: true
+
+        # @!method initialize(country: nil, from: nil, strategy: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {Sentdm::Models::MessageSendParams::Channel} for more details.
+        #
+        #   One entry of a channel's list in Channels, e.g. {"country": "US", "from":
+        #   ["+15559990002", "+15559990003"], "strategy": "sticky"}.
+        #
+        #   @param country [String, nil] Recipient country this entry is meant for (ISO 3166-1 alpha-2, e.g. US). Optiona
+        #
+        #   @param from [Array<String>, nil] Sender numbers in E.164. Each must be an active sender on your account for this
+        #
+        #   @param strategy [String, nil] How to pick a number from From, e.g. sticky or geo. Optional. Accepted
+      end
+
       class Template < Sentdm::Internal::Type::BaseModel
         # @!attribute id
         #   Template ID (mutually exclusive with name)

data/lib/sentdm/resources/calls/participants.rb

@@ -106,11 +106,11 @@ module Sentdm
         # conference room, and answers with the participant's own call record. The
         # participant is a call of their own: it has its own id, can be looked up and hung
         # up, and is billed and reported through call.completed and call.failed like any
-        # other call. A phone participant is called from caller_id, which must be one of
-        # your numbers, or from the call's owning number when omitted, and needs a
-        # destination you may call and a positive balance. Only a call your answer
-        # connected to a conference can take participants: a call connected to a user or a
-        # number answers 409.
+        # other call. Every participant needs a positive balance. A phone participant is
+        # called from caller_id, which must be one of your numbers, or from the call's
+        # owning number when omitted, and needs a destination you may call. Only a call
+        # your answer connected to a conference can take participants: a call connected to
+        # a user or a number answers 409.
         #
         # @overload add(id, caller_id: nil, sandbox: nil, to: nil, idempotency_key: nil, x_profile_id: nil, request_options: {})
         #

data/lib/sentdm/resources/calls.rb

@@ -118,10 +118,11 @@ module Sentdm
       # Some parameter documentations has been truncated, see
       # {Sentdm::Models::CallHangupParams} for more details.
       #
-      # Ends one of your live calls. The call then ends the way any other call does: its
-      # status moves to completed and call.completed is sent once the disconnect is
-      # reported. A call that has already ended answers 409, and so does a call with no
-      # phone leg, such as one between two app users.
+      # Ends one of your live calls. The call then ends the way any other call does once
+      # the disconnect is reported: an answered call as COMPLETED with call.completed, a
+      # call still ringing as NO_ANSWER, REJECTED or FAILED with call.failed. A call
+      # that has already ended answers 409, and so does a call with no phone leg, such
+      # as one between two app users.
       #
       # @overload hangup(id, sandbox: nil, idempotency_key: nil, x_profile_id: nil, request_options: {})
       #

data/lib/sentdm/resources/messages.rb

@@ -19,6 +19,11 @@ module Sentdm
     # 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.
+    #
+    # **A scheduled message can be called off.** `POST /v3/messages/{id}/cancel`
+    # cancels a send you scheduled with `scheduled_at`, as long as it has not been
+    # released yet. Cancelling is free, fires `message.cancelled`, and is final — a
+    # cancelled message cannot be resent.
     class Messages
       # Some parameter documentations has been truncated, see
       # {Sentdm::Models::MessageRetrieveActivitiesParams} for more details.
@@ -55,10 +60,11 @@ module Sentdm
       #
       # Retrieves the current status and details of a message by ID. Includes delivery
       # 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.
+      # was held for a later time (a send you scheduled with scheduled_at, a quiet-hours
+      # hold, or a message you cancelled while it was held) is returned as a
+      # ScheduledMessageResponse: the same fields plus scheduled_at, the instant it is
+      # held for in UTC — or, on a CANCELLED message, the instant that was called off. A
+      # message sent immediately has no scheduled_at key.
       #
       # @overload retrieve_status(id, x_profile_id: nil, request_options: {})
       #
@@ -88,13 +94,27 @@ module Sentdm
       # Sends a message to one or more recipients using a template. Supports
       # multi-channel broadcast — when multiple channels are specified (e.g. ["sms",
       # "whatsapp"]), a separate message is created for each (recipient, channel) pair.
-      # Returns immediately with per-recipient message IDs for async tracking via
-      # webhooks or the GET /messages/{id} endpoint. Sends gated before any delivery
-      # attempt do not reject the request — an account-level precondition such as
-      # 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. To send later, set scheduled_at (ISO-8601 with an
+      # To choose which of your own numbers a send goes out from, use 'channels':
+      # {"sms": [{"from": ["+12125550000", "+14155550000"]}]}. Each channel holds a list
+      # of entries, each with 'from' and optionally 'country' and 'strategy'; 'country'
+      # and 'strategy' are stored but not acted on yet, so every entry's numbers apply
+      # to every recipient on that channel. Every number listed must be an active sender
+      # on your account. Like the other account-level preconditions below, that is
+      # checked per message rather than when the request is received: the request is
+      # still accepted with 202, and each affected message is reported as BLOCKED with
+      # error code BUSINESS_029 on GET /messages/{id} and the message.blocked webhook.
+      # Each channel's numbers restrict which numbers that channel may use; it does not
+      # choose channels — 'channel' does, and the two can be combined. With 'channel'
+      # left at auto-detect, a recipient best served by a channel you listed no numbers
+      # for still goes out on it. Where several of the listed numbers could serve a
+      # recipient, routing prefers the one whose area code matches theirs. Keys: sms,
+      # whatsapp, rcs, mms. Returns immediately with per-recipient message IDs for async
+      # tracking via webhooks or the GET /messages/{id} endpoint. Sends gated before any
+      # delivery attempt do not reject the request — an account-level precondition such
+      # as 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. 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
@@ -106,10 +126,12 @@ module Sentdm
       # 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).
       #
-      # @overload send_(channel: nil, media_urls: nil, sandbox: nil, scheduled_at: nil, subject: nil, template: nil, text: nil, to: nil, idempotency_key: nil, x_profile_id: nil, request_options: {})
+      # @overload send_(channel: nil, channels: nil, media_urls: nil, sandbox: nil, scheduled_at: nil, subject: nil, template: nil, text: nil, to: nil, idempotency_key: nil, x_profile_id: nil, request_options: {})
       #
       # @param channel [Array<String>, nil] Body param: Channels to broadcast on, e.g. ["whatsapp", "sms"].
       #
+      # @param channels [Hash{Symbol=>Array<Sentdm::Models::MessageSendParams::Channel>}, nil] Body param: Which of your own numbers to send from, keyed by channel, each chann
+      #
       # @param media_urls [Array<String>, nil] Body param: Attachments for this send, as publicly fetchable https URLs. Used by
       #
       # @param sandbox [Boolean] Body param: Sandbox flag - when true, the operation is simulated without side ef

data/lib/sentdm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentdm
-  VERSION = "0.35.0"
+  VERSION = "0.37.0"
 end

data/rbi/sentdm/client.rbi

@@ -84,6 +84,11 @@ module Sentdm
     # 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.
+    #
+    # **A scheduled message can be called off.** `POST /v3/messages/{id}/cancel`
+    # cancels a send you scheduled with `scheduled_at`, as long as it has not been
+    # released yet. Cancelling is free, fires `message.cancelled`, and is final — a
+    # cancelled message cannot be resent.
     sig { returns(Sentdm::Resources::Messages) }
     attr_reader :messages
 

data/rbi/sentdm/models/call.rbi

@@ -35,8 +35,9 @@ module Sentdm
       attr_accessor :ended_at
 
       # Why the call did not complete: callback_timeout, invalid_answer,
-      # insufficient_balance, destination_blocked, rejected or no_answer. Null while the
-      # call is live, when it completed, and when it failed without a recorded reason
+      # insufficient_balance, destination_blocked, callback_not_configured, rejected or
+      # no_answer. Null while the call is live, when it completed, and when it failed
+      # without a recorded reason
       sig { returns(T.nilable(String)) }
       attr_accessor :failure_reason
 
@@ -73,7 +74,7 @@ module Sentdm
       sig { params(started_at: Time).void }
       attr_writer :started_at
 
-      # initiated, ringing, answered, completed, failed, no_answer or rejected
+      # INITIATED, RINGING, ANSWERED, COMPLETED, FAILED, NO_ANSWER or REJECTED
       sig { returns(T.nilable(String)) }
       attr_reader :status
 
@@ -126,8 +127,9 @@ module Sentdm
         # When the call ended (UTC). Null while the call is live
         ended_at: nil,
         # Why the call did not complete: callback_timeout, invalid_answer,
-        # insufficient_balance, destination_blocked, rejected or no_answer. Null while the
-        # call is live, when it completed, and when it failed without a recorded reason
+        # insufficient_balance, destination_blocked, callback_not_configured, rejected or
+        # no_answer. Null while the call is live, when it completed, and when it failed
+        # without a recorded reason
         failure_reason: nil,
         # One end of a call
         from: nil,
@@ -140,7 +142,7 @@ module Sentdm
         recording_available: nil,
         # When the call was placed (UTC)
         started_at: nil,
-        # initiated, ringing, answered, completed, failed, no_answer or rejected
+        # INITIATED, RINGING, ANSWERED, COMPLETED, FAILED, NO_ANSWER or REJECTED
         status: nil,
         # When the call entered each status, oldest first. Only returned when reading one
         # call

data/rbi/sentdm/models/call_timeline_entry.rbi

@@ -8,7 +8,7 @@ module Sentdm
           T.any(Sentdm::CallTimelineEntry, Sentdm::Internal::AnyHash)
         end
 
-      # initiated, ringing, answered, completed, failed, no_answer or rejected
+      # INITIATED, RINGING, ANSWERED, COMPLETED, FAILED, NO_ANSWER or REJECTED
       sig { returns(T.nilable(String)) }
       attr_reader :status
 
@@ -25,7 +25,7 @@ module Sentdm
       # When a call entered a status
       sig { params(status: String, timestamp: Time).returns(T.attached_class) }
       def self.new(
-        # initiated, ringing, answered, completed, failed, no_answer or rejected
+        # INITIATED, RINGING, ANSWERED, COMPLETED, FAILED, NO_ANSWER or REJECTED
         status: nil,
         # When the call entered this status (UTC)
         timestamp: nil

data/rbi/sentdm/models/message_event_payload.rbi

@@ -70,12 +70,17 @@ module Sentdm
 
       # message.scheduled only: why the message is held, either because you scheduled it
       # or because the recipient is inside a protected quiet-hours window. Omitted on
-      # every other event.
+      # every other event, including message.cancelled — that is a property of the hold,
+      # not of the cancellation, and repeating it there would read as "why was this
+      # cancelled", which it does not answer.
       sig { returns(T.nilable(String)) }
       attr_accessor :schedule_reason
 
-      # message.scheduled only: when the held message will be released for delivery, in
-      # UTC (yyyy-MM-ddTHH:mm:ssZ). Omitted on every other event.
+      # message.scheduled and message.cancelled only, in UTC (yyyy-MM-ddTHH:mm:ssZ): on
+      # message.scheduled it is when the held message will be released for delivery, on
+      # message.cancelled the release instant that was called off — the same instant,
+      # before and after. A consumer that recorded a future send from the first event
+      # has what it needs to un-record it from the second. Omitted on every other event.
       sig { returns(T.nilable(String)) }
       attr_accessor :scheduled_at
 
@@ -149,10 +154,15 @@ module Sentdm
         reason_code: nil,
         # message.scheduled only: why the message is held, either because you scheduled it
         # or because the recipient is inside a protected quiet-hours window. Omitted on
-        # every other event.
+        # every other event, including message.cancelled — that is a property of the hold,
+        # not of the cancellation, and repeating it there would read as "why was this
+        # cancelled", which it does not answer.
         schedule_reason: nil,
-        # message.scheduled only: when the held message will be released for delivery, in
-        # UTC (yyyy-MM-ddTHH:mm:ssZ). Omitted on every other event.
+        # message.scheduled and message.cancelled only, in UTC (yyyy-MM-ddTHH:mm:ssZ): on
+        # message.scheduled it is when the held message will be released for delivery, on
+        # message.cancelled the release instant that was called off — the same instant,
+        # before and after. A consumer that recorded a future send from the first event
+        # has what it needs to un-record it from the second. Omitted on every other event.
         scheduled_at: nil,
         # The template the message was sent from, when it was sent from one.
         template_id: nil,

data/rbi/sentdm/models/message_retrieve_activities_response.rbi

@@ -216,10 +216,12 @@ module Sentdm
           sig { returns(T.nilable(String)) }
           attr_accessor :reason_code
 
-          # SCHEDULED activities only: when the held message will be released for delivery,
-          # in UTC. Same wire name as on the send response, the message and the webhook.
-          # Omitted on every other activity. A message that quiet hours moved at release has
-          # two SCHEDULED entries, each carrying the instant as it stood at that moment.
+          # SCHEDULED and CANCELLED activities only, in UTC: on a SCHEDULED entry, when the
+          # held message will be released for delivery; on a CANCELLED entry, the instant
+          # that was called off. Same wire name as on the send response, the message and the
+          # webhook. Omitted on every other activity. A message that quiet hours moved at
+          # release has two SCHEDULED entries, each carrying the instant as it stood at that
+          # moment.
           sig { returns(T.nilable(Time)) }
           attr_accessor :scheduled_at
 
@@ -278,10 +280,12 @@ module Sentdm
             # rather than on reason: the code is stable, the wording may be improved. Same
             # wire name and vocabulary as on the message and the webhook.
             reason_code: nil,
-            # SCHEDULED activities only: when the held message will be released for delivery,
-            # in UTC. Same wire name as on the send response, the message and the webhook.
-            # Omitted on every other activity. A message that quiet hours moved at release has
-            # two SCHEDULED entries, each carrying the instant as it stood at that moment.
+            # SCHEDULED and CANCELLED activities only, in UTC: on a SCHEDULED entry, when the
+            # held message will be released for delivery; on a CANCELLED entry, the instant
+            # that was called off. Same wire name as on the send response, the message and the
+            # webhook. Omitted on every other activity. A message that quiet hours moved at
+            # release has two SCHEDULED entries, each carrying the instant as it stood at that
+            # moment.
             scheduled_at: nil,
             # Activity status. Outbound: QUEUED, PROCESSED, ROUTED, SCHEDULED, SENT,
             # DELIVERED, READ, FAILED. Inbound (from contact): RECEIVED (terminal).

data/rbi/sentdm/models/message_send_params.rbi

@@ -17,6 +17,33 @@ module Sentdm
       sig { returns(T.nilable(T::Array[String])) }
       attr_accessor :channel
 
+      # Which of your own numbers to send from, keyed by channel, each channel holding a
+      # list of entries: {"sms": [{"country": "US", "from": ["+12125550000",
+      # "+14155550000"]}, {"from": ["+447700800001"]}]}. Any real channel may be a key;
+      # sent, which is auto-detect rather than a channel, is rejected. country and
+      # strategy are accepted and stored but not acted on yet: every entry's numbers
+      # apply to every recipient on that channel.
+      #
+      # This does not choose channels — Channel does, and the two combine: "channel":
+      # ["sms"] with an sms list sends on SMS from those numbers. Each list only narrows
+      # which of its own channel's routes may win, so with Channel left at auto-detect a
+      # recipient best served by a channel with no list still goes out on it. Routing
+      # itself is unchanged: the same rules are scored and ranked the same way, with
+      # routes pinned to numbers you did not list removed from the running.
+      #
+      # Every number must be an active sender on your account. The request itself is
+      # still accepted (202) if one is not — like every other send-time rule, that is
+      # decided per message, so each affected message is recorded BLOCKED with error
+      # code BUSINESS_029 and reported on GET /v3/messages and the status webhook.
+      sig do
+        returns(
+          T.nilable(
+            T::Hash[Symbol, T::Array[Sentdm::MessageSendParams::Channel]]
+          )
+        )
+      end
+      attr_accessor :channels
+
       # Attachments for this send, as publicly fetchable https URLs. Used by the MMS
       # channel and ignored by every other one.
       #
@@ -99,6 +126,13 @@ module Sentdm
       sig do
         params(
           channel: T.nilable(T::Array[String]),
+          channels:
+            T.nilable(
+              T::Hash[
+                Symbol,
+                T::Array[Sentdm::MessageSendParams::Channel::OrHash]
+              ]
+            ),
           media_urls: T.nilable(T::Array[String]),
           sandbox: T::Boolean,
           scheduled_at: T.nilable(Time),
@@ -116,6 +150,25 @@ module Sentdm
         # separate message per recipient. "sent" = auto-detect. Defaults to ["sent"]
         # (auto-detect) if omitted.
         channel: nil,
+        # Which of your own numbers to send from, keyed by channel, each channel holding a
+        # list of entries: {"sms": [{"country": "US", "from": ["+12125550000",
+        # "+14155550000"]}, {"from": ["+447700800001"]}]}. Any real channel may be a key;
+        # sent, which is auto-detect rather than a channel, is rejected. country and
+        # strategy are accepted and stored but not acted on yet: every entry's numbers
+        # apply to every recipient on that channel.
+        #
+        # This does not choose channels — Channel does, and the two combine: "channel":
+        # ["sms"] with an sms list sends on SMS from those numbers. Each list only narrows
+        # which of its own channel's routes may win, so with Channel left at auto-detect a
+        # recipient best served by a channel with no list still goes out on it. Routing
+        # itself is unchanged: the same rules are scored and ranked the same way, with
+        # routes pinned to numbers you did not list removed from the running.
+        #
+        # Every number must be an active sender on your account. The request itself is
+        # still accepted (202) if one is not — like every other send-time rule, that is
+        # decided per message, so each affected message is recorded BLOCKED with error
+        # code BUSINESS_029 and reported on GET /v3/messages and the status webhook.
+        channels: nil,
         # Attachments for this send, as publicly fetchable https URLs. Used by the MMS
         # channel and ignored by every other one.
         #
@@ -166,6 +219,10 @@ module Sentdm
         override.returns(
           {
             channel: T.nilable(T::Array[String]),
+            channels:
+              T.nilable(
+                T::Hash[Symbol, T::Array[Sentdm::MessageSendParams::Channel]]
+              ),
             media_urls: T.nilable(T::Array[String]),
             sandbox: T::Boolean,
             scheduled_at: T.nilable(Time),
@@ -182,6 +239,66 @@ module Sentdm
       def to_hash
       end
 
+      class Channel < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::MessageSendParams::Channel, Sentdm::Internal::AnyHash)
+          end
+
+        # Recipient country this entry is meant for (ISO 3166-1 alpha-2, e.g. US).
+        # Optional. Accepted and stored, not acted on yet.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :country
+
+        # Sender numbers in E.164. Each must be an active sender on your account for this
+        # channel. That is account state rather than request shape, so it is decided per
+        # message: the request is accepted with 202 and a message naming an unusable
+        # number is recorded BLOCKED with error code BUSINESS_029.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :from
+
+        # How to pick a number from From, e.g. sticky or geo. Optional. Accepted and
+        # stored, not acted on yet.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :strategy
+
+        # One entry of a channel's list in Channels, e.g. {"country": "US", "from":
+        # ["+15559990002", "+15559990003"], "strategy": "sticky"}.
+        sig do
+          params(
+            country: T.nilable(String),
+            from: T.nilable(T::Array[String]),
+            strategy: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Recipient country this entry is meant for (ISO 3166-1 alpha-2, e.g. US).
+          # Optional. Accepted and stored, not acted on yet.
+          country: nil,
+          # Sender numbers in E.164. Each must be an active sender on your account for this
+          # channel. That is account state rather than request shape, so it is decided per
+          # message: the request is accepted with 202 and a message naming an unusable
+          # number is recorded BLOCKED with error code BUSINESS_029.
+          from: nil,
+          # How to pick a number from From, e.g. sticky or geo. Optional. Accepted and
+          # stored, not acted on yet.
+          strategy: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              country: T.nilable(String),
+              from: T.nilable(T::Array[String]),
+              strategy: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
       class Template < Sentdm::Internal::Type::BaseModel
         OrHash =
           T.type_alias do

data/rbi/sentdm/resources/calls/participants.rbi

@@ -90,11 +90,11 @@ module Sentdm
         # conference room, and answers with the participant's own call record. The
         # participant is a call of their own: it has its own id, can be looked up and hung
         # up, and is billed and reported through call.completed and call.failed like any
-        # other call. A phone participant is called from caller_id, which must be one of
-        # your numbers, or from the call's owning number when omitted, and needs a
-        # destination you may call and a positive balance. Only a call your answer
-        # connected to a conference can take participants: a call connected to a user or a
-        # number answers 409.
+        # other call. Every participant needs a positive balance. A phone participant is
+        # called from caller_id, which must be one of your numbers, or from the call's
+        # owning number when omitted, and needs a destination you may call. Only a call
+        # your answer connected to a conference can take participants: a call connected to
+        # a user or a number answers 409.
         sig do
           params(
             id: String,

data/rbi/sentdm/resources/calls.rbi

@@ -104,10 +104,11 @@ module Sentdm
       )
       end
 
-      # Ends one of your live calls. The call then ends the way any other call does: its
-      # status moves to completed and call.completed is sent once the disconnect is
-      # reported. A call that has already ended answers 409, and so does a call with no
-      # phone leg, such as one between two app users.
+      # Ends one of your live calls. The call then ends the way any other call does once
+      # the disconnect is reported: an answered call as COMPLETED with call.completed, a
+      # call still ringing as NO_ANSWER, REJECTED or FAILED with call.failed. A call
+      # that has already ended answers 409, and so does a call with no phone leg, such
+      # as one between two app users.
       sig do
         params(
           id: String,

data/rbi/sentdm/resources/messages.rbi

@@ -19,6 +19,11 @@ module Sentdm
     # 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.
+    #
+    # **A scheduled message can be called off.** `POST /v3/messages/{id}/cancel`
+    # cancels a send you scheduled with `scheduled_at`, as long as it has not been
+    # released yet. Cancelling is free, fires `message.cancelled`, and is final — a
+    # cancelled message cannot be resent.
     class Messages
       # Retrieves the activity log for a specific message. Activities track the message
       # lifecycle including acceptance, processing, sending, delivery, and any errors. A
@@ -43,10 +48,11 @@ module Sentdm
 
       # Retrieves the current status and details of a message by ID. Includes delivery
       # 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.
+      # was held for a later time (a send you scheduled with scheduled_at, a quiet-hours
+      # hold, or a message you cancelled while it was held) is returned as a
+      # ScheduledMessageResponse: the same fields plus scheduled_at, the instant it is
+      # held for in UTC — or, on a CANCELLED message, the instant that was called off. A
+      # message sent immediately has no scheduled_at key.
       sig do
         params(
           id: String,
@@ -67,13 +73,27 @@ module Sentdm
       # Sends a message to one or more recipients using a template. Supports
       # multi-channel broadcast — when multiple channels are specified (e.g. ["sms",
       # "whatsapp"]), a separate message is created for each (recipient, channel) pair.
-      # Returns immediately with per-recipient message IDs for async tracking via
-      # webhooks or the GET /messages/{id} endpoint. Sends gated before any delivery
-      # attempt do not reject the request — an account-level precondition such as
-      # 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. To send later, set scheduled_at (ISO-8601 with an
+      # To choose which of your own numbers a send goes out from, use 'channels':
+      # {"sms": [{"from": ["+12125550000", "+14155550000"]}]}. Each channel holds a list
+      # of entries, each with 'from' and optionally 'country' and 'strategy'; 'country'
+      # and 'strategy' are stored but not acted on yet, so every entry's numbers apply
+      # to every recipient on that channel. Every number listed must be an active sender
+      # on your account. Like the other account-level preconditions below, that is
+      # checked per message rather than when the request is received: the request is
+      # still accepted with 202, and each affected message is reported as BLOCKED with
+      # error code BUSINESS_029 on GET /messages/{id} and the message.blocked webhook.
+      # Each channel's numbers restrict which numbers that channel may use; it does not
+      # choose channels — 'channel' does, and the two can be combined. With 'channel'
+      # left at auto-detect, a recipient best served by a channel you listed no numbers
+      # for still goes out on it. Where several of the listed numbers could serve a
+      # recipient, routing prefers the one whose area code matches theirs. Keys: sms,
+      # whatsapp, rcs, mms. Returns immediately with per-recipient message IDs for async
+      # tracking via webhooks or the GET /messages/{id} endpoint. Sends gated before any
+      # delivery attempt do not reject the request — an account-level precondition such
+      # as 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. 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
@@ -87,6 +107,13 @@ module Sentdm
       sig do
         params(
           channel: T.nilable(T::Array[String]),
+          channels:
+            T.nilable(
+              T::Hash[
+                Symbol,
+                T::Array[Sentdm::MessageSendParams::Channel::OrHash]
+              ]
+            ),
           media_urls: T.nilable(T::Array[String]),
           sandbox: T::Boolean,
           scheduled_at: T.nilable(Time),
@@ -104,6 +131,25 @@ module Sentdm
         # produces a separate message per recipient. "sent" = auto-detect. Defaults to
         # ["sent"] (auto-detect) if omitted.
         channel: nil,
+        # Body param: Which of your own numbers to send from, keyed by channel, each
+        # channel holding a list of entries: {"sms": [{"country": "US", "from":
+        # ["+12125550000", "+14155550000"]}, {"from": ["+447700800001"]}]}. Any real
+        # channel may be a key; sent, which is auto-detect rather than a channel, is
+        # rejected. country and strategy are accepted and stored but not acted on yet:
+        # every entry's numbers apply to every recipient on that channel.
+        #
+        # This does not choose channels — Channel does, and the two combine: "channel":
+        # ["sms"] with an sms list sends on SMS from those numbers. Each list only narrows
+        # which of its own channel's routes may win, so with Channel left at auto-detect a
+        # recipient best served by a channel with no list still goes out on it. Routing
+        # itself is unchanged: the same rules are scored and ranked the same way, with
+        # routes pinned to numbers you did not list removed from the running.
+        #
+        # Every number must be an active sender on your account. The request itself is
+        # still accepted (202) if one is not — like every other send-time rule, that is
+        # decided per message, so each affected message is recorded BLOCKED with error
+        # code BUSINESS_029 and reported on GET /v3/messages and the status webhook.
+        channels: nil,
         # Body param: Attachments for this send, as publicly fetchable https URLs. Used by
         # the MMS channel and ignored by every other one.
         #

data/sig/sentdm/models/message_send_params.rbs

@@ -3,6 +3,7 @@ module Sentdm
     type message_send_params =
       {
         channel: ::Array[String]?,
+        channels: ::Hash[Symbol, ::Array[Sentdm::MessageSendParams::Channel]]?,
         media_urls: ::Array[String]?,
         sandbox: bool,
         scheduled_at: Time?,
@@ -21,6 +22,8 @@ module Sentdm
 
       attr_accessor channel: ::Array[String]?
 
+      attr_accessor channels: ::Hash[Symbol, ::Array[Sentdm::MessageSendParams::Channel]]?
+
       attr_accessor media_urls: ::Array[String]?
 
       attr_reader sandbox: bool?
@@ -49,6 +52,7 @@ module Sentdm
 
       def initialize: (
         ?channel: ::Array[String]?,
+        ?channels: ::Hash[Symbol, ::Array[Sentdm::MessageSendParams::Channel]]?,
         ?media_urls: ::Array[String]?,
         ?sandbox: bool,
         ?scheduled_at: Time?,
@@ -63,6 +67,7 @@ module Sentdm
 
       def to_hash: -> {
         channel: ::Array[String]?,
+        channels: ::Hash[Symbol, ::Array[Sentdm::MessageSendParams::Channel]]?,
         media_urls: ::Array[String]?,
         sandbox: bool,
         scheduled_at: Time?,
@@ -75,6 +80,29 @@ module Sentdm
         request_options: Sentdm::RequestOptions
       }
 
+      type channel =
+        { country: String?, from: ::Array[String]?, strategy: String? }
+
+      class Channel < Sentdm::Internal::Type::BaseModel
+        attr_accessor country: String?
+
+        attr_accessor from: ::Array[String]?
+
+        attr_accessor strategy: String?
+
+        def initialize: (
+          ?country: String?,
+          ?from: ::Array[String]?,
+          ?strategy: String?
+        ) -> void
+
+        def to_hash: -> {
+          country: String?,
+          from: ::Array[String]?,
+          strategy: String?
+        }
+      end
+
       type template =
         { id: String?, name: String?, parameters: ::Hash[Symbol, String]? }
 

data/sig/sentdm/resources/messages.rbs

@@ -15,6 +15,7 @@ module Sentdm
 
       def send_: (
         ?channel: ::Array[String]?,
+        ?channels: ::Hash[Symbol, ::Array[Sentdm::MessageSendParams::Channel]]?,
         ?media_urls: ::Array[String]?,
         ?sandbox: bool,
         ?scheduled_at: Time?,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentdm
 version: !ruby/object:Gem::Version
-  version: 0.35.0
+  version: 0.37.0
 platform: ruby
 authors:
 - Sent
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-01 00:00:00.000000000 Z
+date: 2026-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cgi