sentdm 0.44.0 → 0.46.0

data/rbi/sentdm/models/{webhook_rotate_secret_response.rbi → api_response_of_cancelled_message.rbi}

@@ -2,27 +2,20 @@
 
 module Sentdm
   module Models
-    class WebhookRotateSecretResponse < Sentdm::Internal::Type::BaseModel
+    class APIResponseOfCancelledMessage < Sentdm::Internal::Type::BaseModel
       OrHash =
         T.type_alias do
           T.any(
-            Sentdm::Models::WebhookRotateSecretResponse,
+            Sentdm::APIResponseOfCancelledMessage,
             Sentdm::Internal::AnyHash
           )
         end
 
       # The response data (null if error)
-      sig do
-        returns(T.nilable(Sentdm::Models::WebhookRotateSecretResponse::Data))
-      end
+      sig { returns(T.nilable(Sentdm::CancelledMessage)) }
       attr_reader :data
 
-      sig do
-        params(
-          data:
-            T.nilable(Sentdm::Models::WebhookRotateSecretResponse::Data::OrHash)
-        ).void
-      end
+      sig { params(data: T.nilable(Sentdm::CancelledMessage::OrHash)).void }
       attr_writer :data
 
       # Error information
@@ -49,10 +42,7 @@ module Sentdm
       # Standard API response envelope for all v3 endpoints
       sig do
         params(
-          data:
-            T.nilable(
-              Sentdm::Models::WebhookRotateSecretResponse::Data::OrHash
-            ),
+          data: T.nilable(Sentdm::CancelledMessage::OrHash),
           error: T.nilable(Sentdm::ErrorDetail::OrHash),
           meta: Sentdm::APIMeta::OrHash,
           success: T::Boolean
@@ -73,7 +63,7 @@ module Sentdm
       sig do
         override.returns(
           {
-            data: T.nilable(Sentdm::Models::WebhookRotateSecretResponse::Data),
+            data: T.nilable(Sentdm::CancelledMessage),
             error: T.nilable(Sentdm::ErrorDetail),
             meta: Sentdm::APIMeta,
             success: T::Boolean
@@ -82,31 +72,6 @@ module Sentdm
       end
       def to_hash
       end
-
-      class Data < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Sentdm::Models::WebhookRotateSecretResponse::Data,
-              Sentdm::Internal::AnyHash
-            )
-          end
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :signing_secret
-
-        sig { params(signing_secret: String).void }
-        attr_writer :signing_secret
-
-        # The response data (null if error)
-        sig { params(signing_secret: String).returns(T.attached_class) }
-        def self.new(signing_secret: nil)
-        end
-
-        sig { override.returns({ signing_secret: String }) }
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/sentdm/models/api_response_of_channels_state.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfChannelsState < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseOfChannelsState, Sentdm::Internal::AnyHash)
+        end
+
+      # 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 :data
+
+      sig { params(data: T.nilable(Sentdm::ChannelsState::OrHash)).void }
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::ChannelsState::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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.
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::ChannelsState),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_of_compliance_requirements.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfComplianceRequirements < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Sentdm::APIResponseOfComplianceRequirements,
+            Sentdm::Internal::AnyHash
+          )
+        end
+
+      # Everything a market expects of a sender, for one channel, country and sender
+      # type.
+      sig { returns(T.nilable(Sentdm::ComplianceRequirements)) }
+      attr_reader :data
+
+      sig do
+        params(data: T.nilable(Sentdm::ComplianceRequirements::OrHash)).void
+      end
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::ComplianceRequirements::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Everything a market expects of a sender, for one channel, country and sender
+        # type.
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::ComplianceRequirements),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_of_contacts_list.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfContactsList < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseOfContactsList, Sentdm::Internal::AnyHash)
+        end
+
+      # A paginated list of contacts.
+      sig { returns(T.nilable(Sentdm::ContactsList)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::ContactsList::OrHash)).void }
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::ContactsList::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A paginated list of contacts.
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::ContactsList),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_of_message.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfMessage < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseOfMessage, Sentdm::Internal::AnyHash)
+        end
+
+      # Message response for v3 API — same shape as v2 with snake_case JSON conventions.
+      #
+      # The shape of a message that was sent immediately: it never has a scheduled_at
+      # key. A message that is or was held for a later instant is a
+      # ScheduledMessageResponse, and the endpoint decides which of the two to answer
+      # with. From always returns this type.
+      sig { returns(T.nilable(Sentdm::Message)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::Message::OrHash)).void }
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::Message::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Message response for v3 API — same shape as v2 with snake_case JSON conventions.
+        #
+        # The shape of a message that was sent immediately: it never has a scheduled_at
+        # key. A message that is or was held for a later instant is a
+        # ScheduledMessageResponse, and the endpoint decides which of the two to answer
+        # with. From always returns this type.
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::Message),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_of_message_activities.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfMessageActivities < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Sentdm::APIResponseOfMessageActivities,
+            Sentdm::Internal::AnyHash
+          )
+        end
+
+      # Response for GET /messages/{id}/activities
+      sig { returns(T.nilable(Sentdm::MessageActivities)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::MessageActivities::OrHash)).void }
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::MessageActivities::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Response for GET /messages/{id}/activities
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::MessageActivities),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/{webhook_test_response.rbi → api_response_of_number_lookup_result.rbi}

