sentdm 0.45.0 → 0.46.0

data/rbi/sentdm/models/message_header_media.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MessageHeaderMedia < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::MessageHeaderMedia, Sentdm::Internal::AnyHash)
+        end
+
+      # "image", "video" or "document" — taken from the header's media variable.
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      # The https URL the caller supplied for this send. Never the template's stored
+      # props.sample, which is Meta's expiring header_handle rather than what was
+      # delivered.
+      sig { returns(T.nilable(String)) }
+      attr_reader :url
+
+      sig { params(url: String).void }
+      attr_writer :url
+
+      # The media asset that rode a message's header, recorded as sent.
+      sig { params(type: String, url: String).returns(T.attached_class) }
+      def self.new(
+        # "image", "video" or "document" — taken from the header's media variable.
+        type: nil,
+        # The https URL the caller supplied for this send. Never the template's stored
+        # props.sample, which is Meta's expiring header_handle rather than what was
+        # delivered.
+        url: nil
+      )
+      end
+
+      sig { override.returns({ type: String, url: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/message_media.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MessageMedia < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::MessageMedia, Sentdm::Internal::AnyHash) }
+
+      # 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_accessor :mime_type
+
+      # Size as the provider declared it. Never measured here — nothing downloads the
+      # file.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :size_bytes
+
+      # 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.
+      #
+      # 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),
+          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 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),
+            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
+    end
+  end
+end

data/rbi/sentdm/models/message_recipient.rbi

@@ -0,0 +1,70 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MessageRecipient < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::MessageRecipient, Sentdm::Internal::AnyHash)
+        end
+
+      # Resolved template body for this recipient's channel, or null when the channel is
+      # auto-detected.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :body
+
+      # Channel this message will be sent on — sms, whatsapp — or null to auto-detect.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :channel
+
+      # Identifier for tracking this recipient's message.
+      sig { returns(T.nilable(String)) }
+      attr_reader :message_id
+
+      sig { params(message_id: String).void }
+      attr_writer :message_id
+
+      # Phone number in E.164 format.
+      sig { returns(T.nilable(String)) }
+      attr_reader :to
+
+      sig { params(to: String).void }
+      attr_writer :to
+
+      # What one recipient of a send got, as the API reports it.
+      sig do
+        params(
+          body: T.nilable(String),
+          channel: T.nilable(String),
+          message_id: String,
+          to: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Resolved template body for this recipient's channel, or null when the channel is
+        # auto-detected.
+        body: nil,
+        # Channel this message will be sent on — sms, whatsapp — or null to auto-detect.
+        channel: nil,
+        # Identifier for tracking this recipient's message.
+        message_id: nil,
+        # Phone number in E.164 format.
+        to: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            body: T.nilable(String),
+            channel: T.nilable(String),
+            message_id: String,
+            to: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/message_send_params.rbi

@@ -42,9 +42,7 @@ module Sentdm
       # 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]]
-          )
+          T.nilable(T::Hash[Symbol, T::Array[Sentdm::MessageChannelOptions]])
         )
       end
       attr_accessor :channels
@@ -97,14 +95,10 @@ module Sentdm
 
       # SDK-style template reference: resolve by ID or by name, with optional
       # parameters.
-      sig { returns(T.nilable(Sentdm::MessageSendParams::Template)) }
+      sig { returns(T.nilable(Sentdm::TemplateRef)) }
       attr_reader :template
 
-      sig do
-        params(
-          template: T.nilable(Sentdm::MessageSendParams::Template::OrHash)
-        ).void
-      end
+      sig { params(template: T.nilable(Sentdm::TemplateRef::OrHash)).void }
       attr_writer :template
 
       # Plain-text (free-form) message body. Provide either Template or this.
