sentdm 0.45.0 → 0.46.0

data/rbi/sentdm/models/sender_profile_update_params.rbi

@@ -0,0 +1,96 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class SenderProfileUpdateParams < Sentdm::Internal::Type::BaseModel
+      extend Sentdm::Internal::Type::RequestParameters::Converter
+      include Sentdm::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::SenderProfileUpdateParams, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # Who is notified about this profile's events: ORGANIZATION, SENDER_PROFILE, or
+      # ORGANIZATION_AND_SENDER_PROFILE. Cannot be cleared — a supplied value must be
+      # one of those.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :notifications
+
+      # 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
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :short_name
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :idempotency_key
+
+      sig { params(idempotency_key: String).void }
+      attr_writer :idempotency_key
+
+      sig do
+        params(
+          id: String,
+          description: T.nilable(String),
+          name: String,
+          notifications: T.nilable(String),
+          sandbox: T::Boolean,
+          short_name: T.nilable(String),
+          idempotency_key: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        description: nil,
+        name: nil,
+        # Who is notified about this profile's events: ORGANIZATION, SENDER_PROFILE, or
+        # ORGANIZATION_AND_SENDER_PROFILE. Cannot be cleared — a supplied value must be
+        # one of those.
+        notifications: nil,
+        # Sandbox flag - when true, the operation is simulated without side effects Useful
+        # for testing integrations without actual execution
+        sandbox: nil,
+        short_name: nil,
+        idempotency_key: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            description: T.nilable(String),
+            name: String,
+            notifications: T.nilable(String),
+            sandbox: T::Boolean,
+            short_name: T.nilable(String),
+            idempotency_key: String,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/sender_profile_whatsapp.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class SenderProfileWhatsapp < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::SenderProfileWhatsapp, Sentdm::Internal::AnyHash)
+        end
+
+      # The Meta phone-number id this profile sends from. Must already be registered
+      # under WabaId.
+      #
+      # Optional. Omit it to attach the account now and settle the number later: the
+      # channel reads as ACTION_NEEDED with CHANNEL_007, and the profile's WhatsApp
+      # messages fail until a number is named. They do not fall back to the
+      # organization's account. Nothing picks one on your behalf.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :phone_number_id
+
+      # WhatsApp Business Account id — one of the accounts shared into your
+      # organization. Required: the organization holds one per client, and nothing but
+      # the caller says which belongs to this profile.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :waba_id
+
+      # The profile's own WhatsApp Business Account, named by the two identifiers the
+      # organization cannot answer for you.
+      #
+      # No mode: a profile's WABA is its own or it has none. Sharing the organization's
+      # would mean sharing its inbox and its throughput, which makes the two
+      # indistinguishable to a recipient — so inheriting is not offered rather than
+      # refused.
+      #
+      # Everything derivable is derived. Whenever this block is present, the solution
+      # the account arrived through, the client business portfolio that owns it, the
+      # access token and that token's expiry are all resolved from the organization by
+      # IPartnerSolutionService.ResolveAccountCredentialsAsync — the first two off the
+      # org's shared-account listing, the token minted against the org's own solution.
+      # They were previously asked for and are no longer accepted: solution_id and
+      # owner_business_id are Meta's answer about provenance, so taking them from the
+      # caller let a request assert a partnership Meta disagreed with, and the listing
+      # has to be consulted regardless because it is what proves the account is one this
+      # organization may reach.
+      #
+      # No access token, and there never was one here: it is minted per client business
+      # portfolio and rotates roughly every sixty days, so a pasted value would be stale
+      # before it was useful. Asking a customer to mint a System User token in Meta
+      # Business Manager is skilled work in a console they were never meant to see, and
+      # it would say nothing about which solution the account came from or when it is
+      # revoked.
+      sig do
+        params(
+          phone_number_id: T.nilable(String),
+          waba_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The Meta phone-number id this profile sends from. Must already be registered
+        # under WabaId.
+        #
+        # Optional. Omit it to attach the account now and settle the number later: the
+        # channel reads as ACTION_NEEDED with CHANNEL_007, and the profile's WhatsApp
+        # messages fail until a number is named. They do not fall back to the
+        # organization's account. Nothing picks one on your behalf.
+        phone_number_id: nil,
+        # WhatsApp Business Account id — one of the accounts shared into your
+        # organization. Required: the organization holds one per client, and nothing but
+        # the caller says which belongs to this profile.
+        waba_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { phone_number_id: T.nilable(String), waba_id: T.nilable(String) }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/sender_profiles_list.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class SenderProfilesList < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::SenderProfilesList, Sentdm::Internal::AnyHash)
+        end
+
+      # Pagination metadata for list responses
+      sig { returns(T.nilable(Sentdm::PaginationMeta)) }
+      attr_reader :pagination
+
+      sig { params(pagination: Sentdm::PaginationMeta::OrHash).void }
+      attr_writer :pagination
+
+      # The sender_profiles on this page.
+      sig { returns(T.nilable(T::Array[Sentdm::SenderProfile])) }
+      attr_reader :sender_profiles
+
+      sig do
+        params(sender_profiles: T::Array[Sentdm::SenderProfile::OrHash]).void
+      end
+      attr_writer :sender_profiles
+
+      # A paginated list of sender profiles.
+      sig do
+        params(
+          pagination: Sentdm::PaginationMeta::OrHash,
+          sender_profiles: T::Array[Sentdm::SenderProfile::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Pagination metadata for list responses
+        pagination: nil,
+        # The sender_profiles on this page.
+        sender_profiles: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            pagination: Sentdm::PaginationMeta,
+            sender_profiles: T::Array[Sentdm::SenderProfile]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/tcr_brand_identity_status.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module TcrBrandIdentityStatus
+      extend Sentdm::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Sentdm::TcrBrandIdentityStatus) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      SELF_DECLARED =
+        T.let(:SELF_DECLARED, Sentdm::TcrBrandIdentityStatus::TaggedSymbol)
+      UNVERIFIED =
+        T.let(:UNVERIFIED, Sentdm::TcrBrandIdentityStatus::TaggedSymbol)
+      VERIFIED = T.let(:VERIFIED, Sentdm::TcrBrandIdentityStatus::TaggedSymbol)
+      VETTED_VERIFIED =
+        T.let(:VETTED_VERIFIED, Sentdm::TcrBrandIdentityStatus::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[Sentdm::TcrBrandIdentityStatus::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/sentdm/models/tcr_brand_status.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module TcrBrandStatus
+      extend Sentdm::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Sentdm::TcrBrandStatus) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      ACTIVE = T.let(:ACTIVE, Sentdm::TcrBrandStatus::TaggedSymbol)
+      INACTIVE = T.let(:INACTIVE, Sentdm::TcrBrandStatus::TaggedSymbol)
+      SUSPENDED = T.let(:SUSPENDED, Sentdm::TcrBrandStatus::TaggedSymbol)
+
+      sig { override.returns(T::Array[Sentdm::TcrBrandStatus::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/sentdm/models/tcr_campaign_status.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module TcrCampaignStatus
+      extend Sentdm::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Sentdm::TcrCampaignStatus) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      SENT_CREATED =
+        T.let(:SENT_CREATED, Sentdm::TcrCampaignStatus::TaggedSymbol)
+      ACTIVE = T.let(:ACTIVE, Sentdm::TcrCampaignStatus::TaggedSymbol)
+      EXPIRED = T.let(:EXPIRED, Sentdm::TcrCampaignStatus::TaggedSymbol)
+
+      sig do
+        override.returns(T::Array[Sentdm::TcrCampaignStatus::TaggedSymbol])
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/sentdm/models/template_body.rbi

@@ -13,10 +13,12 @@ module Sentdm
       # this slot MMS renders the shared or SMS body, so it is only needed for
       # MMS-specific copy, a subject or attachments. When present it replaces that body
       # on MMS rather than adding to it.
-      sig { returns(T.nilable(Sentdm::TemplateBody::Mms)) }
+      sig { returns(T.nilable(Sentdm::TemplateMmsBodyContent)) }
       attr_reader :mms
 
-      sig { params(mms: T.nilable(Sentdm::TemplateBody::Mms::OrHash)).void }
+      sig do
+        params(mms: T.nilable(Sentdm::TemplateMmsBodyContent::OrHash)).void
+      end
       attr_writer :mms
 
       # The shared body, used for every channel. One half of the choice described above.
@@ -67,7 +69,7 @@ module Sentdm
       # the copy, but cannot stand alone.
       sig do
         params(
-          mms: T.nilable(Sentdm::TemplateBody::Mms::OrHash),
+          mms: T.nilable(Sentdm::TemplateMmsBodyContent::OrHash),
           multi_channel: T.nilable(Sentdm::TemplateBodyContent::OrHash),
           rcs: T.nilable(Sentdm::TemplateBodyContent::OrHash),
           sms: T.nilable(Sentdm::TemplateBodyContent::OrHash),
@@ -99,7 +101,7 @@ module Sentdm
       sig do
         override.returns(
           {
-            mms: T.nilable(Sentdm::TemplateBody::Mms),
+            mms: T.nilable(Sentdm::TemplateMmsBodyContent),
             multi_channel: T.nilable(Sentdm::TemplateBodyContent),
             rcs: T.nilable(Sentdm::TemplateBodyContent),
             sms: T.nilable(Sentdm::TemplateBodyContent),
@@ -109,116 +111,6 @@ 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. Without
-        # this slot MMS renders the shared or SMS body, so it is only needed for
-        # MMS-specific copy, a subject or attachments. When present it replaces that body
-        # on MMS rather than adding to it.
-        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_header.rbi

@@ -31,13 +31,11 @@ module Sentdm
       # 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)) }
+      sig { returns(T.nilable(Sentdm::TemplateHeaderLocation)) }
       attr_reader :location
 
       sig do
-        params(
-          location: T.nilable(Sentdm::TemplateHeader::Location::OrHash)
-        ).void
+        params(location: T.nilable(Sentdm::TemplateHeaderLocation::OrHash)).void
       end
       attr_writer :location
 
@@ -78,7 +76,7 @@ module Sentdm
         params(
           template: String,
           example_url: T.nilable(String),
-          location: T.nilable(Sentdm::TemplateHeader::Location::OrHash),
+          location: T.nilable(Sentdm::TemplateHeaderLocation::OrHash),
           static_resource: T::Boolean,
           type: T.nilable(String),
           variables: T.nilable(T::Array[Sentdm::TemplateVariable::OrHash])
@@ -136,7 +134,7 @@ module Sentdm
           {
             template: String,
             example_url: T.nilable(String),
-            location: T.nilable(Sentdm::TemplateHeader::Location),
+            location: T.nilable(Sentdm::TemplateHeaderLocation),
             static_resource: T::Boolean,
             type: T.nilable(String),
             variables: T.nilable(T::Array[Sentdm::TemplateVariable])
@@ -145,53 +143,6 @@ 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_header_location.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class TemplateHeaderLocation < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::TemplateHeaderLocation, 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

data/rbi/sentdm/models/template_media_item.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class TemplateMediaItem < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::TemplateMediaItem, 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 { override.returns({ media_type: T.nilable(String), url: String }) }
+      def to_hash
+      end
+    end
+  end
+end