sentdm 0.44.0 → 0.46.0

data/rbi/sentdm/models/message_send_result.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MessageSendResult < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::MessageSendResult, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(T::Array[Sentdm::MessageRecipient])) }
+      attr_reader :recipients
+
+      sig do
+        params(recipients: T::Array[Sentdm::MessageRecipient::OrHash]).void
+      end
+      attr_writer :recipients
+
+      # QUEUED: the batch is accepted. A request that carried scheduled_at is QUEUED
+      # here too; each message moves to SCHEDULED once it is held, as GET
+      # /v3/messages/{id} and the message.scheduled webhook report.
+      sig { returns(T.nilable(String)) }
+      attr_reader :status
+
+      sig { params(status: String).void }
+      attr_writer :status
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :template_id
+
+      sig { params(template_id: String).void }
+      attr_writer :template_id
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :template_name
+
+      sig { params(template_name: String).void }
+      attr_writer :template_name
+
+      # The result of a multi-recipient send.
+      #
+      # Declared here rather than in the service layer. POST /v3/messages used to
+      # publish MessageSendResult — a type in Common.Services.Messaging.Contracts — so
+      # the public contract was whatever the send service happened to return, and
+      # changing that service for an internal reason changed the API. The service keeps
+      # its result; this is what a caller sees, and the mapping between them is a
+      # decision the endpoint makes.
+      #
+      # The shape of an immediate send: it never has a scheduled_at key. A send that
+      # carried scheduled_at is a ScheduledSendMessageResponse, and the endpoint decides
+      # which of the two to answer with. From always returns this type.
+      sig do
+        params(
+          recipients: T::Array[Sentdm::MessageRecipient::OrHash],
+          status: String,
+          template_id: String,
+          template_name: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        recipients: nil,
+        # QUEUED: the batch is accepted. A request that carried scheduled_at is QUEUED
+        # here too; each message moves to SCHEDULED once it is held, as GET
+        # /v3/messages/{id} and the message.scheduled webhook report.
+        status: nil,
+        template_id: nil,
+        template_name: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            recipients: T::Array[Sentdm::MessageRecipient],
+            status: String,
+            template_id: String,
+            template_name: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/message_status_event.rbi

@@ -0,0 +1,70 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MessageStatusEvent < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::MessageStatusEvent, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :status
+
+      sig { returns(Time) }
+      attr_accessor :timestamp
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :description
+
+      # A human-readable sentence for reason_code. Omitted whenever reason_code is.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason
+
+      # Why the message reached this status, as a stable platform code such as
+      # DELIVERY_007. Present on FAILED, FILTERED and BLOCKED events; omitted on every
+      # status that needs no explanation. Same wire name and vocabulary as on the
+      # activities list and the webhook.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :reason_code
+
+      # Represents a status change event in a message's lifecycle (v3)
+      sig do
+        params(
+          status: String,
+          timestamp: Time,
+          description: T.nilable(String),
+          reason: T.nilable(String),
+          reason_code: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        status:,
+        timestamp:,
+        description: nil,
+        # A human-readable sentence for reason_code. Omitted whenever reason_code is.
+        reason: nil,
+        # Why the message reached this status, as a stable platform code such as
+        # DELIVERY_007. Present on FAILED, FILTERED and BLOCKED events; omitted on every
+        # status that needs no explanation. Same wire name and vocabulary as on the
+        # activities list and the webhook.
+        reason_code: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            status: String,
+            timestamp: Time,
+            description: T.nilable(String),
+            reason: T.nilable(String),
+            reason_code: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/mms_market.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MmsMarket < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::MmsMarket, Sentdm::Internal::AnyHash) }
+
+      # ISO-3166 alpha-2 of the market.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :country
+
+      # The sender type the market sends from, mirroring the SMS sender.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :number_type
+
+      # The sending number. Null while the market is still being provisioned.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :sender_value
+
+      # Where this market's MMS sender stands. Read-only.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :status
+
+      # One market the profile can send MMS in.
+      #
+      # Deliberately not SmsMarketState: an MMS market carries no compliance of its own.
+      # It is the same number, carrier and registration as the SMS market on it in that
+      # country — MMS files nothing separately — so a compliance block here would always
+      # be null and would invite the question of what an MMS market owes. It owes what
+      # the SMS market owes, reported there.
+      sig do
+        params(
+          country: T.nilable(String),
+          number_type: T.nilable(String),
+          sender_value: T.nilable(String),
+          status: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # ISO-3166 alpha-2 of the market.
+        country: nil,
+        # The sender type the market sends from, mirroring the SMS sender.
+        number_type: nil,
+        # The sending number. Null while the market is still being provisioned.
+        sender_value: nil,
+        # Where this market's MMS sender stands. Read-only.
+        status: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            country: T.nilable(String),
+            number_type: T.nilable(String),
+            sender_value: T.nilable(String),
+            status: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/number_lookup_result.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class NumberLookupResult < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::NumberLookupResult, Sentdm::Internal::AnyHash)
+        end
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :carrier_name
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :country_code
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :is_ported
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_valid
+
+      sig { params(is_valid: T::Boolean).void }
+      attr_writer :is_valid
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :is_voip
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :line_type
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :mobile_country_code
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :mobile_network_code
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :phone_number
+
+      sig { params(phone_number: String).void }
+      attr_writer :phone_number
+
+      sig do
+        params(
+          carrier_name: T.nilable(String),
+          country_code: T.nilable(String),
+          is_ported: T.nilable(T::Boolean),
+          is_valid: T::Boolean,
+          is_voip: T.nilable(T::Boolean),
+          line_type: T.nilable(String),
+          mobile_country_code: T.nilable(String),
+          mobile_network_code: T.nilable(String),
+          phone_number: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        carrier_name: nil,
+        country_code: nil,
+        is_ported: nil,
+        is_valid: nil,
+        is_voip: nil,
+        line_type: nil,
+        mobile_country_code: nil,
+        mobile_network_code: nil,
+        phone_number: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            carrier_name: T.nilable(String),
+            country_code: T.nilable(String),
+            is_ported: T.nilable(T::Boolean),
+            is_valid: T::Boolean,
+            is_voip: T.nilable(T::Boolean),
+            line_type: T.nilable(String),
+            mobile_country_code: T.nilable(String),
+            mobile_network_code: T.nilable(String),
+            phone_number: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/pagination_cursors.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class PaginationCursors < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::PaginationCursors, Sentdm::Internal::AnyHash)
+        end
+
+      # Cursor to fetch the next page.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :after
+
+      # Cursor to fetch the previous page.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :before
+
+      # Cursor-based pagination. Never populated — see Cursors.
+      sig do
+        params(after: T.nilable(String), before: T.nilable(String)).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # Cursor to fetch the next page.
+        after: nil,
+        # Cursor to fetch the previous page.
+        before: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { after: T.nilable(String), before: T.nilable(String) }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/pagination_meta.rbi