@@ -135,16 +129,13 @@ module Sentdm
           channel: T.nilable(T::Array[String]),
           channels:
             T.nilable(
-              T::Hash[
-                Symbol,
-                T::Array[Sentdm::MessageSendParams::Channel::OrHash]
-              ]
+              T::Hash[Symbol, T::Array[Sentdm::MessageChannelOptions::OrHash]]
             ),
           media_urls: T.nilable(T::Array[String]),
           sandbox: T::Boolean,
           scheduled_at: T.nilable(Time),
           subject: T.nilable(String),
-          template: T.nilable(Sentdm::MessageSendParams::Template::OrHash),
+          template: T.nilable(Sentdm::TemplateRef::OrHash),
           text: T.nilable(String),
           to: T::Array[String],
           idempotency_key: String,
@@ -235,13 +226,13 @@ module Sentdm
             channel: T.nilable(T::Array[String]),
             channels:
               T.nilable(
-                T::Hash[Symbol, T::Array[Sentdm::MessageSendParams::Channel]]
+                T::Hash[Symbol, T::Array[Sentdm::MessageChannelOptions]]
               ),
             media_urls: T.nilable(T::Array[String]),
             sandbox: T::Boolean,
             scheduled_at: T.nilable(Time),
             subject: T.nilable(String),
-            template: T.nilable(Sentdm::MessageSendParams::Template),
+            template: T.nilable(Sentdm::TemplateRef),
             text: T.nilable(String),
             to: T::Array[String],
             idempotency_key: String,
@@ -252,145 +243,6 @@ module Sentdm
       end
       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
-            T.any(
-              Sentdm::MessageSendParams::Template,
-              Sentdm::Internal::AnyHash
-            )
-          end
-
-        # Template ID (mutually exclusive with name)
-        sig { returns(T.nilable(String)) }
-        attr_accessor :id
-
-        # Template name (mutually exclusive with id)
-        sig { returns(T.nilable(String)) }
-        attr_accessor :name
-
-        # Template variable parameters for personalization, keyed by variable name.
-        #
-        # Every variable the template declares is required; GET /v3/templates/{id} lists
-        # them. Supplying a key the template does not declare is ignored.
-        #
-        # Media headers. A template whose header is an image (designed in WhatsApp Manager
-        # and imported into Sent) declares a reserved header_image key. Its value is a
-        # publicly reachable https URL that Meta fetches at send time — Sent does not host
-        # the asset, and the sample approved with the template is not reused. The key is
-        # derived from the header's media type, so header_video and header_document follow
-        # the same shape when those formats ship.
-        #
-        # "parameters": { "header_image": "https://cdn.example.com/banner.jpg", "name":
-        # "John Doe" }
-        sig { returns(T.nilable(T::Hash[Symbol, String])) }
-        attr_accessor :parameters
-
-        # SDK-style template reference: resolve by ID or by name, with optional
-        # parameters.
-        sig do
-          params(
-            id: T.nilable(String),
-            name: T.nilable(String),
-            parameters: T.nilable(T::Hash[Symbol, String])
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Template ID (mutually exclusive with name)
-          id: nil,
-          # Template name (mutually exclusive with id)
-          name: nil,
-          # Template variable parameters for personalization, keyed by variable name.
-          #
-          # Every variable the template declares is required; GET /v3/templates/{id} lists
-          # them. Supplying a key the template does not declare is ignored.
-          #
-          # Media headers. A template whose header is an image (designed in WhatsApp Manager
-          # and imported into Sent) declares a reserved header_image key. Its value is a
-          # publicly reachable https URL that Meta fetches at send time — Sent does not host
-          # the asset, and the sample approved with the template is not reused. The key is
-          # derived from the header's media type, so header_video and header_document follow
-          # the same shape when those formats ship.
-          #
-          # "parameters": { "header_image": "https://cdn.example.com/banner.jpg", "name":
-          # "John Doe" }
-          parameters: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              id: T.nilable(String),
-              name: T.nilable(String),
-              parameters: T.nilable(T::Hash[Symbol, String])
-            }
-          )
-        end
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/sentdm/models/message_send_response.rbi