@@ -2,21 +2,20 @@
 
 module Sentdm
   module Models
-    class WebhookTestResponse < Sentdm::Internal::Type::BaseModel
+    class APIResponseOfNumberLookupResult < Sentdm::Internal::Type::BaseModel
       OrHash =
         T.type_alias do
-          T.any(Sentdm::Models::WebhookTestResponse, Sentdm::Internal::AnyHash)
+          T.any(
+            Sentdm::APIResponseOfNumberLookupResult,
+            Sentdm::Internal::AnyHash
+          )
         end
 
       # The response data (null if error)
-      sig { returns(T.nilable(Sentdm::Models::WebhookTestResponse::Data)) }
+      sig { returns(T.nilable(Sentdm::NumberLookupResult)) }
       attr_reader :data
 
-      sig do
-        params(
-          data: T.nilable(Sentdm::Models::WebhookTestResponse::Data::OrHash)
-        ).void
-      end
+      sig { params(data: T.nilable(Sentdm::NumberLookupResult::OrHash)).void }
       attr_writer :data
 
       # Error information
@@ -43,7 +42,7 @@ module Sentdm
       # Standard API response envelope for all v3 endpoints
       sig do
         params(
-          data: T.nilable(Sentdm::Models::WebhookTestResponse::Data::OrHash),
+          data: T.nilable(Sentdm::NumberLookupResult::OrHash),
           error: T.nilable(Sentdm::ErrorDetail::OrHash),
           meta: Sentdm::APIMeta::OrHash,
           success: T::Boolean
@@ -64,7 +63,7 @@ module Sentdm
       sig do
         override.returns(
           {
-            data: T.nilable(Sentdm::Models::WebhookTestResponse::Data),
+            data: T.nilable(Sentdm::NumberLookupResult),
             error: T.nilable(Sentdm::ErrorDetail),
             meta: Sentdm::APIMeta,
             success: T::Boolean
@@ -73,39 +72,6 @@ module Sentdm
       end
       def to_hash
       end
-
-      class Data < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Sentdm::Models::WebhookTestResponse::Data,
-              Sentdm::Internal::AnyHash
-            )
-          end
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :message
-
-        sig { params(message: String).void }
-        attr_writer :message
-
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_reader :success
-
-        sig { params(success: T::Boolean).void }
-        attr_writer :success
-
-        # The response data (null if error)
-        sig do
-          params(message: String, success: T::Boolean).returns(T.attached_class)
-        end
-        def self.new(message: nil, success: nil)
-        end
-
-        sig { override.returns({ message: String, success: T::Boolean }) }
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/sentdm/models/api_response_of_profile_completion_accepted.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfProfileCompletionAccepted < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Sentdm::APIResponseOfProfileCompletionAccepted,
+            Sentdm::Internal::AnyHash
+          )
+        end
+
+      # Response acknowledging that profile completion has been accepted and started in
+      # the background. The provided webhook URL will be called when processing
+      # finishes.
+      sig { returns(T.nilable(Sentdm::ProfileCompletionAccepted)) }
+      attr_reader :data
+
+      sig do
+        params(data: T.nilable(Sentdm::ProfileCompletionAccepted::OrHash)).void
+      end
+      attr_writer :data
+
+      # Error information
+      sig { returns(T.nilable(Sentdm::ErrorDetail)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::ErrorDetail::OrHash)).void }
+      attr_writer :error
+
+      # Request and response metadata
+      sig { returns(T.nilable(Sentdm::APIMeta)) }
+      attr_reader :meta
+
+      sig { params(meta: Sentdm::APIMeta::OrHash).void }
+      attr_writer :meta
+
+      # Indicates whether the request was successful
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :success
+
+      sig { params(success: T::Boolean).void }
+      attr_writer :success
+
+      # Standard API response envelope for all v3 endpoints
+      sig do
+        params(
+          data: T.nilable(Sentdm::ProfileCompletionAccepted::OrHash),
+          error: T.nilable(Sentdm::ErrorDetail::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Response acknowledging that profile completion has been accepted and started in
+        # the background. The provided webhook URL will be called when processing
+        # finishes.
+        data: nil,
+        # Error information
+        error: nil,
+        # Request and response metadata
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T.nilable(Sentdm::ProfileCompletionAccepted),
+            error: T.nilable(Sentdm::ErrorDetail),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end