sentdm 0.33.0 → 0.35.0

data/rbi/sentdm/models/channels/voice_test_params.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class VoiceTestParams < Sentdm::Models::MutationRequest
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::VoiceTestParams, Sentdm::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :number
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :idempotency_key
+
+        sig { params(idempotency_key: String).void }
+        attr_writer :idempotency_key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :x_profile_id
+
+        sig { params(x_profile_id: String).void }
+        attr_writer :x_profile_id
+
+        sig do
+          params(
+            number: String,
+            idempotency_key: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          number:,
+          idempotency_key: nil,
+          x_profile_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              number: String,
+              idempotency_key: String,
+              x_profile_id: String,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/voice_token.rbi

@@ -0,0 +1,76 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class VoiceToken < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::VoiceToken, Sentdm::Internal::AnyHash)
+          end
+
+        # The signed token. Hand it to the client SDK unchanged.
+        sig { returns(T.nilable(String)) }
+        attr_reader :token
+
+        sig { params(token: String).void }
+        attr_writer :token
+
+        # When the token expires (UTC)
+        sig { returns(T.nilable(Time)) }
+        attr_reader :expires_at
+
+        sig { params(expires_at: Time).void }
+        attr_writer :expires_at
+
+        # The identity the token was minted for
+        sig { returns(T.nilable(String)) }
+        attr_reader :identity
+
+        sig { params(identity: String).void }
+        attr_writer :identity
+
+        # The phone number this identity is now bound to, in E.164 format
+        sig { returns(T.nilable(String)) }
+        attr_reader :number
+
+        sig { params(number: String).void }
+        attr_writer :number
+
+        # A short-lived token your app passes to the voice client SDK to register
+        sig do
+          params(
+            token: String,
+            expires_at: Time,
+            identity: String,
+            number: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The signed token. Hand it to the client SDK unchanged.
+          token: nil,
+          # When the token expires (UTC)
+          expires_at: nil,
+          # The identity the token was minted for
+          identity: nil,
+          # The phone number this identity is now bound to, in E.164 format
+          number: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              token: String,
+              expires_at: Time,
+              identity: String,
+              number: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/voice_update_params.rbi

@@ -0,0 +1,158 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class VoiceUpdateParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::VoiceUpdateParams,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :number
+
+        # A new callback URL for the number, active or not: an absolute HTTP or HTTPS URL
+        # on a public host, where Sent asks what to do with each call. The signing secret
+        # is kept.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :callback_url
+
+        # true makes this the line app-originated calls are placed from when a voice token
+        # names no number. false is refused: an account with active voice numbers always
+        # has exactly one default, so the default moves by giving it to another number.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :default_for_app_calls
+
+        # Sandbox flag - when true, the operation is simulated without side effects Useful
+        # for testing integrations without actual execution
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :sandbox
+
+        sig { params(sandbox: T::Boolean).void }
+        attr_writer :sandbox
+
+        # ACTIVE turns calls on for the number again, INACTIVE turns them off. Matched
+        # ignoring case. Turning the default line off is refused while other active voice
+        # numbers remain.
+        sig do
+          returns(
+            T.nilable(Sentdm::Channels::VoiceUpdateParams::Status::OrSymbol)
+          )
+        end
+        attr_accessor :status
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :idempotency_key
+
+        sig { params(idempotency_key: String).void }
+        attr_writer :idempotency_key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :x_profile_id
+
+        sig { params(x_profile_id: String).void }
+        attr_writer :x_profile_id
+
+        sig do
+          params(
+            number: String,
+            callback_url: T.nilable(String),
+            default_for_app_calls: T.nilable(T::Boolean),
+            sandbox: T::Boolean,
+            status:
+              T.nilable(Sentdm::Channels::VoiceUpdateParams::Status::OrSymbol),
+            idempotency_key: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          number:,
+          # A new callback URL for the number, active or not: an absolute HTTP or HTTPS URL
+          # on a public host, where Sent asks what to do with each call. The signing secret
+          # is kept.
+          callback_url: nil,
+          # true makes this the line app-originated calls are placed from when a voice token
+          # names no number. false is refused: an account with active voice numbers always
+          # has exactly one default, so the default moves by giving it to another number.
+          default_for_app_calls: nil,
+          # Sandbox flag - when true, the operation is simulated without side effects Useful
+          # for testing integrations without actual execution
+          sandbox: nil,
+          # ACTIVE turns calls on for the number again, INACTIVE turns them off. Matched
+          # ignoring case. Turning the default line off is refused while other active voice
+          # numbers remain.
+          status: nil,
+          idempotency_key: nil,
+          x_profile_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              number: String,
+              callback_url: T.nilable(String),
+              default_for_app_calls: T.nilable(T::Boolean),
+              sandbox: T::Boolean,
+              status:
+                T.nilable(
+                  Sentdm::Channels::VoiceUpdateParams::Status::OrSymbol
+                ),
+              idempotency_key: String,
+              x_profile_id: String,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # ACTIVE turns calls on for the number again, INACTIVE turns them off. Matched
+        # ignoring case. Turning the default line off is refused while other active voice
+        # numbers remain.
+        module Status
+          extend Sentdm::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Sentdm::Channels::VoiceUpdateParams::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # Turns calls on for the number again. The callback URL and the signing secret it had are kept; send `callback_url` in the same call to replace the URL.
+          ACTIVE =
+            T.let(
+              :ACTIVE,
+              Sentdm::Channels::VoiceUpdateParams::Status::TaggedSymbol
+            )
+
+          # Turns calls off for the number. Refused while the number is the default line for app calls and other active voice numbers remain; move the default first. The callback URL and the secret stay on the number.
+          INACTIVE =
+            T.let(
+              :INACTIVE,
+              Sentdm::Channels::VoiceUpdateParams::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Sentdm::Channels::VoiceUpdateParams::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/conversation_messages_list.rbi

@@ -152,6 +152,20 @@ module Sentdm
         sig { returns(T.nilable(Float)) }
         attr_accessor :price
 
+        # A human-readable sentence for reason_code, for example "Insufficient balance".
+        # Omitted whenever reason_code is.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        # Why the message is at its current status, as a stable platform code such as
+        # DELIVERY_007, BUSINESS_003 or DELIVERY_003. Present when the current status is
+        # FAILED, FILTERED or BLOCKED and the lifecycle was loaded; omitted otherwise.
+        # Switch on this rather than on reason: the code is stable, the wording may be
+        # improved. It is the platform's classification of the outcome, never a carrier or
+        # vendor code.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason_code
+
         sig { returns(T.nilable(String)) }
         attr_reader :region_code
 
@@ -201,6 +215,8 @@ module Sentdm
             phone: String,
             phone_international: String,
             price: T.nilable(Float),
+            reason: T.nilable(String),
+            reason_code: T.nilable(String),
             region_code: String,
             status: String,
             template_category: T.nilable(String),
@@ -230,6 +246,16 @@ module Sentdm
           phone: nil,
           phone_international: nil,
           price: nil,
+          # A human-readable sentence for reason_code, for example "Insufficient balance".
+          # Omitted whenever reason_code is.
+          reason: nil,
+          # Why the message is at its current status, as a stable platform code such as
+          # DELIVERY_007, BUSINESS_003 or DELIVERY_003. Present when the current status is
+          # FAILED, FILTERED or BLOCKED and the lifecycle was loaded; omitted otherwise.
+          # Switch on this rather than on reason: the code is stable, the wording may be
+          # improved. It is the platform's classification of the outcome, never a carrier or
+          # vendor code.
+          reason_code: nil,
           region_code: nil,
           status: nil,
           template_category: nil,
@@ -259,6 +285,8 @@ module Sentdm
               phone: String,
               phone_international: String,
               price: T.nilable(Float),
+              reason: T.nilable(String),
+              reason_code: T.nilable(String),
               region_code: String,
               status: String,
               template_category: T.nilable(String),
@@ -288,15 +316,39 @@ module Sentdm
           sig { returns(T.nilable(String)) }
           attr_accessor :description
 
+          # A human-readable sentence for reason_code. Omitted whenever reason_code is.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reason
+
+          # Why the message reached this status, as a stable platform code such as
+          # DELIVERY_007. Present on FAILED, FILTERED and BLOCKED events; omitted on every
+          # status that needs no explanation. Same wire name and vocabulary as on the
+          # activities list and the webhook.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :reason_code
+
           # Represents a status change event in a message's lifecycle (v3)
           sig do
             params(
               status: String,
               timestamp: Time,
-              description: T.nilable(String)
+              description: T.nilable(String),
+              reason: T.nilable(String),
+              reason_code: T.nilable(String)
             ).returns(T.attached_class)
           end
-          def self.new(status:, timestamp:, description: nil)
+          def self.new(
+            status:,
+            timestamp:,
+            description: nil,
+            # A human-readable sentence for reason_code. Omitted whenever reason_code is.
+            reason: nil,
+            # Why the message reached this status, as a stable platform code such as
+            # DELIVERY_007. Present on FAILED, FILTERED and BLOCKED events; omitted on every
+            # status that needs no explanation. Same wire name and vocabulary as on the
+            # activities list and the webhook.
+            reason_code: nil
+          )
           end
 
           sig do
@@ -304,7 +356,9 @@ module Sentdm
               {
                 status: String,
                 timestamp: Time,
-                description: T.nilable(String)
+                description: T.nilable(String),
+                reason: T.nilable(String),
+                reason_code: T.nilable(String)
               }
             )
           end
@@ -571,38 +625,87 @@ module Sentdm
                 )
               end
 
-            # One of Constants.MmsMediaTypes when known. Advisory — the carrier reads the
-            # fetched object's Content-Type, not this.
+            # One of MmsMediaTypes when the content type is known. Advisory — a reader should
+            # trust the fetched object's own Content-Type.
             sig { returns(T.nilable(String)) }
             attr_accessor :media_type
 
+            # Content type as the provider declared it. Null when it declared none.
             sig { returns(T.nilable(String)) }
-            attr_reader :url
+            attr_accessor :mime_type
 
-            sig { params(url: String).void }
-            attr_writer :url
+            # Size as the provider declared it. Never measured here — nothing downloads the
+            # file.
+            sig { returns(T.nilable(Integer)) }
+            attr_accessor :size_bytes
 
-            # One attachment on a message: a customer-supplied public URL handed to the
-            # carrier as-is.
+            # Inbound only: the SHA-256 the provider declared alongside the attachment, when
+            # it declared one. Relayed to the customer so they can verify what they fetch
+            # matches what the carrier said it sent. It is the only integrity signal available
+            # on an attachment nobody here has read.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :source_hash_sha256
+
+            # Where the file lives. Outbound: the URL the customer gave us and the carrier
+            # fetched. Inbound: the URL the carrier hosts it at, relayed unchanged.
+            sig { returns(T.nilable(String)) }
+            attr_accessor :url
+
+            # One attachment on a message, in either direction — and in both, a URL somebody
+            # else hosts.
             #
-            #              A URL and nothing else. sent.dm never takes custody of MMS media — the customer hosts it and we
-            #              pass the link through at send time — so there is no storage key, size or expiry to record. If we ever
-            #              do host attachments, that belongs with the change that introduces the hosting, not here.
+            # Outbound: the customer supplied a public URL and we handed it to the carrier.
+            # Inbound: the carrier hosts the file and we record where. sent.dm never holds the
+            # bytes, so there is no key, no expiry bookkeeping and nothing minted per read —
+            # what is stored is what is served.
+            #
+            # An inbound link expires on the carrier's own schedule and is unauthenticated.
+            # That is the customer's to manage, and it is documented where they will see it
+            # rather than only here — a recipient who needs an attachment to outlive that
+            # window copies it on receipt.
+            #
+            # Storing a presigned URL is the specific mistake this shape still avoids:
+            # M260826130000 and M260826140000 exist because RCS assets were stored as signed
+            # URLs and went stale. Nothing here is signed.
             sig do
-              params(media_type: T.nilable(String), url: String).returns(
-                T.attached_class
-              )
+              params(
+                media_type: T.nilable(String),
+                mime_type: T.nilable(String),
+                size_bytes: T.nilable(Integer),
+                source_hash_sha256: T.nilable(String),
+                url: T.nilable(String)
+              ).returns(T.attached_class)
             end
             def self.new(
-              # One of Constants.MmsMediaTypes when known. Advisory — the carrier reads the
-              # fetched object's Content-Type, not this.
+              # One of MmsMediaTypes when the content type is known. Advisory — a reader should
+              # trust the fetched object's own Content-Type.
               media_type: nil,
+              # Content type as the provider declared it. Null when it declared none.
+              mime_type: nil,
+              # Size as the provider declared it. Never measured here — nothing downloads the
+              # file.
+              size_bytes: nil,
+              # Inbound only: the SHA-256 the provider declared alongside the attachment, when
+              # it declared one. Relayed to the customer so they can verify what they fetch
+              # matches what the carrier said it sent. It is the only integrity signal available
+              # on an attachment nobody here has read.
+              source_hash_sha256: nil,
+              # Where the file lives. Outbound: the URL the customer gave us and the carrier
+              # fetched. Inbound: the URL the carrier hosts it at, relayed unchanged.
               url: nil
             )
             end
 
             sig do
-              override.returns({ media_type: T.nilable(String), url: String })
+              override.returns(
+                {
+                  media_type: T.nilable(String),
+                  mime_type: T.nilable(String),
+                  size_bytes: T.nilable(Integer),
+                  source_hash_sha256: T.nilable(String),
+                  url: T.nilable(String)
+                }
+              )
             end
             def to_hash
             end

data/rbi/sentdm/models/inbound_message_event_payload.rbi

@@ -23,13 +23,28 @@ module Sentdm
       sig { params(account_id: String).void }
       attr_writer :account_id
 
-      # The channel the message arrived on, for example sms or whatsapp.
+      # The channel the message arrived on, for example sms or mms.
       sig { returns(T.nilable(String)) }
       attr_reader :channel
 
       sig { params(channel: String).void }
       attr_writer :channel
 
+      # Attachments the contact sent, present only on channels that carry them (mms
+      # today) and omitted entirely otherwise.
+      #
+      # Each url points at the carrier's own copy of the file — sent.dm records where
+      # the attachment is, not the attachment itself. The link is unauthenticated and
+      # expires on the carrier's schedule, which differs between them: assume days, not
+      # months. Download what you need on receipt; re-reading the message through GET
+      # /v3/messages/{id} returns the same stored link, not a fresh one, so once it
+      # lapses the entry remains with whatever the carrier declared about the file but
+      # the file is no longer reachable.
+      sig do
+        returns(T.nilable(T::Array[Sentdm::InboundMessageEventPayload::Media]))
+      end
+      attr_accessor :media
+
       # The inbound message.
       sig { returns(T.nilable(String)) }
       attr_reader :message_id
@@ -66,6 +81,10 @@ module Sentdm
           received_at: String,
           account_id: String,
           channel: String,
+          media:
+            T.nilable(
+              T::Array[Sentdm::InboundMessageEventPayload::Media::OrHash]
+            ),
           message_id: String,
           outbound_number: String,
           text: T.nilable(String),
@@ -79,8 +98,19 @@ module Sentdm
         received_at:,
         # The account the message belongs to.
         account_id: nil,
-        # The channel the message arrived on, for example sms or whatsapp.
+        # The channel the message arrived on, for example sms or mms.
         channel: nil,
+        # Attachments the contact sent, present only on channels that carry them (mms
+        # today) and omitted entirely otherwise.
+        #
+        # Each url points at the carrier's own copy of the file — sent.dm records where
+        # the attachment is, not the attachment itself. The link is unauthenticated and
+        # expires on the carrier's schedule, which differs between them: assume days, not
+        # months. Download what you need on receipt; re-reading the message through GET
+        # /v3/messages/{id} returns the same stored link, not a fresh one, so once it
+        # lapses the entry remains with whatever the carrier declared about the file but
+        # the file is no longer reachable.
+        media: nil,
         # The inbound message.
         message_id: nil,
         # Your number in E.164 format, meaning the number the message was addressed to.
@@ -102,6 +132,8 @@ module Sentdm
             received_at: String,
             account_id: String,
             channel: String,
+            media:
+              T.nilable(T::Array[Sentdm::InboundMessageEventPayload::Media]),
             message_id: String,
             outbound_number: String,
             text: T.nilable(String),
@@ -111,6 +143,82 @@ module Sentdm
       end
       def to_hash
       end
+
+      class Media < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::InboundMessageEventPayload::Media,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # SHA-256 of the file as the carrier declared it, when it declares one. Verify
+        # what you download against this — sent.dm never reads the bytes, so it is the
+        # only integrity signal available.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :hash_sha256
+
+        # Content type as the carrier reported it, for example image/jpeg.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :mime_type
+
+        # Size in bytes as the carrier declared it. Absent when it declared none.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :size_bytes
+
+        # Where the carrier hosts the attachment.
+        #
+        # This link expires and is not authenticated. sent.dm relays it rather than
+        # copying the file, so how long it stays fetchable is the carrier's decision and
+        # differs between them — assume days, not months. Anyone holding the URL can fetch
+        # it until it lapses. Copy the file on receipt if you need it to outlive that
+        # window; do not store this URL as a permanent reference.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :url
+
+        # One attachment on an inbound message.
+        sig do
+          params(
+            hash_sha256: T.nilable(String),
+            mime_type: T.nilable(String),
+            size_bytes: T.nilable(Integer),
+            url: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # SHA-256 of the file as the carrier declared it, when it declares one. Verify
+          # what you download against this — sent.dm never reads the bytes, so it is the
+          # only integrity signal available.
+          hash_sha256: nil,
+          # Content type as the carrier reported it, for example image/jpeg.
+          mime_type: nil,
+          # Size in bytes as the carrier declared it. Absent when it declared none.
+          size_bytes: nil,
+          # Where the carrier hosts the attachment.
+          #
+          # This link expires and is not authenticated. sent.dm relays it rather than
+          # copying the file, so how long it stays fetchable is the carrier's decision and
+          # differs between them — assume days, not months. Anyone holding the URL can fetch
+          # it until it lapses. Copy the file on receipt if you need it to outlive that
+          # window; do not store this URL as a permanent reference.
+          url: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              hash_sha256: T.nilable(String),
+              mime_type: T.nilable(String),
+              size_bytes: T.nilable(Integer),
+              url: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
     end
   end
 end