@@ -9,12 +9,10 @@ module Sentdm
         end
 
       # Cursor-based pagination. Never populated — see Cursors.
-      sig { returns(T.nilable(Sentdm::PaginationMeta::Cursors)) }
+      sig { returns(T.nilable(Sentdm::PaginationCursors)) }
       attr_reader :cursors
 
-      sig do
-        params(cursors: T.nilable(Sentdm::PaginationMeta::Cursors::OrHash)).void
-      end
+      sig { params(cursors: T.nilable(Sentdm::PaginationCursors::OrHash)).void }
       attr_writer :cursors
 
       # Whether there are more pages after this one
@@ -55,7 +53,7 @@ module Sentdm
       # Pagination metadata for list responses
       sig do
         params(
-          cursors: T.nilable(Sentdm::PaginationMeta::Cursors::OrHash),
+          cursors: T.nilable(Sentdm::PaginationCursors::OrHash),
           has_more: T::Boolean,
           page: Integer,
           page_size: Integer,
@@ -82,7 +80,7 @@ module Sentdm
       sig do
         override.returns(
           {
-            cursors: T.nilable(Sentdm::PaginationMeta::Cursors),
+            cursors: T.nilable(Sentdm::PaginationCursors),
             has_more: T::Boolean,
             page: Integer,
             page_size: Integer,
@@ -93,43 +91,6 @@ module Sentdm
       end
       def to_hash
       end
-
-      class Cursors < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Sentdm::PaginationMeta::Cursors, Sentdm::Internal::AnyHash)
-          end
-
-        # Cursor to fetch the next page.
-        sig { returns(T.nilable(String)) }
-        attr_accessor :after
-
-        # Cursor to fetch the previous page.
-        sig { returns(T.nilable(String)) }
-        attr_accessor :before
-
-        # Cursor-based pagination. Never populated — see Cursors.
-        sig do
-          params(after: T.nilable(String), before: T.nilable(String)).returns(
-            T.attached_class
-          )
-        end
-        def self.new(
-          # Cursor to fetch the next page.
-          after: nil,
-          # Cursor to fetch the previous page.
-          before: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            { after: T.nilable(String), before: T.nilable(String) }
-          )
-        end
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/sentdm/models/profile_completion_accepted.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ProfileCompletionAccepted < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::ProfileCompletionAccepted, Sentdm::Internal::AnyHash)
+        end
+
+      # Human-readable message describing the accepted state.
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # Response acknowledging that profile completion has been accepted and started in
+      # the background. The provided webhook URL will be called when processing
+      # finishes.
+      sig { params(message: String).returns(T.attached_class) }
+      def self.new(
+        # Human-readable message describing the accepted state.
+        message: nil
+      )
+      end
+
+      sig { override.returns({ message: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/profile_completion_result.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class ProfileCompletionResult < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::ProfileCompletionResult, Sentdm::Internal::AnyHash)
+        end
+
+      # Human-readable message describing the result.
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # Current process status of the profile (e.g., "completed", "submitted",
+      # "in_progress").
+      sig { returns(T.nilable(String)) }
+      attr_reader :status
+
+      sig { params(status: String).void }
+      attr_writer :status
+
+      # Response when a profile is already in the completed state and no further action
+      # is taken.
+      sig { params(message: String, status: String).returns(T.attached_class) }
+      def self.new(
+        # Human-readable message describing the result.
+        message: nil,
+        # Current process status of the profile (e.g., "completed", "submitted",
+        # "in_progress").
+        status: nil
+      )
+      end
+
+      sig { override.returns({ message: String, status: String }) }
+      def to_hash
+      end
+    end
+  end
+end