sentdm 0.45.0 → 0.47.0

data/rbi/sentdm/models/channels/supplied_compliance.rbi

@@ -0,0 +1,180 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class SuppliedCompliance < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::SuppliedCompliance,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # The identity this market registers under, with inherit saying whose it is.
+        #
+        # Reported here rather than on the profile because it belongs to the registration
+        # this market files, and only one market files one. It was a top-level block for a
+        # while, which put a per-registration value beside a list of markets and left a
+        # caller to work out which market it belonged to.
+        #
+        # Absent for a market that registers with nobody — such a market asks for no
+        # identity, so there is none to report. Absent and null mean different things:
+        # absent says this market does not ask, null would say it asks and nothing was
+        # supplied.
+        #
+        # Untyped, like the request side, because its members are declared by the market's
+        # own schema rather than by a C# class. A typed pair here would be a second
+        # definition of what a market wants, free to drift from the one that validates.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_accessor :brand
+
+        # The programme this market registers, with inherit saying whose it is.
+        #
+        # One, not a list. TcrCampaigns permits several and an account built on the admin
+        # side may hold them, but this surface offers one — which is what lets the
+        # market's PATCH be an upsert rather than a collection with an addressable create
+        # behind it. An account holding several is reported as its first and refused on
+        # write, rather than half-edited.
+        #
+        # Carries no id. Nothing addresses a campaign, and an undeclared key would be
+        # refused if the caller sent this object back — which it is meant to be able to
+        # do.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_accessor :campaign
+
+        # Every campaign this market registers, each with inherit saying whose it is —
+        # oldest first.
+        #
+        # A list, because a market can now be on more than one. POST
+        # /v3/channels/sms/compliances/US/TEN_DLC/campaigns adds a campaign of the
+        # customer's own beside the one it has, and a profile running on its
+        # organization's campaign keeps that one when it adds its own. Campaign can only
+        # show one of them, so it stays as it was, for callers that read it, and this is
+        # where the rest are.
+        #
+        # The organization's campaign reads "inherit": true and the customer's own read
+        # "inherit": false. Each entry is the shape of Campaign plus id, the campaign's
+        # own id, so several can be told apart. Campaign carries no id, because it is sent
+        # back to PATCH, which refuses a key it does not declare; this list is read-only.
+        #
+        # Absent for a market that registers with nobody; empty for one that registers and
+        # has no campaign yet.
+        sig { returns(T.nilable(T::Array[T::Hash[Symbol, T.anything]])) }
+        attr_accessor :campaigns
+
+        # What has been supplied for this market.
+        #
+        # Files, not values — the declared halves above carry the values. A document
+        # cannot be a JSON value, so it is sent as multipart on the channel call and
+        # reported here as a reference.
+        #
+        # Absent on a list read, which fetches identity but does not compute compliance
+        # documents per market. Absent and empty mean different things: absent says the
+        # documents were not fetched; empty says the market has been given none.
+        sig { returns(T.nilable(T::Array[Sentdm::Channels::SuppliedDocument])) }
+        attr_accessor :documents
+
+        # 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 do
+          params(
+            brand: T.nilable(T::Hash[Symbol, T.anything]),
+            campaign: T.nilable(T::Hash[Symbol, T.anything]),
+            campaigns: T.nilable(T::Array[T::Hash[Symbol, T.anything]]),
+            documents:
+              T.nilable(T::Array[Sentdm::Channels::SuppliedDocument::OrHash])
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The identity this market registers under, with inherit saying whose it is.
+          #
+          # Reported here rather than on the profile because it belongs to the registration
+          # this market files, and only one market files one. It was a top-level block for a
+          # while, which put a per-registration value beside a list of markets and left a
+          # caller to work out which market it belonged to.
+          #
+          # Absent for a market that registers with nobody — such a market asks for no
+          # identity, so there is none to report. Absent and null mean different things:
+          # absent says this market does not ask, null would say it asks and nothing was
+          # supplied.
+          #
+          # Untyped, like the request side, because its members are declared by the market's
+          # own schema rather than by a C# class. A typed pair here would be a second
+          # definition of what a market wants, free to drift from the one that validates.
+          brand: nil,
+          # The programme this market registers, with inherit saying whose it is.
+          #
+          # One, not a list. TcrCampaigns permits several and an account built on the admin
+          # side may hold them, but this surface offers one — which is what lets the
+          # market's PATCH be an upsert rather than a collection with an addressable create
+          # behind it. An account holding several is reported as its first and refused on
+          # write, rather than half-edited.
+          #
+          # Carries no id. Nothing addresses a campaign, and an undeclared key would be
+          # refused if the caller sent this object back — which it is meant to be able to
+          # do.
+          campaign: nil,
+          # Every campaign this market registers, each with inherit saying whose it is —
+          # oldest first.
+          #
+          # A list, because a market can now be on more than one. POST
+          # /v3/channels/sms/compliances/US/TEN_DLC/campaigns adds a campaign of the
+          # customer's own beside the one it has, and a profile running on its
+          # organization's campaign keeps that one when it adds its own. Campaign can only
+          # show one of them, so it stays as it was, for callers that read it, and this is
+          # where the rest are.
+          #
+          # The organization's campaign reads "inherit": true and the customer's own read
+          # "inherit": false. Each entry is the shape of Campaign plus id, the campaign's
+          # own id, so several can be told apart. Campaign carries no id, because it is sent
+          # back to PATCH, which refuses a key it does not declare; this list is read-only.
+          #
+          # Absent for a market that registers with nobody; empty for one that registers and
+          # has no campaign yet.
+          campaigns: nil,
+          # What has been supplied for this market.
+          #
+          # Files, not values — the declared halves above carry the values. A document
+          # cannot be a JSON value, so it is sent as multipart on the channel call and
+          # reported here as a reference.
+          #
+          # Absent on a list read, which fetches identity but does not compute compliance
+          # documents per market. Absent and empty mean different things: absent says the
+          # documents were not fetched; empty says the market has been given none.
+          documents: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              brand: T.nilable(T::Hash[Symbol, T.anything]),
+              campaign: T.nilable(T::Hash[Symbol, T.anything]),
+              campaigns: T.nilable(T::Array[T::Hash[Symbol, T.anything]]),
+              documents: T.nilable(T::Array[Sentdm::Channels::SuppliedDocument])
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/supplied_document.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class SuppliedDocument < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::SuppliedDocument, Sentdm::Internal::AnyHash)
+          end
+
+        # Identifier of the upload, for fetching it back through the documents endpoints.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :document_id
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :file_name
+
+        # The catalog's name for this document, matching the requirement it satisfies.
+        sig { returns(T.nilable(String)) }
+        attr_reader :key
+
+        sig { params(key: String).void }
+        attr_writer :key
+
+        # A document a market asked for and has been given.
+        sig do
+          params(
+            document_id: T.nilable(String),
+            file_name: T.nilable(String),
+            key: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Identifier of the upload, for fetching it back through the documents endpoints.
+          document_id: nil,
+          file_name: nil,
+          # The catalog's name for this document, matching the requirement it satisfies.
+          key: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              document_id: T.nilable(String),
+              file_name: T.nilable(String),
+              key: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/whatsapp_channel.rbi

@@ -0,0 +1,172 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    WhatsappChannel = Channels::WhatsappChannel
+
+    module Channels
+      class WhatsappChannel < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Channels::WhatsappChannel, Sentdm::Internal::AnyHash)
+          end
+
+        # Derived from the organization's shared-account listing, like SolutionId.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :owner_business_id
+
+        # The Meta phone-number id the profile sends from, or null when the account is
+        # connected but no number has been named yet — which is what a provisioning status
+        # means here.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone_number_id
+
+        # A sentence for reason_code, saying what to do where it is yours. Omitted while
+        # ACTIVE.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason
+
+        # Why the account is not ACTIVE, as a stable code: an ErrorCodes CHANNEL_xxx value
+        # such as CHANNEL_001 (something you owe) or CHANNEL_009 (under review). Switch on
+        # this rather than on reason. Omitted while ACTIVE. Read-only; when nothing more
+        # specific is known it is the generic reason for the status.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :reason_code
+
+        # Derived, not echoed. The request no longer accepts this — it is read off the
+        # organization's shared-account listing at connect time and reported back so a
+        # caller can see which partnership the account actually arrived through.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :solution_id
+
+        # Read-only. Never carries a token — the row holds that and it is not returned.
+        # ACTION_NEEDED when no account is connected or the account has no phone number:
+        # both are yours to do.
+        sig do
+          returns(
+            T.nilable(Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol)
+          )
+        end
+        attr_accessor :status
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :waba_id
+
+        # The profile's WhatsApp account. Its status is Meta's verification state.
+        sig do
+          params(
+            owner_business_id: T.nilable(String),
+            phone_number_id: T.nilable(String),
+            reason: T.nilable(String),
+            reason_code: T.nilable(String),
+            solution_id: T.nilable(String),
+            status:
+              T.nilable(Sentdm::Channels::WhatsappChannel::Status::OrSymbol),
+            waba_id: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Derived from the organization's shared-account listing, like SolutionId.
+          owner_business_id: nil,
+          # The Meta phone-number id the profile sends from, or null when the account is
+          # connected but no number has been named yet — which is what a provisioning status
+          # means here.
+          phone_number_id: nil,
+          # A sentence for reason_code, saying what to do where it is yours. Omitted while
+          # ACTIVE.
+          reason: nil,
+          # Why the account is not ACTIVE, as a stable code: an ErrorCodes CHANNEL_xxx value
+          # such as CHANNEL_001 (something you owe) or CHANNEL_009 (under review). Switch on
+          # this rather than on reason. Omitted while ACTIVE. Read-only; when nothing more
+          # specific is known it is the generic reason for the status.
+          reason_code: nil,
+          # Derived, not echoed. The request no longer accepts this — it is read off the
+          # organization's shared-account listing at connect time and reported back so a
+          # caller can see which partnership the account actually arrived through.
+          solution_id: nil,
+          # Read-only. Never carries a token — the row holds that and it is not returned.
+          # ACTION_NEEDED when no account is connected or the account has no phone number:
+          # both are yours to do.
+          status: nil,
+          waba_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              owner_business_id: T.nilable(String),
+              phone_number_id: T.nilable(String),
+              reason: T.nilable(String),
+              reason_code: T.nilable(String),
+              solution_id: T.nilable(String),
+              status:
+                T.nilable(
+                  Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+                ),
+              waba_id: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Read-only. Never carries a token — the row holds that and it is not returned.
+        # ACTION_NEEDED when no account is connected or the account has no phone number:
+        # both are yours to do.
+        module Status
+          extend Sentdm::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Sentdm::Channels::WhatsappChannel::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          # We are working on it and there is nothing for you to do — a number is being procured, or a registration is being assembled. Minutes to hours.
+          PROVISIONING =
+            T.let(
+              :PROVISIONING,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          # **Waiting on you.** Something the market asks for has not been supplied, a regulator rejected what was, or we have asked you to correct and resubmit your identity data. Nothing progresses until you act. For an SMS market, `GET /v3/channels/sms/{country}/{type}` names what it wants and `PATCH` on the same path supplies it — compliance values, documents and numbers alike.
+          ACTION_NEEDED =
+            T.let(
+              :ACTION_NEEDED,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          # With a regulator or carrier — filed, or assembled and queued for us to file — and their answer is what moves it, to `ACTIVE` or back to `ACTION_NEEDED`. Nothing on your side changes it. Days for SMS, weeks for RCS.
+          PENDING_REVIEW =
+            T.let(
+              :PENDING_REVIEW,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          # Can carry traffic now. A channel a sender profile runs on its organization's reads `ACTIVE` too — it sends, which is what the field is about.
+          ACTIVE =
+            T.let(
+              :ACTIVE,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          # **It had a working sender and no longer does** — the number was released, or the campaign it carried lapsed. Distinct from `PROVISIONING`, which means it has never sent yet: the same absence of a sender, opposite news. Sends will fail until it returns to `ACTIVE`.
+          INACTIVE =
+            T.let(
+              :INACTIVE,
+              Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Sentdm::Channels::WhatsappChannel::Status::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels/whatsapp_create_params.rbi

@@ -0,0 +1,104 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Channels
+      class WhatsappCreateParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Channels::WhatsappCreateParams,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # The Meta phone-number id of the number on WabaId, which assigns it to this
+        # profile as the number it sends from. It is not checked against the account here,
+        # so name the account's number; it is refused if another profile already uses it.
+        #
+        # Optional: omit it to connect the account and settle the number later. Nothing
+        # picks one on your behalf.
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone_number_id
+
+        # 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
+
+        # 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 is meant here.
+        sig { returns(T.nilable(String)) }
+        attr_reader :waba_id
+
+        sig { params(waba_id: String).void }
+        attr_writer :waba_id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :idempotency_key
+
+        sig { params(idempotency_key: String).void }
+        attr_writer :idempotency_key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :x_profile_id
+
+        sig { params(x_profile_id: String).void }
+        attr_writer :x_profile_id
+
+        sig do
+          params(
+            phone_number_id: T.nilable(String),
+            sandbox: T::Boolean,
+            waba_id: String,
+            idempotency_key: String,
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The Meta phone-number id of the number on WabaId, which assigns it to this
+          # profile as the number it sends from. It is not checked against the account here,
+          # so name the account's number; it is refused if another profile already uses it.
+          #
+          # Optional: omit it to connect the account and settle the number later. Nothing
+          # picks one on your behalf.
+          phone_number_id: nil,
+          # Sandbox flag - when true, the operation is simulated without side effects Useful
+          # for testing integrations without actual execution
+          sandbox: 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 is meant here.
+          waba_id: nil,
+          idempotency_key: nil,
+          x_profile_id: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              phone_number_id: T.nilable(String),
+              sandbox: T::Boolean,
+              waba_id: String,
+              idempotency_key: String,
+              x_profile_id: String,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/channels_state.rbi

@@ -0,0 +1,151 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ChannelsState < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::ChannelsState, Sentdm::Internal::AnyHash) }
+
+      # Which customer these channels belong to — the key's own, or the profile named in
+      # x-profile-id.
+      #
+      # Same reason the brand carries one: as the response to /v3/channels there is no
+      # other id in the document, and under x-profile-id this is the profile the call
+      # resolved to rather than the caller. Absent when nested inside a sender profile,
+      # whose own id already says whose they are.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :customer_id
+
+      # The markets this profile can send MMS in, one entry per country, or empty when
+      # none.
+      #
+      # Appears alongside sms rather than replacing an entry in it: the two are separate
+      # senders on the same number and a caller needs to see both — a market can be live
+      # for SMS while its MMS row is still provisioning, or MMS-incapable entirely
+      # because the market's sender-type SKU does not carry it.
+      sig { returns(T.nilable(T::Array[Sentdm::MmsMarket])) }
+      attr_reader :mms
+
+      sig { params(mms: T::Array[Sentdm::MmsMarket::OrHash]).void }
+      attr_writer :mms
+
+      # An RCS agent as its owner sees it: the order form back, plus where the
+      # submission stands.
+      #
+      # Not RcsSenderResponse. That one is the admin projection and carries the pipeline
+      # we track about a customer's request — internalStatus, statusReason, isLaunched —
+      # and the S3 keys behind the assets. None of that is the customer's to read: an
+      # internal status is a note to ourselves, and an S3 key is a storage detail that
+      # would become a contract the moment it was published.
+      #
+      # What is here is what the caller sent, in the names it sent them under, plus the
+      # three things only we can answer: the record's id, its status, and the number it
+      # sends from. So a read after a write shows the form as stored rather than as
+      # echoed.
+      sig { returns(T.nilable(Sentdm::Channels::RcsAgent)) }
+      attr_reader :rcs
+
+      sig { params(rcs: T.nilable(Sentdm::Channels::RcsAgent::OrHash)).void }
+      attr_writer :rcs
+
+      sig { returns(T.nilable(T::Array[Sentdm::Channels::SMSMarket])) }
+      attr_reader :sms
+
+      sig { params(sms: T::Array[Sentdm::Channels::SMSMarket::OrHash]).void }
+      attr_writer :sms
+
+      # The numbers this profile carries phone calls on, one entry per number, or empty
+      # when none. Voice is per number like an SMS market is per country: each number is
+      # its own channel row, turned on and off on its own, and one of them is the line
+      # app-originated calls fall back to.
+      sig { returns(T.nilable(T::Array[Sentdm::Channels::VoiceNumber])) }
+      attr_reader :voice
+
+      sig do
+        params(voice: T::Array[Sentdm::Channels::VoiceNumber::OrHash]).void
+      end
+      attr_writer :voice
+
+      # The profile's WhatsApp account. Its status is Meta's verification state.
+      sig { returns(T.nilable(Sentdm::Channels::WhatsappChannel)) }
+      attr_reader :whatsapp
+
+      sig do
+        params(
+          whatsapp: T.nilable(Sentdm::Channels::WhatsappChannel::OrHash)
+        ).void
+      end
+      attr_writer :whatsapp
+
+      # 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 do
+        params(
+          customer_id: T.nilable(String),
+          mms: T::Array[Sentdm::MmsMarket::OrHash],
+          rcs: T.nilable(Sentdm::Channels::RcsAgent::OrHash),
+          sms: T::Array[Sentdm::Channels::SMSMarket::OrHash],
+          voice: T::Array[Sentdm::Channels::VoiceNumber::OrHash],
+          whatsapp: T.nilable(Sentdm::Channels::WhatsappChannel::OrHash)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Which customer these channels belong to — the key's own, or the profile named in
+        # x-profile-id.
+        #
+        # Same reason the brand carries one: as the response to /v3/channels there is no
+        # other id in the document, and under x-profile-id this is the profile the call
+        # resolved to rather than the caller. Absent when nested inside a sender profile,
+        # whose own id already says whose they are.
+        customer_id: nil,
+        # The markets this profile can send MMS in, one entry per country, or empty when
+        # none.
+        #
+        # Appears alongside sms rather than replacing an entry in it: the two are separate
+        # senders on the same number and a caller needs to see both — a market can be live
+        # for SMS while its MMS row is still provisioning, or MMS-incapable entirely
+        # because the market's sender-type SKU does not carry it.
+        mms: nil,
+        # An RCS agent as its owner sees it: the order form back, plus where the
+        # submission stands.
+        #
+        # Not RcsSenderResponse. That one is the admin projection and carries the pipeline
+        # we track about a customer's request — internalStatus, statusReason, isLaunched —
+        # and the S3 keys behind the assets. None of that is the customer's to read: an
+        # internal status is a note to ourselves, and an S3 key is a storage detail that
+        # would become a contract the moment it was published.
+        #
+        # What is here is what the caller sent, in the names it sent them under, plus the
+        # three things only we can answer: the record's id, its status, and the number it
+        # sends from. So a read after a write shows the form as stored rather than as
+        # echoed.
+        rcs: nil,
+        sms: nil,
+        # The numbers this profile carries phone calls on, one entry per number, or empty
+        # when none. Voice is per number like an SMS market is per country: each number is
+        # its own channel row, turned on and off on its own, and one of them is the line
+        # app-originated calls fall back to.
+        voice: nil,
+        # The profile's WhatsApp account. Its status is Meta's verification state.
+        whatsapp: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            customer_id: T.nilable(String),
+            mms: T::Array[Sentdm::MmsMarket],
+            rcs: T.nilable(Sentdm::Channels::RcsAgent),
+            sms: T::Array[Sentdm::Channels::SMSMarket],
+            voice: T::Array[Sentdm::Channels::VoiceNumber],
+            whatsapp: T.nilable(Sentdm::Channels::WhatsappChannel)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end