sentdm 0.45.0 → 0.46.0

data/rbi/sentdm/models/profiles/brand_campaign.rbi

@@ -87,11 +87,7 @@ module Sentdm
         sig { returns(T.nilable(String)) }
         attr_accessor :privacy_policy_link
 
-        sig do
-          returns(
-            T.nilable(Sentdm::Profiles::BrandCampaign::Status::TaggedSymbol)
-          )
-        end
+        sig { returns(T.nilable(Sentdm::TcrCampaignStatus::TaggedSymbol)) }
         attr_accessor :status
 
         sig { returns(T.nilable(Time)) }
@@ -163,8 +159,7 @@ module Sentdm
             optout_keywords: T.nilable(String),
             optout_message: T.nilable(String),
             privacy_policy_link: T.nilable(String),
-            status:
-              T.nilable(Sentdm::Profiles::BrandCampaign::Status::OrSymbol),
+            status: T.nilable(Sentdm::TcrCampaignStatus::OrSymbol),
             submitted_at: T.nilable(Time),
             submitted_to_tcr: T::Boolean,
             tcr_campaign_id: T.nilable(String),
@@ -241,10 +236,7 @@ module Sentdm
               optout_keywords: T.nilable(String),
               optout_message: T.nilable(String),
               privacy_policy_link: T.nilable(String),
-              status:
-                T.nilable(
-                  Sentdm::Profiles::BrandCampaign::Status::TaggedSymbol
-                ),
+              status: T.nilable(Sentdm::TcrCampaignStatus::TaggedSymbol),
               submitted_at: T.nilable(Time),
               submitted_to_tcr: T::Boolean,
               tcr_campaign_id: T.nilable(String),
@@ -259,40 +251,6 @@ module Sentdm
         end
         def to_hash
         end
-
-        module Status
-          extend Sentdm::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, Sentdm::Profiles::BrandCampaign::Status)
-            end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-          SENT_CREATED =
-            T.let(
-              :SENT_CREATED,
-              Sentdm::Profiles::BrandCampaign::Status::TaggedSymbol
-            )
-          ACTIVE =
-            T.let(
-              :ACTIVE,
-              Sentdm::Profiles::BrandCampaign::Status::TaggedSymbol
-            )
-          EXPIRED =
-            T.let(
-              :EXPIRED,
-              Sentdm::Profiles::BrandCampaign::Status::TaggedSymbol
-            )
-
-          sig do
-            override.returns(
-              T::Array[Sentdm::Profiles::BrandCampaign::Status::TaggedSymbol]
-            )
-          end
-          def self.values
-          end
-        end
       end
     end
   end

