sentdm 0.36.0 → 0.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1d07878fe77b406e3665345f7f6d2c733edfd36e5d9885919ca6a480bd448d4
-  data.tar.gz: a71ce847b04363a6718b2d5bcd04e99502518d77d9eaa7b07ecc7fcc44b735d9
+  metadata.gz: d680fc6fd1a90e7cfbb949b51b2318a9a5be626e7f5629eac8e94aa891efb518
+  data.tar.gz: 51a7542758dea2afa3873d000f47d003c4212ad54808c9a1ee6b97551f14a93d
 SHA512:
-  metadata.gz: e510f27198098e2f73c9d0d1eb86578b395a2222cb1e291631fa7d18682b0d334b6827165df73440e06667e876d53d2675aeee460753d4006c2e162fcb6294da
-  data.tar.gz: d9239a9ef793bae4801adc25f099db5dfa77a1c65bc4798e01b41521cbc482e506a0ec8c573a9933da38d0af981a8056442f9bc2264c7c7f60c75115a77d7633
+  metadata.gz: 1fd26499de108ec871956cbc8f6219506a2c08cb6ce1f9aa105c2509518faf6b99eda7cfd5dda5781f2b584fbbeca3618692667ac6fe46b1cc2a4e033114f6ee
+  data.tar.gz: 3bf07498b8d470a63f9f543b4bf0e68b88141ae345c7a7700994fb6beaf89731a01a0ddc41198275d0d64f1e8ffa8026487b14c74a6e9f9194c4b3659462223d

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 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)
 
 

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.37.0"
 ```
 
 <!-- x-release-please-end -->

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

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

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