@@ -20,12 +20,10 @@ module Sentdm
       # The shape of an immediate send: it never has a scheduled_at key. A send that
       # carried scheduled_at is a ScheduledSendMessageResponse, and the endpoint decides
       # which of the two to answer with. From always returns this type.
-      sig { returns(T.nilable(Sentdm::MessageSendResponse::Data)) }
+      sig { returns(T.nilable(Sentdm::MessageSendResult)) }
       attr_reader :data
 
-      sig do
-        params(data: T.nilable(Sentdm::MessageSendResponse::Data::OrHash)).void
-      end
+      sig { params(data: T.nilable(Sentdm::MessageSendResult::OrHash)).void }
       attr_writer :data
 
       # Error information
@@ -52,7 +50,7 @@ module Sentdm
       # Standard API response envelope for all v3 endpoints
       sig do
         params(
-          data: T.nilable(Sentdm::MessageSendResponse::Data::OrHash),
+          data: T.nilable(Sentdm::MessageSendResult::OrHash),
           error: T.nilable(Sentdm::ErrorDetail::OrHash),
           meta: Sentdm::APIMeta::OrHash,
           success: T::Boolean
@@ -84,7 +82,7 @@ module Sentdm
       sig do
         override.returns(
           {
-            data: T.nilable(Sentdm::MessageSendResponse::Data),
+            data: T.nilable(Sentdm::MessageSendResult),
             error: T.nilable(Sentdm::ErrorDetail),
             meta: Sentdm::APIMeta,
             success: T::Boolean
@@ -93,163 +91,6 @@ module Sentdm
       end
       def to_hash
       end
-
-      class Data < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Sentdm::MessageSendResponse::Data, Sentdm::Internal::AnyHash)
-          end
-
-        sig do
-          returns(
-            T.nilable(T::Array[Sentdm::MessageSendResponse::Data::Recipient])
-          )
-        end
-        attr_reader :recipients
-
-        sig do
-          params(
-            recipients:
-              T::Array[Sentdm::MessageSendResponse::Data::Recipient::OrHash]
-          ).void
-        end
-        attr_writer :recipients
-
-        # QUEUED: the batch is accepted. A request that carried scheduled_at is QUEUED
-        # here too; each message moves to SCHEDULED once it is held, as GET
-        # /v3/messages/{id} and the message.scheduled webhook report.
-        sig { returns(T.nilable(String)) }
-        attr_reader :status
-
-        sig { params(status: String).void }
-        attr_writer :status
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :template_id
-
-        sig { params(template_id: String).void }
-        attr_writer :template_id
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :template_name
-
-        sig { params(template_name: String).void }
-        attr_writer :template_name
-
-        # The result of a multi-recipient send.
-        #
-        # Declared here rather than in the service layer. POST /v3/messages used to
-        # publish MessageSendResult — a type in Common.Services.Messaging.Contracts — so
-        # the public contract was whatever the send service happened to return, and
-        # changing that service for an internal reason changed the API. The service keeps
-        # its result; this is what a caller sees, and the mapping between them is a
-        # decision the endpoint makes.
-        #
-        # The shape of an immediate send: it never has a scheduled_at key. A send that
-        # carried scheduled_at is a ScheduledSendMessageResponse, and the endpoint decides
-        # which of the two to answer with. From always returns this type.
-        sig do
-          params(
-            recipients:
-              T::Array[Sentdm::MessageSendResponse::Data::Recipient::OrHash],
-            status: String,
-            template_id: String,
-            template_name: String
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          recipients: nil,
-          # QUEUED: the batch is accepted. A request that carried scheduled_at is QUEUED
-          # here too; each message moves to SCHEDULED once it is held, as GET
-          # /v3/messages/{id} and the message.scheduled webhook report.
-          status: nil,
-          template_id: nil,
-          template_name: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              recipients:
-                T::Array[Sentdm::MessageSendResponse::Data::Recipient],
-              status: String,
-              template_id: String,
-              template_name: String
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class Recipient < Sentdm::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Sentdm::MessageSendResponse::Data::Recipient,
-                Sentdm::Internal::AnyHash
-              )
-            end
-
-          # Resolved template body for this recipient's channel, or null when the channel is
-          # auto-detected.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :body
-
-          # Channel this message will be sent on — sms, whatsapp — or null to auto-detect.
-          sig { returns(T.nilable(String)) }
-          attr_accessor :channel
-
-          # Identifier for tracking this recipient's message.
-          sig { returns(T.nilable(String)) }
-          attr_reader :message_id
-
-          sig { params(message_id: String).void }
-          attr_writer :message_id
-
-          # Phone number in E.164 format.
-          sig { returns(T.nilable(String)) }
-          attr_reader :to
-
-          sig { params(to: String).void }
-          attr_writer :to
-
-          # What one recipient of a send got, as the API reports it.
-          sig do
-            params(
-              body: T.nilable(String),
-              channel: T.nilable(String),
-              message_id: String,
-              to: String
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            # Resolved template body for this recipient's channel, or null when the channel is
-            # auto-detected.
-            body: nil,
-            # Channel this message will be sent on — sms, whatsapp — or null to auto-detect.
-            channel: nil,
-            # Identifier for tracking this recipient's message.
-            message_id: nil,
-            # Phone number in E.164 format.
-            to: nil
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                body: T.nilable(String),
-                channel: T.nilable(String),
-                message_id: String,
-                to: String
-              }
-            )
-          end
-          def to_hash
-          end
-        end
-      end
     end
   end
 end

data/rbi/sentdm/models/message_send_result.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MessageSendResult < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::MessageSendResult, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Array[Sentdm::MessageRecipient])) }
+      attr_reader :recipients
+
+      sig do
+        params(recipients: T::Array[Sentdm::MessageRecipient::OrHash]).void
+      end
+      attr_writer :recipients
+
+      # QUEUED: the batch is accepted. A request that carried scheduled_at is QUEUED
+      # here too; each message moves to SCHEDULED once it is held, as GET
+      # /v3/messages/{id} and the message.scheduled webhook report.
+      sig { returns(T.nilable(String)) }
+      attr_reader :status
+
+      sig { params(status: String).void }
+      attr_writer :status
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :template_id
+
+      sig { params(template_id: String).void }
+      attr_writer :template_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :template_name
+
+      sig { params(template_name: String).void }
+      attr_writer :template_name
+
+      # The result of a multi-recipient send.
+      #
+      # Declared here rather than in the service layer. POST /v3/messages used to
+      # publish MessageSendResult — a type in Common.Services.Messaging.Contracts — so
+      # the public contract was whatever the send service happened to return, and
+      # changing that service for an internal reason changed the API. The service keeps
+      # its result; this is what a caller sees, and the mapping between them is a
+      # decision the endpoint makes.
+      #
+      # The shape of an immediate send: it never has a scheduled_at key. A send that
+      # carried scheduled_at is a ScheduledSendMessageResponse, and the endpoint decides
+      # which of the two to answer with. From always returns this type.
+      sig do
+        params(
+          recipients: T::Array[Sentdm::MessageRecipient::OrHash],
+          status: String,
+          template_id: String,
+          template_name: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        recipients: nil,
+        # QUEUED: the batch is accepted. A request that carried scheduled_at is QUEUED
+        # here too; each message moves to SCHEDULED once it is held, as GET
+        # /v3/messages/{id} and the message.scheduled webhook report.
+        status: nil,
+        template_id: nil,
+        template_name: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            recipients: T::Array[Sentdm::MessageRecipient],
+            status: String,
+            template_id: String,
+            template_name: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end