sentdm 0.36.0 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1d07878fe77b406e3665345f7f6d2c733edfd36e5d9885919ca6a480bd448d4
-  data.tar.gz: a71ce847b04363a6718b2d5bcd04e99502518d77d9eaa7b07ecc7fcc44b735d9
+  metadata.gz: b87a8f99b83286055bbd617ca7e428d48734be02c56c328493de78fbc3676c20
+  data.tar.gz: 277e30bdcb461b6d6a124caf606810d09b295ee097b12795d309a705f82cd28e
 SHA512:
-  metadata.gz: e510f27198098e2f73c9d0d1eb86578b395a2222cb1e291631fa7d18682b0d334b6827165df73440e06667e876d53d2675aeee460753d4006c2e162fcb6294da
-  data.tar.gz: d9239a9ef793bae4801adc25f099db5dfa77a1c65bc4798e01b41521cbc482e506a0ec8c573a9933da38d0af981a8056442f9bc2264c7c7f60c75115a77d7633
+  metadata.gz: f5a4a889a1c15fb5962a15e1468106d3eac930c0fd2b9bbe1f2246696c27c504809fbaff257bf06a97c732f877ce04fe02daa1c15eead19d16e7754d53dc4354
+  data.tar.gz: 8e0df11e0a4367ee7a2eb5e44798e980ca2e49619d77faa7042c1829ae9f0c8c3e3f46dfb9e43d91c20e566105f06fe0897272096b463d5207e19028244dd78d

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.38.0](https://github.com/sentdm/sent-dm-ruby/compare/v0.37.0...v0.38.0) (2026-10-20)
+
+
+### Features
+
+* **api:** sync generated SDKs from the committed spec ([0f635d5](https://github.com/sentdm/sent-dm-ruby/commit/0f635d57fa2ee924000ff7c6683ca505d00dc3e2))
+* **api:** sync OpenAPI spec from production ([dbd2131](https://github.com/sentdm/sent-dm-ruby/commit/dbd2131083dda1ff7b2cd11e41db535364881d65))
+
+## [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)
 
 

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.36.0"
+gem "sentdm", "~> 0.38.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/sentdm/models/inbound_message_event_payload.rb

@@ -56,6 +56,20 @@ module Sentdm
       #   @return [String, nil]
       optional :outbound_number, String
 
+      # @!attribute referral
+      #   The ad the contact tapped to start the conversation, present only on whatsapp
+      #   messages sent from a Click to WhatsApp ad and omitted entirely otherwise.
+      #
+      #   This is Meta's referral object passed through unchanged, with Meta's field names
+      #   and nesting: source_url, source_id, source_type, headline, body, media_type,
+      #   image_url (image ads), video_url and thumbnail_url (video ads), ctwa_clid and
+      #   welcome_message.text. Which fields appear is Meta's decision: ctwa_clid in
+      #   particular is not sent for ads shown in WhatsApp Status, so treat every field as
+      #   optional.
+      #
+      #   @return [Object, nil]
+      optional :referral, Sentdm::Internal::Type::Unknown, nil?: true
+
       # @!attribute text
       #   The message body. Sent as null when the inbound message carried no text, for
       #   example a media-only message. The field is always present, so read it and check
@@ -71,7 +85,7 @@ module Sentdm
       #   @return [String, nil]
       optional :updated_at, String
 
-      # @!method initialize(inbound_number:, received_at:, account_id: nil, channel: nil, media: nil, message_id: nil, outbound_number: nil, text: nil, updated_at: nil)
+      # @!method initialize(inbound_number:, received_at:, account_id: nil, channel: nil, media: nil, message_id: nil, outbound_number: nil, referral: nil, text: nil, updated_at: nil)
       #   Some parameter documentations has been truncated, see
       #   {Sentdm::Models::InboundMessageEventPayload} for more details.
       #
@@ -92,6 +106,8 @@ module Sentdm
       #
       #   @param outbound_number [String] Your number in E.164 format, meaning the number the message was addressed to.
       #
+      #   @param referral [Object, nil] The ad the contact tapped to start the conversation, present only on whatsapp
+      #
       #   @param text [String, nil] The message body. Sent as null when the inbound message carried no text, for
       #
       #   @param updated_at [String] When the message was received, in UTC (yyyy-MM-ddTHH:mm:ssZ). Same value as

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/messages.rb

@@ -94,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
@@ -112,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/resources/profiles.rb

@@ -316,6 +316,13 @@ module Sentdm
       # deregistered, and its routing rules stop being used. Requires admin role in the
       # organization.
       #
+      # A number it holds that your WhatsApp Business Account still carries refuses the
+      # delete with a `409 CONFLICT_012`, and nothing is deleted: the number would
+      # return to our shared inventory while Meta still routes WhatsApp to it, and only
+      # you can take it off the account — deregister **and** delete it in WhatsApp
+      # Manager, then try again. A `409 CONFLICT_013` means the account could not be
+      # read, so we cannot tell.
+      #
       # @overload delete(profile_id, sandbox: nil, x_profile_id: nil, request_options: {})
       #
       # @param profile_id [String] Path param: Profile ID from route parameter

data/lib/sentdm/version.rb

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

data/rbi/sentdm/models/inbound_message_event_payload.rbi

@@ -59,6 +59,18 @@ module Sentdm
       sig { params(outbound_number: String).void }
       attr_writer :outbound_number
 
+      # The ad the contact tapped to start the conversation, present only on whatsapp
+      # messages sent from a Click to WhatsApp ad and omitted entirely otherwise.
+      #
+      # This is Meta's referral object passed through unchanged, with Meta's field names
+      # and nesting: source_url, source_id, source_type, headline, body, media_type,
+      # image_url (image ads), video_url and thumbnail_url (video ads), ctwa_clid and
+      # welcome_message.text. Which fields appear is Meta's decision: ctwa_clid in
+      # particular is not sent for ads shown in WhatsApp Status, so treat every field as
+      # optional.
+      sig { returns(T.nilable(T.anything)) }
+      attr_accessor :referral
+
       # The message body. Sent as null when the inbound message carried no text, for
       # example a media-only message. The field is always present, so read it and check
       # for null rather than checking whether the key exists.
@@ -87,6 +99,7 @@ module Sentdm
             ),
           message_id: String,
           outbound_number: String,
+          referral: T.nilable(T.anything),
           text: T.nilable(String),
           updated_at: String
         ).returns(T.attached_class)
@@ -115,6 +128,16 @@ module Sentdm
         message_id: nil,
         # Your number in E.164 format, meaning the number the message was addressed to.
         outbound_number: nil,
+        # The ad the contact tapped to start the conversation, present only on whatsapp
+        # messages sent from a Click to WhatsApp ad and omitted entirely otherwise.
+        #
+        # This is Meta's referral object passed through unchanged, with Meta's field names
+        # and nesting: source_url, source_id, source_type, headline, body, media_type,
+        # image_url (image ads), video_url and thumbnail_url (video ads), ctwa_clid and
+        # welcome_message.text. Which fields appear is Meta's decision: ctwa_clid in
+        # particular is not sent for ads shown in WhatsApp Status, so treat every field as
+        # optional.
+        referral: nil,
         # The message body. Sent as null when the inbound message carried no text, for
         # example a media-only message. The field is always present, so read it and check
         # for null rather than checking whether the key exists.
@@ -136,6 +159,7 @@ module Sentdm
               T.nilable(T::Array[Sentdm::InboundMessageEventPayload::Media]),
             message_id: String,
             outbound_number: String,
+            referral: T.nilable(T.anything),
             text: T.nilable(String),
             updated_at: String
           }

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/messages.rbi

@@ -73,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
@@ -93,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),
@@ -110,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/rbi/sentdm/resources/profiles.rbi

@@ -385,6 +385,13 @@ module Sentdm
       # inventory and can go to whoever asks next, its own WhatsApp account is
       # deregistered, and its routing rules stop being used. Requires admin role in the
       # organization.
+      #
+      # A number it holds that your WhatsApp Business Account still carries refuses the
+      # delete with a `409 CONFLICT_012`, and nothing is deleted: the number would
+      # return to our shared inventory while Meta still routes WhatsApp to it, and only
+      # you can take it off the account — deregister **and** delete it in WhatsApp
+      # Manager, then try again. A `409 CONFLICT_013` means the account could not be
+      # read, so we cannot tell.
       sig do
         params(
           profile_id: String,

data/sig/sentdm/models/inbound_message_event_payload.rbs

@@ -9,6 +9,7 @@ module Sentdm
         media: ::Array[Sentdm::InboundMessageEventPayload::Media]?,
         message_id: String,
         outbound_number: String,
+        referral: top?,
         text: String?,
         updated_at: String
       }
@@ -36,6 +37,8 @@ module Sentdm
 
       def outbound_number=: (String) -> String
 
+      attr_accessor referral: top?
+
       attr_accessor text: String?
 
       attr_reader updated_at: String?
@@ -50,6 +53,7 @@ module Sentdm
         ?media: ::Array[Sentdm::InboundMessageEventPayload::Media]?,
         ?message_id: String,
         ?outbound_number: String,
+        ?referral: top?,
         ?text: String?,
         ?updated_at: String
       ) -> void
@@ -62,6 +66,7 @@ module Sentdm
         media: ::Array[Sentdm::InboundMessageEventPayload::Media]?,
         message_id: String,
         outbound_number: String,
+        referral: top?,
         text: String?,
         updated_at: String
       }

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.36.0
+  version: 0.38.0
 platform: ruby
 authors:
 - Sent
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-06 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cgi