data/rbi/sentdm/models/profiles_list.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ProfilesList < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::ProfilesList, Sentdm::Internal::AnyHash) }
+
+      # 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 profiles on this page.
+      sig { returns(T.nilable(T::Array[Sentdm::ProfileDetail])) }
+      attr_reader :profiles
+
+      sig { params(profiles: T::Array[Sentdm::ProfileDetail::OrHash]).void }
+      attr_writer :profiles
+
+      # The profiles in the organization.
+      sig do
+        params(
+          pagination: Sentdm::PaginationMeta::OrHash,
+          profiles: T::Array[Sentdm::ProfileDetail::OrHash]
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Pagination metadata for list responses
+        pagination: nil,
+        # The profiles on this page.
+        profiles: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            pagination: Sentdm::PaginationMeta,
+            profiles: T::Array[Sentdm::ProfileDetail]
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/sender_profile.rbi

@@ -0,0 +1,204 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class SenderProfile < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::SenderProfile, Sentdm::Internal::AnyHash) }
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # The API key for this profile.
+      #
+      # Returned by create and by nothing else. It is shown once; a read that repeated
+      # it would turn every profile list into a credential dump and put the key into any
+      # log or cache that keeps a response body.
+      #
+      # Omitted rather than null on a read. A key field that is always present and
+      # always empty suggests it could be populated, which is an invitation to populate
+      # it; absent says there is nothing to look for. Doing it with a serializer
+      # condition rather than a second response type keeps create and read on one shape,
+      # which is what stops them drifting.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :api_key
+
+      # Who pays for a sender profile's traffic, as a read reports it.
+      #
+      # Its own type, field for field the same as BillingRequest. Same reason as the
+      # brand: a response is not a request, whatever it carries.
+      sig { returns(T.nilable(Sentdm::SenderProfileBilling)) }
+      attr_reader :billing
+
+      sig do
+        params(billing: T.nilable(Sentdm::SenderProfileBilling::OrHash)).void
+      end
+      attr_writer :billing
+
+      # The channels a profile sends on. SMS is a list because a profile can send in
+      # several markets; WhatsApp and RCS are single, because a profile has one business
+      # account and one agent.
+      sig { returns(T.nilable(Sentdm::ChannelsState)) }
+      attr_reader :channels
+
+      sig { params(channels: T.nilable(Sentdm::ChannelsState::OrHash)).void }
+      attr_writer :channels
+
+      # What a market has been given: the identity it registers under, its programme,
+      # and any documents attached.
+      #
+      # What it does not carry is what the market asks for. That is the subject of GET
+      # /v3/compliance/requirements, and it is the same answer for every caller — a
+      # description of what a compliance regime wants, not a record of one customer's
+      # progress through it. It was reported here as well for a while, which put the
+      # same array in six response shapes and left a caller deciding which of two
+      # sources to believe.
+      #
+      # Present on a list read for markets that register (carrying brand and campaign),
+      # but with documents absent — documents are not fetched for a list, because a
+      # catalog lookup and a document read per market would multiply across a page.
+      # Absent documents is distinct from an empty list: absent says they were not
+      # fetched; empty says the market has been given none. The parent object is null
+      # only when the market registers with nobody and compliance was not computed —
+      # nothing to show at all.
+      sig { returns(T.nilable(Sentdm::Channels::SuppliedCompliance)) }
+      attr_reader :compliance
+
+      sig do
+        params(
+          compliance: T.nilable(Sentdm::Channels::SuppliedCompliance::OrHash)
+        ).void
+      end
+      attr_writer :compliance
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :created_at
+
+      sig { params(created_at: Time).void }
+      attr_writer :created_at
+
+      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. Always present — a profile that never chose
+      # reports as ORGANIZATION, the value a create would send to get the default
+      # behaviour.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :notifications
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :organization_id
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :short_name
+
+      # A sender profile as the API reports it — the same document the create call
+      # accepts, plus the read-only facts it cannot: each market's status and what it
+      # still owes.
+      #
+      # No status at the profile, brand or campaign level. Brand and campaign are
+      # identity, and identity has no lifecycle. What has one is the registration of a
+      # sender in a market, and the approval of a channel — so status lives there, where
+      # it says which specific thing is blocked rather than flattening several answers
+      # into one.
+      sig do
+        params(
+          id: String,
+          api_key: T.nilable(String),
+          billing: T.nilable(Sentdm::SenderProfileBilling::OrHash),
+          channels: T.nilable(Sentdm::ChannelsState::OrHash),
+          compliance: T.nilable(Sentdm::Channels::SuppliedCompliance::OrHash),
+          created_at: Time,
+          description: T.nilable(String),
+          name: String,
+          notifications: T.nilable(String),
+          organization_id: T.nilable(String),
+          short_name: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id: nil,
+        # The API key for this profile.
+        #
+        # Returned by create and by nothing else. It is shown once; a read that repeated
+        # it would turn every profile list into a credential dump and put the key into any
+        # log or cache that keeps a response body.
+        #
+        # Omitted rather than null on a read. A key field that is always present and
+        # always empty suggests it could be populated, which is an invitation to populate
+        # it; absent says there is nothing to look for. Doing it with a serializer
+        # condition rather than a second response type keeps create and read on one shape,
+        # which is what stops them drifting.
+        api_key: nil,
+        # Who pays for a sender profile's traffic, as a read reports it.
+        #
+        # Its own type, field for field the same as BillingRequest. Same reason as the
+        # brand: a response is not a request, whatever it carries.
+        billing: nil,
+        # The channels a profile sends on. SMS is a list because a profile can send in
+        # several markets; WhatsApp and RCS are single, because a profile has one business
+        # account and one agent.
+        channels: nil,
+        # What a market has been given: the identity it registers under, its programme,
+        # and any documents attached.
+        #
+        # What it does not carry is what the market asks for. That is the subject of GET
+        # /v3/compliance/requirements, and it is the same answer for every caller — a
+        # description of what a compliance regime wants, not a record of one customer's
+        # progress through it. It was reported here as well for a while, which put the
+        # same array in six response shapes and left a caller deciding which of two
+        # sources to believe.
+        #
+        # Present on a list read for markets that register (carrying brand and campaign),
+        # but with documents absent — documents are not fetched for a list, because a
+        # catalog lookup and a document read per market would multiply across a page.
+        # Absent documents is distinct from an empty list: absent says they were not
+        # fetched; empty says the market has been given none. The parent object is null
+        # only when the market registers with nobody and compliance was not computed —
+        # nothing to show at all.
+        compliance: nil,
+        created_at: nil,
+        description: nil,
+        name: nil,
+        # Who is notified about this profile's events: ORGANIZATION, SENDER_PROFILE, or
+        # ORGANIZATION_AND_SENDER_PROFILE. Always present — a profile that never chose
+        # reports as ORGANIZATION, the value a create would send to get the default
+        # behaviour.
+        notifications: nil,
+        organization_id: nil,
+        short_name: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            api_key: T.nilable(String),
+            billing: T.nilable(Sentdm::SenderProfileBilling),
+            channels: T.nilable(Sentdm::ChannelsState),
+            compliance: T.nilable(Sentdm::Channels::SuppliedCompliance),
+            created_at: Time,
+            description: T.nilable(String),
+            name: String,
+            notifications: T.nilable(String),
+            organization_id: T.nilable(String),
+            short_name: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/sender_profile_billing.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class SenderProfileBilling < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::SenderProfileBilling, Sentdm::Internal::AnyHash)
+        end
+
+      # Whether the organization pays, rather than the profile.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :inherit
+
+      sig { params(inherit: T::Boolean).void }
+      attr_writer :inherit
+
+      # Who pays for a sender profile's traffic, as a read reports it.
+      #
+      # Its own type, field for field the same as BillingRequest. Same reason as the
+      # brand: a response is not a request, whatever it carries.
+      sig { params(inherit: T::Boolean).returns(T.attached_class) }
+      def self.new(
+        # Whether the organization pays, rather than the profile.
+        inherit: nil
+      )
+      end
+
+      sig { override.returns({ inherit: T::Boolean }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/sender_profile_billing_request.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class SenderProfileBillingRequest < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::SenderProfileBillingRequest, Sentdm::Internal::AnyHash)
+        end
+
+      # Whether the parent organization pays. false is the profile paying for itself.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :inherit
+
+      sig { params(inherit: T::Boolean).void }
+      attr_writer :inherit
+
+      # Who pays for what a sender profile sends.
+      #
+      # Ownership reads the same way as BrandRequest and CampaignRequest: inherit: true
+      # is the organization paying; inherit: false (or an empty block) is the profile
+      # paying for itself.
+      #
+      # An absent block is the one place billing differs from brand and campaign: a
+      # profile still has to be paid for, so omitting billing stores
+      # ProfileAndOrganizationBilling — the profile pays first and its organization
+      # covers what the profile's balance cannot (see ResolveStored). { "name": "..." }
+      # stays a complete request.
+      #
+      # Billing carries no fields of its own yet, so a profile paying for itself is {
+      # "inherit": false } — or an empty block, which means the same. That is thinner
+      # than brand and campaign, where supplying data is the act of owning; it becomes
+      # ordinary the moment billing gains a contact or a payment method to carry.
+      sig { params(inherit: T::Boolean).returns(T.attached_class) }
+      def self.new(
+        # Whether the parent organization pays. false is the profile paying for itself.
+        inherit: nil
+      )
+      end
+
+      sig { override.returns({ inherit: T::Boolean }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/sender_profile_channels.rbi

@@ -0,0 +1,163 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class SenderProfileChannels < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::SenderProfileChannels, Sentdm::Internal::AnyHash)
+        end
+
+      # Asks for an RCS agent of the profile's own, optionally with the full order form
+      # inline.
+      #
+      # Two modes, distinguished by whether any field is populated: "rcs": {} — intent
+      # only. Records that the profile wants its own agent; the order form is submitted
+      # separately through POST /v3/channels/rcs once the fields are ready. "rcs": {
+      # ...fields... } — full form. All required fields must be present; the agent is
+      # created alongside the profile in one call. Omitting opt_in_screenshot_url is
+      # allowed.
+      sig { returns(T.nilable(Sentdm::SenderProfileRcs)) }
+      attr_reader :rcs
+
+      sig { params(rcs: T.nilable(Sentdm::SenderProfileRcs::OrHash)).void }
+      attr_writer :rcs
+
+      # One SMS market a profile sends in — a country and a sender type.
+      #
+      # A profile may have several. It is a tenant, not a market: a business sending to
+      # two countries is one customer of yours, and forcing it into two profiles would
+      # give it two API keys, two inboxes and two contact lists for one business. The
+      # platform already assumes many — CustomerChannelProviders is unique on (customer,
+      # channel, iso, number).
+      #
+      # No mode: a sender is the profile's own or it has none. Listing a market is the
+      # request for one.
+      #
+      # Also the discriminator for everything else: the compliance catalog is keyed on
+      # (country, number type), and that pair decides which fields brand accepts and
+      # what compliance is asked for.
+      sig { returns(T.nilable(Sentdm::SenderProfileSMS)) }
+      attr_reader :sms
+
+      sig { params(sms: T.nilable(Sentdm::SenderProfileSMS::OrHash)).void }
+      attr_writer :sms
+
+      # 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 { returns(T.nilable(Sentdm::SenderProfileWhatsapp)) }
+      attr_reader :whatsapp
+
+      sig do
+        params(whatsapp: T.nilable(Sentdm::SenderProfileWhatsapp::OrHash)).void
+      end
+      attr_writer :whatsapp
+
+      # The channels the profile sends on. Each is independently the profile's own or
+      # absent — none can be inherited, so none carries a mode and presence is the whole
+      # of the request.
+      #
+      # A profile can send SMS in several markets, but create takes one — the market it
+      # starts in. Further markets are added through POST /v3/channels/sms with
+      # x-profile-id, and a read returns them all as a list. Create stays singular
+      # permanently rather than being a list that accepts one entry: the constraint is
+      # in the type, and there is no later widening to break the contract.
+      sig do
+        params(
+          rcs: T.nilable(Sentdm::SenderProfileRcs::OrHash),
+          sms: T.nilable(Sentdm::SenderProfileSMS::OrHash),
+          whatsapp: T.nilable(Sentdm::SenderProfileWhatsapp::OrHash)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Asks for an RCS agent of the profile's own, optionally with the full order form
+        # inline.
+        #
+        # Two modes, distinguished by whether any field is populated: "rcs": {} — intent
+        # only. Records that the profile wants its own agent; the order form is submitted
+        # separately through POST /v3/channels/rcs once the fields are ready. "rcs": {
+        # ...fields... } — full form. All required fields must be present; the agent is
+        # created alongside the profile in one call. Omitting opt_in_screenshot_url is
+        # allowed.
+        rcs: nil,
+        # One SMS market a profile sends in — a country and a sender type.
+        #
+        # A profile may have several. It is a tenant, not a market: a business sending to
+        # two countries is one customer of yours, and forcing it into two profiles would
+        # give it two API keys, two inboxes and two contact lists for one business. The
+        # platform already assumes many — CustomerChannelProviders is unique on (customer,
+        # channel, iso, number).
+        #
+        # No mode: a sender is the profile's own or it has none. Listing a market is the
+        # request for one.
+        #
+        # Also the discriminator for everything else: the compliance catalog is keyed on
+        # (country, number type), and that pair decides which fields brand accepts and
+        # what compliance is asked for.
+        sms: nil,
+        # 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.
+        whatsapp: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            rcs: T.nilable(Sentdm::SenderProfileRcs),
+            sms: T.nilable(Sentdm::SenderProfileSMS),
+            whatsapp: T.nilable(Sentdm::SenderProfileWhatsapp)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end