sentdm 0.44.0 → 0.46.0

data/rbi/sentdm/models/compliance_requirements.rbi

@@ -0,0 +1,165 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ComplianceRequirements < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::ComplianceRequirements, Sentdm::Internal::AnyHash)
+        end
+
+      # Channel the requirements apply to — sms, whatsapp or rcs.
+      #
+      # Echoed so the document says which channel it describes. It always described one:
+      # setup's last step is a specific channel path, and every type is an SMS sender
+      # type — but a caller reading the payload had to infer that from the path to know
+      # it.
+      sig { returns(T.nilable(String)) }
+      attr_reader :channel
+
+      sig { params(channel: String).void }
+      attr_writer :channel
+
+      # ISO 3166-1 alpha-2 country the requirements apply to.
+      sig { returns(T.nilable(String)) }
+      attr_reader :country
+
+      sig { params(country: String).void }
+      attr_writer :country
+
+      # Whether this market demands anything before a sender can be registered. When
+      # false, the compliance array may be omitted entirely and the profile is ready
+      # once provisioned.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :required
+
+      sig { params(required: T::Boolean).void }
+      attr_writer :required
+
+      # Values to supply in compliance. Empty when the market demands nothing. Values
+      # Sent supplies on your behalf are never listed, and neither are ones it derives
+      # from what you send.
+      sig { returns(T.nilable(T::Array[Sentdm::ComplianceRequirement])) }
+      attr_reader :requirements
+
+      sig do
+        params(
+          requirements: T::Array[Sentdm::ComplianceRequirement::OrHash]
+        ).void
+      end
+      attr_writer :requirements
+
+      # Pattern the sender's own value must match, where the market dictates one —
+      # alphanumeric sender ids and short codes. Null when the value is
+      # carrier-assigned.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :sender_id_pattern
+
+      # The calls that set this market up, in the order they have to be made, each
+      # carrying a body that can be sent as it stands.
+      #
+      # This is the answer to "what do I actually do". Requirements describes each value
+      # the market wants; this assembles those descriptions into the requests that
+      # supply them, so a caller — or an agent acting for one — copies a body out and
+      # sends it rather than building one from a table.
+      #
+      # The last step is always the channel itself, and it is where the regime's own
+      # values are supplied. The one before it, where there is one, is the brand a
+      # registering market files against — so it is a step of its own and the channel
+      # call refuses until it exists. A market that registers with nobody has one step.
+      sig { returns(T.nilable(T::Array[Sentdm::ComplianceSetupStep])) }
+      attr_reader :setup
+
+      sig { params(setup: T::Array[Sentdm::ComplianceSetupStep::OrHash]).void }
+      attr_writer :setup
+
+      # Sender type the requirements apply to.
+      #
+      # Non-nullable while sms is the only channel answered here, because it is the only
+      # channel whose senders have a type — the day another one is answered, this
+      # becomes nullable along with it. Not nullable in advance: nothing can emit null
+      # today, and publishing a shape the API never sends is the same mistake as
+      # publishing a field it does not have.
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      # Everything a market expects of a sender, for one channel, country and sender
+      # type.
+      sig do
+        params(
+          channel: String,
+          country: String,
+          required: T::Boolean,
+          requirements: T::Array[Sentdm::ComplianceRequirement::OrHash],
+          sender_id_pattern: T.nilable(String),
+          setup: T::Array[Sentdm::ComplianceSetupStep::OrHash],
+          type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Channel the requirements apply to — sms, whatsapp or rcs.
+        #
+        # Echoed so the document says which channel it describes. It always described one:
+        # setup's last step is a specific channel path, and every type is an SMS sender
+        # type — but a caller reading the payload had to infer that from the path to know
+        # it.
+        channel: nil,
+        # ISO 3166-1 alpha-2 country the requirements apply to.
+        country: nil,
+        # Whether this market demands anything before a sender can be registered. When
+        # false, the compliance array may be omitted entirely and the profile is ready
+        # once provisioned.
+        required: nil,
+        # Values to supply in compliance. Empty when the market demands nothing. Values
+        # Sent supplies on your behalf are never listed, and neither are ones it derives
+        # from what you send.
+        requirements: nil,
+        # Pattern the sender's own value must match, where the market dictates one —
+        # alphanumeric sender ids and short codes. Null when the value is
+        # carrier-assigned.
+        sender_id_pattern: nil,
+        # The calls that set this market up, in the order they have to be made, each
+        # carrying a body that can be sent as it stands.
+        #
+        # This is the answer to "what do I actually do". Requirements describes each value
+        # the market wants; this assembles those descriptions into the requests that
+        # supply them, so a caller — or an agent acting for one — copies a body out and
+        # sends it rather than building one from a table.
+        #
+        # The last step is always the channel itself, and it is where the regime's own
+        # values are supplied. The one before it, where there is one, is the brand a
+        # registering market files against — so it is a step of its own and the channel
+        # call refuses until it exists. A market that registers with nobody has one step.
+        setup: nil,
+        # Sender type the requirements apply to.
+        #
+        # Non-nullable while sms is the only channel answered here, because it is the only
+        # channel whose senders have a type — the day another one is answered, this
+        # becomes nullable along with it. Not nullable in advance: nothing can emit null
+        # today, and publishing a shape the API never sends is the same mistake as
+        # publishing a field it does not have.
+        type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            channel: String,
+            country: String,
+            required: T::Boolean,
+            requirements: T::Array[Sentdm::ComplianceRequirement],
+            sender_id_pattern: T.nilable(String),
+            setup: T::Array[Sentdm::ComplianceSetupStep],
+            type: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/compliance_retrieve_requirements_params.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ComplianceRetrieveRequirementsParams < Sentdm::Internal::Type::BaseModel
+      extend Sentdm::Internal::Type::RequestParameters::Converter
+      include Sentdm::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            Sentdm::ComplianceRetrieveRequirementsParams,
+            Sentdm::Internal::AnyHash
+          )
+        end
+
+      # Channel the sender is for: sms, whatsapp or rcs. Defaults to sms, which is the
+      # only one answered today — the other two are 501 until their requirements are
+      # declared.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :channel
+
+      # ISO 3166-1 alpha-2 country code, e.g. US, XK, IN
+      sig { returns(T.nilable(String)) }
+      attr_accessor :country
+
+      # Sender type: LOCAL, MOBILE, TEN_DLC, TOLL_FREE, SHORT_CODE, ALPHANUMERIC. 10DLC
+      # is accepted as a synonym of TEN_DLC, the same as on POST /v3/sender-profiles.
+      # Applies to channel=sms, the only channel whose senders have a type.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :type
+
+      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(
+          channel: T.nilable(String),
+          country: T.nilable(String),
+          type: T.nilable(String),
+          x_profile_id: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Channel the sender is for: sms, whatsapp or rcs. Defaults to sms, which is the
+        # only one answered today — the other two are 501 until their requirements are
+        # declared.
+        channel: nil,
+        # ISO 3166-1 alpha-2 country code, e.g. US, XK, IN
+        country: nil,
+        # Sender type: LOCAL, MOBILE, TEN_DLC, TOLL_FREE, SHORT_CODE, ALPHANUMERIC. 10DLC
+        # is accepted as a synonym of TEN_DLC, the same as on POST /v3/sender-profiles.
+        # Applies to channel=sms, the only channel whose senders have a type.
+        type: nil,
+        x_profile_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            channel: T.nilable(String),
+            country: T.nilable(String),
+            type: T.nilable(String),
+            x_profile_id: String,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/compliance_setup_step.rbi

@@ -0,0 +1,115 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ComplianceSetupStep < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::ComplianceSetupStep, Sentdm::Internal::AnyHash)
+        end
+
+      # Files to attach as multipart, when this call takes any. Absent when it does not.
+      sig { returns(T.nilable(T::Array[Sentdm::ComplianceAttachmentTemplate])) }
+      attr_accessor :attachments
+
+      # The request body, with every key this market wants already present and the
+      # values left blank. Send it as it stands and the response names each blank that
+      # still has to be filled.
+      sig { returns(T.nilable(T.anything)) }
+      attr_reader :body
+
+      sig { params(body: T.anything).void }
+      attr_writer :body
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :method_
+
+      sig { params(method_: String).void }
+      attr_writer :method_
+
+      # Path to call. Add the x-profile-id header with an organization key to make the
+      # same call for one of your sender profiles — there is no separate path for that.
+      sig { returns(T.nilable(String)) }
+      attr_reader :path
+
+      sig { params(path: String).void }
+      attr_writer :path
+
+      # What this call sets up: brand or channel.
+      sig { returns(T.nilable(String)) }
+      attr_reader :resource
+
+      sig { params(resource: String).void }
+      attr_writer :resource
+
+      # Position in the sequence, from 1. Steps must be performed in this order.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :step
+
+      sig { params(step: Integer).void }
+      attr_writer :step
+
+      # Why this market needs this call, in one sentence.
+      sig { returns(T.nilable(String)) }
+      attr_reader :why
+
+      sig { params(why: String).void }
+      attr_writer :why
+
+      # One call to make, with a body that can be sent as it stands.
+      #
+      # The steps are ordered and the order is load-bearing: a channel that registers
+      # with a regime is filed against a brand, so the brand call comes first and the
+      # channel call refuses until it has been made. Doing them in order is the whole of
+      # setting a market up.
+      sig do
+        params(
+          attachments:
+            T.nilable(T::Array[Sentdm::ComplianceAttachmentTemplate::OrHash]),
+          body: T.anything,
+          method_: String,
+          path: String,
+          resource: String,
+          step: Integer,
+          why: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Files to attach as multipart, when this call takes any. Absent when it does not.
+        attachments: nil,
+        # The request body, with every key this market wants already present and the
+        # values left blank. Send it as it stands and the response names each blank that
+        # still has to be filled.
+        body: nil,
+        method_: nil,
+        # Path to call. Add the x-profile-id header with an organization key to make the
+        # same call for one of your sender profiles — there is no separate path for that.
+        path: nil,
+        # What this call sets up: brand or channel.
+        resource: nil,
+        # Position in the sequence, from 1. Steps must be performed in this order.
+        step: nil,
+        # Why this market needs this call, in one sentence.
+        why: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            attachments:
+              T.nilable(T::Array[Sentdm::ComplianceAttachmentTemplate]),
+            body: T.anything,
+            method_: String,
+            path: String,
+            resource: String,
+            step: Integer,
+            why: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/contact_message_summary.rbi

@@ -8,18 +8,11 @@ module Sentdm
           T.any(Sentdm::ContactMessageSummary, Sentdm::Internal::AnyHash)
         end
 
-      sig do
-        returns(
-          T.nilable(T::Array[Sentdm::ContactMessageSummary::ChannelScore])
-        )
-      end
+      sig { returns(T.nilable(T::Array[Sentdm::ChannelScore])) }
       attr_reader :channel_scores
 
       sig do
-        params(
-          channel_scores:
-            T::Array[Sentdm::ContactMessageSummary::ChannelScore::OrHash]
-        ).void
+        params(channel_scores: T::Array[Sentdm::ChannelScore::OrHash]).void
       end
       attr_writer :channel_scores
 
@@ -49,8 +42,7 @@ module Sentdm
 
       sig do
         params(
-          channel_scores:
-            T::Array[Sentdm::ContactMessageSummary::ChannelScore::OrHash],
+          channel_scores: T::Array[Sentdm::ChannelScore::OrHash],
           channels_used: T::Array[String],
           contact_id: String,
           first_message_at: T.nilable(Time),
@@ -71,8 +63,7 @@ module Sentdm
       sig do
         override.returns(
           {
-            channel_scores:
-              T::Array[Sentdm::ContactMessageSummary::ChannelScore],
+            channel_scores: T::Array[Sentdm::ChannelScore],
             channels_used: T::Array[String],
             contact_id: String,
             first_message_at: T.nilable(Time),
@@ -83,62 +74,6 @@ module Sentdm
       end
       def to_hash
       end
-
-      class ChannelScore < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Sentdm::ContactMessageSummary::ChannelScore,
-              Sentdm::Internal::AnyHash
-            )
-          end
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :channel
-
-        sig { params(channel: String).void }
-        attr_writer :channel
-
-        # Percentage (0-100) of messages on this channel that ended in FAILED.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :fail_score
-
-        sig { params(fail_score: Integer).void }
-        attr_writer :fail_score
-
-        # Percentage (0-100) of messages on this channel that reached a successful
-        # terminal state: SENT/DELIVERED/READ for outbound, RECEIVED for inbound.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :success_score
-
-        sig { params(success_score: Integer).void }
-        attr_writer :success_score
-
-        sig do
-          params(
-            channel: String,
-            fail_score: Integer,
-            success_score: Integer
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          channel: nil,
-          # Percentage (0-100) of messages on this channel that ended in FAILED.
-          fail_score: nil,
-          # Percentage (0-100) of messages on this channel that reached a successful
-          # terminal state: SENT/DELIVERED/READ for outbound, RECEIVED for inbound.
-          success_score: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            { channel: String, fail_score: Integer, success_score: Integer }
-          )
-        end
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/sentdm/models/contacts_list.rbi

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