sentdm 0.45.0 → 0.47.0

data/rbi/sentdm/models/compliance_attachment_template.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ComplianceAttachmentTemplate < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::ComplianceAttachmentTemplate, Sentdm::Internal::AnyHash)
+        end
+
+      # The multipart field name to attach the file under.
+      sig { returns(T.nilable(String)) }
+      attr_reader :field_name
+
+      sig { params(field_name: String).void }
+      attr_writer :field_name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :label
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :required
+
+      sig { params(required: T::Boolean).void }
+      attr_writer :required
+
+      # A file this market wants, and the multipart field to send it as.
+      #
+      # Separate from compliance because a file is not JSON: the channel call accepts
+      # multipart, and each file is named after the key it satisfies. Listing documents
+      # among the JSON entries would describe a request nobody could send.
+      sig do
+        params(
+          field_name: String,
+          label: T.nilable(String),
+          required: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The multipart field name to attach the file under.
+        field_name: nil,
+        label: nil,
+        required: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { field_name: String, label: T.nilable(String), required: T::Boolean }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/compliance_requirement.rbi

@@ -0,0 +1,149 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ComplianceRequirement < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::ComplianceRequirement, Sentdm::Internal::AnyHash)
+        end
+
+      # Refinement of type where the market demands a specific shape, e.g. e164, url,
+      # email, iso3166_alpha2, csv_keywords.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :format_
+
+      # Shape of each entry, when this requirement is a list of objects rather than of
+      # scalars.
+      #
+      # The compliance value stays null in the setup body like every other blank — a
+      # body that carries a half-filled object is one the endpoint refuses, which would
+      # break the promise that the published body can be sent as it stands. So the shape
+      # is described here instead, and each entry the caller composes has these keys.
+      sig { returns(T.nilable(T::Array[Sentdm::ComplianceRequirement])) }
+      attr_accessor :item_fields
+
+      # Key to use in the compliance map.
+      sig { returns(T.nilable(String)) }
+      attr_reader :key
+
+      sig { params(key: String).void }
+      attr_writer :key
+
+      # Human label, suitable for a form field.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :label
+
+      # Most entries this value accepts, where the market caps it.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :max_items
+
+      # Shortest acceptable value, where the market sets one. TCR refuses a consent
+      # narrative under 40 characters, and finding that out at submission time is the
+      # round trip this exists to save.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :min_length
+
+      # Why the market asks for this.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :notes
+
+      # Accepted values, when the type is an enum or a constrained array.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :options
+
+      # Whether the market always demands this value.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :required
+
+      sig { params(required: T::Boolean).void }
+      attr_writer :required
+
+      # Condition that makes this value required, when it is only required in some cases
+      # — e.g. brand.entity_type == PUBLIC_PROFIT. Evaluate it against your own payload
+      # to know whether to collect the field.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :required_when
+
+      # Value type: string, number, boolean, date, enum, object, array or document.
+      sig { returns(T.nilable(String)) }
+      attr_reader :type
+
+      sig { params(type: String).void }
+      attr_writer :type
+
+      # One value a market expects in a channel call's compliance map.
+      sig do
+        params(
+          format_: T.nilable(String),
+          item_fields: T.nilable(T::Array[Sentdm::ComplianceRequirement]),
+          key: String,
+          label: T.nilable(String),
+          max_items: T.nilable(Integer),
+          min_length: T.nilable(Integer),
+          notes: T.nilable(String),
+          options: T.nilable(T::Array[String]),
+          required: T::Boolean,
+          required_when: T.nilable(String),
+          type: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Refinement of type where the market demands a specific shape, e.g. e164, url,
+        # email, iso3166_alpha2, csv_keywords.
+        format_: nil,
+        # Shape of each entry, when this requirement is a list of objects rather than of
+        # scalars.
+        #
+        # The compliance value stays null in the setup body like every other blank — a
+        # body that carries a half-filled object is one the endpoint refuses, which would
+        # break the promise that the published body can be sent as it stands. So the shape
+        # is described here instead, and each entry the caller composes has these keys.
+        item_fields: nil,
+        # Key to use in the compliance map.
+        key: nil,
+        # Human label, suitable for a form field.
+        label: nil,
+        # Most entries this value accepts, where the market caps it.
+        max_items: nil,
+        # Shortest acceptable value, where the market sets one. TCR refuses a consent
+        # narrative under 40 characters, and finding that out at submission time is the
+        # round trip this exists to save.
+        min_length: nil,
+        # Why the market asks for this.
+        notes: nil,
+        # Accepted values, when the type is an enum or a constrained array.
+        options: nil,
+        # Whether the market always demands this value.
+        required: nil,
+        # Condition that makes this value required, when it is only required in some cases
+        # — e.g. brand.entity_type == PUBLIC_PROFIT. Evaluate it against your own payload
+        # to know whether to collect the field.
+        required_when: nil,
+        # Value type: string, number, boolean, date, enum, object, array or document.
+        type: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            format_: T.nilable(String),
+            item_fields: T.nilable(T::Array[Sentdm::ComplianceRequirement]),
+            key: String,
+            label: T.nilable(String),
+            max_items: T.nilable(Integer),
+            min_length: T.nilable(Integer),
+            notes: T.nilable(String),
+            options: T.nilable(T::Array[String]),
+            required: T::Boolean,
+            required_when: T.nilable(String),
+            type: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

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