sentdm 0.32.0 → 0.34.0

data/rbi/sentdm/models/template_body.rbi

@@ -6,6 +6,19 @@ module Sentdm
       OrHash =
         T.type_alias { T.any(Sentdm::TemplateBody, Sentdm::Internal::AnyHash) }
 
+      # MMS-specific content — subject, text and attachments.
+      #
+      # Like Rcs, an override that cannot stand on its own: a template still needs a
+      # MultiChannel body or the Sms + Whatsapp pair to be deliverable at all. Unlike
+      # Rcs, it has no fallback at send time — MMS with no media is a more expensive
+      # SMS, so a template without this slot is deliberately not MMS-capable and never
+      # produces an MMS route candidate.
+      sig { returns(T.nilable(Sentdm::TemplateBody::Mms)) }
+      attr_reader :mms
+
+      sig { params(mms: T.nilable(Sentdm::TemplateBody::Mms::OrHash)).void }
+      attr_writer :mms
+
       # The shared body, used for every channel. One half of the choice described above.
       sig { returns(T.nilable(Sentdm::TemplateBodyContent)) }
       attr_reader :multi_channel
@@ -54,6 +67,7 @@ module Sentdm
       # the copy, but cannot stand alone.
       sig do
         params(
+          mms: T.nilable(Sentdm::TemplateBody::Mms::OrHash),
           multi_channel: T.nilable(Sentdm::TemplateBodyContent::OrHash),
           rcs: T.nilable(Sentdm::TemplateBodyContent::OrHash),
           sms: T.nilable(Sentdm::TemplateBodyContent::OrHash),
@@ -61,6 +75,14 @@ module Sentdm
         ).returns(T.attached_class)
       end
       def self.new(
+        # MMS-specific content — subject, text and attachments.
+        #
+        # Like Rcs, an override that cannot stand on its own: a template still needs a
+        # MultiChannel body or the Sms + Whatsapp pair to be deliverable at all. Unlike
+        # Rcs, it has no fallback at send time — MMS with no media is a more expensive
+        # SMS, so a template without this slot is deliberately not MMS-capable and never
+        # produces an MMS route candidate.
+        mms: nil,
         # The shared body, used for every channel. One half of the choice described above.
         multi_channel: nil,
         # RCS-specific copy that overrides the chosen strategy for RCS only. The one true
@@ -77,6 +99,7 @@ module Sentdm
       sig do
         override.returns(
           {
+            mms: T.nilable(Sentdm::TemplateBody::Mms),
             multi_channel: T.nilable(Sentdm::TemplateBodyContent),
             rcs: T.nilable(Sentdm::TemplateBodyContent),
             sms: T.nilable(Sentdm::TemplateBodyContent),
@@ -86,6 +109,116 @@ module Sentdm
       end
       def to_hash
       end
+
+      class Mms < Sentdm::Models::TemplateBodyContent
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::TemplateBody::Mms, Sentdm::Internal::AnyHash)
+          end
+
+        # Attachments carried by every send on this template, in order. A per-send
+        # media_urls on the request replaces this list rather than adding to it, so a
+        # template can hold a default creative and a caller can still send something
+        # recipient-specific.
+        sig { returns(T.nilable(T::Array[Sentdm::TemplateBody::Mms::Media])) }
+        attr_accessor :media
+
+        # MMS subject line. Optional — most handsets render it above the body, some ignore
+        # it entirely. Deliberately its own field rather than riding TemplateHeader: the
+        # header is authored once and shared across every channel, and carries Meta's
+        # 60-character cap plus its no-newline, no-emoji text rules, none of which
+        # describe an MMS subject.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :subject
+
+        # MMS-specific content — subject, text and attachments.
+        #
+        # Like Rcs, an override that cannot stand on its own: a template still needs a
+        # MultiChannel body or the Sms + Whatsapp pair to be deliverable at all. Unlike
+        # Rcs, it has no fallback at send time — MMS with no media is a more expensive
+        # SMS, so a template without this slot is deliberately not MMS-capable and never
+        # produces an MMS route candidate.
+        sig do
+          params(
+            media:
+              T.nilable(T::Array[Sentdm::TemplateBody::Mms::Media::OrHash]),
+            subject: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Attachments carried by every send on this template, in order. A per-send
+          # media_urls on the request replaces this list rather than adding to it, so a
+          # template can hold a default creative and a caller can still send something
+          # recipient-specific.
+          media: nil,
+          # MMS subject line. Optional — most handsets render it above the body, some ignore
+          # it entirely. Deliberately its own field rather than riding TemplateHeader: the
+          # header is authored once and shared across every channel, and carries Meta's
+          # 60-character cap plus its no-newline, no-emoji text rules, none of which
+          # describe an MMS subject.
+          subject: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              media: T.nilable(T::Array[Sentdm::TemplateBody::Mms::Media]),
+              subject: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Media < Sentdm::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(Sentdm::TemplateBody::Mms::Media, Sentdm::Internal::AnyHash)
+            end
+
+          # One of MmsMediaTypes. Advisory: the carrier reads the Content-Type off the
+          # fetched object, not this field. It exists so an authoring UI can render the
+          # right preview and so a reviewer can see what was intended.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :media_type
+
+          # Publicly fetchable https URL. The carrier's MMSC fetches this at send time, so
+          # it has to stay reachable and unauthenticated for the life of the send —
+          # including retries and a DLQ replay — which is why a presigned URL is not a valid
+          # value here.
+          sig { returns(T.nilable(String)) }
+          attr_reader :url
+
+          sig { params(url: String).void }
+          attr_writer :url
+
+          # One attachment on an MMS template body.
+          sig do
+            params(media_type: T.nilable(String), url: String).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # One of MmsMediaTypes. Advisory: the carrier reads the Content-Type off the
+            # fetched object, not this field. It exists so an authoring UI can render the
+            # right preview and so a reviewer can see what was intended.
+            media_type: nil,
+            # Publicly fetchable https URL. The carrier's MMSC fetches this at send time, so
+            # it has to stay reachable and unauthenticated for the life of the send —
+            # including retries and a DLQ replay — which is why a presigned URL is not a valid
+            # value here.
+            url: nil
+          )
+          end
+
+          sig do
+            override.returns({ media_type: T.nilable(String), url: String })
+          end
+          def to_hash
+          end
+        end
+      end
     end
   end
 end

data/rbi/sentdm/models/template_create_params.rbi

@@ -11,6 +11,15 @@ module Sentdm
           T.any(Sentdm::TemplateCreateParams, Sentdm::Internal::AnyHash)
         end
 
+      # Create this template automatically on every sender profile of the organization,
+      # now and in future (default: false). Accepted only from an organization that has
+      # been enabled for it, and only at creation — it cannot be changed afterwards.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :auto_create_for_sp
+
+      sig { params(auto_create_for_sp: T::Boolean).void }
+      attr_writer :auto_create_for_sp
+
       # Template category: MARKETING, UTILITY, AUTHENTICATION (optional, auto-detected
       # if not provided)
       sig { returns(T.nilable(String)) }
@@ -61,6 +70,7 @@ module Sentdm
 
       sig do
         params(
+          auto_create_for_sp: T::Boolean,
           category: T.nilable(String),
           creation_source: T.nilable(String),
           definition: Sentdm::TemplateDefinition::OrHash,
@@ -73,6 +83,10 @@ module Sentdm
         ).returns(T.attached_class)
       end
       def self.new(
+        # Create this template automatically on every sender profile of the organization,
+        # now and in future (default: false). Accepted only from an organization that has
+        # been enabled for it, and only at creation — it cannot be changed afterwards.
+        auto_create_for_sp: nil,
         # Template category: MARKETING, UTILITY, AUTHENTICATION (optional, auto-detected
         # if not provided)
         category: nil,
@@ -97,6 +111,7 @@ module Sentdm
       sig do
         override.returns(
           {
+            auto_create_for_sp: T::Boolean,
             category: T.nilable(String),
             creation_source: T.nilable(String),
             definition: Sentdm::TemplateDefinition,

data/rbi/sentdm/models/template_header.rbi

@@ -13,7 +13,59 @@ module Sentdm
       sig { returns(String) }
       attr_accessor :template
 
-      # The type of header (e.g., "text", "image", "video", "document")
+      # Request-only. The s.dm URL of the asset Meta's reviewers see —
+      # https://s.dm/s/{ID}, eight uppercase characters, uploaded to s.dm out of band.
+      # NormalizeRichHeader folds it into the synthesized media variable's Props.Sample
+      # and clears it, so it never persists and a stored definition is indistinguishable
+      # from an imported one.
+      #
+      # Stricter than the send path on purpose:
+      # TemplateUtils.ValidateMediaVariableValues accepts any absolute https URL for the
+      # per-send asset, because that one is the customer's and may live behind a signed
+      # CDN link. This one is the review sample, has to outlive every resubmission, and
+      # so must be ours. Do not "fix" one to match the other.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :example_url
+
+      # The map pin a location header drops. Meta wants none of this at creation — the
+      # component is just {"type":"header","format":"location"} — so these values exist
+      # for Sent: a preview, and the default a StaticResource header falls back to at
+      # send.
+      sig { returns(T.nilable(Sentdm::TemplateHeader::Location)) }
+      attr_reader :location
+
+      sig do
+        params(
+          location: T.nilable(Sentdm::TemplateHeader::Location::OrHash)
+        ).void
+      end
+      attr_writer :location
+
+      # Whether the asset registered at creation is reused when a caller omits the
+      # header's variable at send time. Default false — the caller must supply it per
+      # message, which is the behaviour every existing template has. Written only when
+      # true, so a default-valued header serializes byte-identically to one imported
+      # from Meta.
+      #
+      # Stored and validated but not yet honoured at send: that lands with the Resumable
+      # Upload work, alongside the code that lets such a template be approved in the
+      # first place.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :static_resource
+
+      sig { params(static_resource: T::Boolean).void }
+      attr_writer :static_resource
+
+      # The kind of header. One of:
+      #
+      # text — up to 60 characters, at most one variable. image — png, jpg or jpeg.
+      # Needs ExampleUrl. video — mp4. Needs ExampleUrl. gif — mp4, max 3.5MB. WhatsApp
+      # renders larger files as an ordinary video. Needs ExampleUrl. document — pdf or
+      # docx; only the first page is shown as a thumbnail, so pdf is the practical
+      # choice. Needs ExampleUrl. location — a map pin, supplied through Location.
+      #
+      # Kept lowercase because MetaToTemplateConverter writes Meta's format through
+      # ToLowerInvariant() into this field on import, and the two are compared directly.
       sig { returns(T.nilable(String)) }
       attr_accessor :type
 
@@ -25,6 +77,9 @@ module Sentdm
       sig do
         params(
           template: String,
+          example_url: T.nilable(String),
+          location: T.nilable(Sentdm::TemplateHeader::Location::OrHash),
+          static_resource: T::Boolean,
           type: T.nilable(String),
           variables: T.nilable(T::Array[Sentdm::TemplateVariable::OrHash])
         ).returns(T.attached_class)
@@ -33,7 +88,43 @@ module Sentdm
         # The header template text with optional variable placeholders (e.g., "Welcome to
         # {{0:variable}}")
         template:,
-        # The type of header (e.g., "text", "image", "video", "document")
+        # Request-only. The s.dm URL of the asset Meta's reviewers see —
+        # https://s.dm/s/{ID}, eight uppercase characters, uploaded to s.dm out of band.
+        # NormalizeRichHeader folds it into the synthesized media variable's Props.Sample
+        # and clears it, so it never persists and a stored definition is indistinguishable
+        # from an imported one.
+        #
+        # Stricter than the send path on purpose:
+        # TemplateUtils.ValidateMediaVariableValues accepts any absolute https URL for the
+        # per-send asset, because that one is the customer's and may live behind a signed
+        # CDN link. This one is the review sample, has to outlive every resubmission, and
+        # so must be ours. Do not "fix" one to match the other.
+        example_url: nil,
+        # The map pin a location header drops. Meta wants none of this at creation — the
+        # component is just {"type":"header","format":"location"} — so these values exist
+        # for Sent: a preview, and the default a StaticResource header falls back to at
+        # send.
+        location: nil,
+        # Whether the asset registered at creation is reused when a caller omits the
+        # header's variable at send time. Default false — the caller must supply it per
+        # message, which is the behaviour every existing template has. Written only when
+        # true, so a default-valued header serializes byte-identically to one imported
+        # from Meta.
+        #
+        # Stored and validated but not yet honoured at send: that lands with the Resumable
+        # Upload work, alongside the code that lets such a template be approved in the
+        # first place.
+        static_resource: nil,
+        # The kind of header. One of:
+        #
+        # text — up to 60 characters, at most one variable. image — png, jpg or jpeg.
+        # Needs ExampleUrl. video — mp4. Needs ExampleUrl. gif — mp4, max 3.5MB. WhatsApp
+        # renders larger files as an ordinary video. Needs ExampleUrl. document — pdf or
+        # docx; only the first page is shown as a thumbnail, so pdf is the practical
+        # choice. Needs ExampleUrl. location — a map pin, supplied through Location.
+        #
+        # Kept lowercase because MetaToTemplateConverter writes Meta's format through
+        # ToLowerInvariant() into this field on import, and the two are compared directly.
         type: nil,
         # List of variables used in the header template
         variables: nil
@@ -44,6 +135,9 @@ module Sentdm
         override.returns(
           {
             template: String,
+            example_url: T.nilable(String),
+            location: T.nilable(Sentdm::TemplateHeader::Location),
+            static_resource: T::Boolean,
             type: T.nilable(String),
             variables: T.nilable(T::Array[Sentdm::TemplateVariable])
           }
@@ -51,6 +145,53 @@ module Sentdm
       end
       def to_hash
       end
+
+      class Location < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::TemplateHeader::Location, Sentdm::Internal::AnyHash)
+          end
+
+        sig { returns(String) }
+        attr_accessor :address
+
+        sig { returns(String) }
+        attr_accessor :latitude
+
+        sig { returns(String) }
+        attr_accessor :longitude
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        # The map pin a location header drops. Meta wants none of this at creation — the
+        # component is just {"type":"header","format":"location"} — so these values exist
+        # for Sent: a preview, and the default a StaticResource header falls back to at
+        # send.
+        sig do
+          params(
+            address: String,
+            latitude: String,
+            longitude: String,
+            name: String
+          ).returns(T.attached_class)
+        end
+        def self.new(address:, latitude:, longitude:, name:)
+        end
+
+        sig do
+          override.returns(
+            {
+              address: String,
+              latitude: String,
+              longitude: String,
+              name: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
     end
   end
 end

data/rbi/sentdm/models/template_variable.rbi

@@ -86,6 +86,11 @@ module Sentdm
         sig { returns(String) }
         attr_accessor :media_type
 
+        # Example value substituted into the template when previewing it and when
+        # submitting it to Meta for review. Free text by nature, so the converter accepts
+        # a JSON number or boolean here and normalizes it — see
+        # JsonScalarToStringConverter for why — and guarantees it is always serialized
+        # back out as a JSON string.
         sig { returns(String) }
         attr_accessor :sample
 
@@ -117,6 +122,11 @@ module Sentdm
         end
         def self.new(
           media_type:,
+          # Example value substituted into the template when previewing it and when
+          # submitting it to Meta for review. Free text by nature, so the converter accepts
+          # a JSON number or boolean here and normalizes it — see
+          # JsonScalarToStringConverter for why — and guarantees it is always serialized
+          # back out as a JSON string.
           sample:,
           url:,
           variable_type:,

data/rbi/sentdm/models/webhook_create_params.rbi

@@ -46,6 +46,19 @@ module Sentdm
       sig { params(sandbox: T::Boolean).void }
       attr_writer :sandbox
 
+      # Request-only: the events an organization webhook's sender profile clones
+      # receive, one clone per existing and future profile. Responses never return it.
+      sig { returns(T.nilable(Sentdm::WebhookCreateParams::SenderProfile)) }
+      attr_reader :sender_profile
+
+      sig do
+        params(
+          sender_profile:
+            T.nilable(Sentdm::WebhookCreateParams::SenderProfile::OrHash)
+        ).void
+      end
+      attr_writer :sender_profile
+
       sig { returns(T.nilable(Integer)) }
       attr_reader :timeout_seconds
 
@@ -72,6 +85,8 @@ module Sentdm
           event_types: T::Array[String],
           retry_count: Integer,
           sandbox: T::Boolean,
+          sender_profile:
+            T.nilable(Sentdm::WebhookCreateParams::SenderProfile::OrHash),
           timeout_seconds: Integer,
           idempotency_key: String,
           x_profile_id: String,
@@ -87,6 +102,9 @@ module Sentdm
         # Sandbox flag - when true, the operation is simulated without side effects Useful
         # for testing integrations without actual execution
         sandbox: nil,
+        # Request-only: the events an organization webhook's sender profile clones
+        # receive, one clone per existing and future profile. Responses never return it.
+        sender_profile: nil,
         timeout_seconds: nil,
         idempotency_key: nil,
         x_profile_id: nil,
@@ -103,6 +121,8 @@ module Sentdm
             event_types: T::Array[String],
             retry_count: Integer,
             sandbox: T::Boolean,
+            sender_profile:
+              T.nilable(Sentdm::WebhookCreateParams::SenderProfile),
             timeout_seconds: Integer,
             idempotency_key: String,
             x_profile_id: String,
@@ -112,6 +132,47 @@ module Sentdm
       end
       def to_hash
       end
+
+      class SenderProfile < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::WebhookCreateParams::SenderProfile,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Hash[Symbol, T::Array[String]])) }
+        attr_accessor :event_filters
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :event_types
+
+        sig { params(event_types: T::Array[String]).void }
+        attr_writer :event_types
+
+        # Request-only: the events an organization webhook's sender profile clones
+        # receive, one clone per existing and future profile. Responses never return it.
+        sig do
+          params(
+            event_filters: T.nilable(T::Hash[Symbol, T::Array[String]]),
+            event_types: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(event_filters: nil, event_types: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              event_filters: T.nilable(T::Hash[Symbol, T::Array[String]]),
+              event_types: T::Array[String]
+            }
+          )
+        end
+        def to_hash
+        end
+      end
     end
   end
 end