sentdm 0.2.0 → 0.3.0

data/rbi/sentdm/models/message_retrieve_status_response.rbi

@@ -0,0 +1,434 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MessageRetrieveStatusResponse < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Sentdm::Models::MessageRetrieveStatusResponse,
+            Sentdm::Internal::AnyHash
+          )
+        end
+
+      # The response data (null if error)
+      sig do
+        returns(T.nilable(Sentdm::Models::MessageRetrieveStatusResponse::Data))
+      end
+      attr_reader :data
+
+      sig do
+        params(
+          data:
+            T.nilable(
+              Sentdm::Models::MessageRetrieveStatusResponse::Data::OrHash
+            )
+        ).void
+      end
+      attr_writer :data
+
+      # Error details (null if successful)
+      sig { returns(T.nilable(Sentdm::APIError)) }
+      attr_reader :error
+
+      sig { params(error: T.nilable(Sentdm::APIError::OrHash)).void }
+      attr_writer :error
+
+      # Metadata about the request and response
+      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::Models::MessageRetrieveStatusResponse::Data::OrHash
+            ),
+          error: T.nilable(Sentdm::APIError::OrHash),
+          meta: Sentdm::APIMeta::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The response data (null if error)
+        data: nil,
+        # Error details (null if successful)
+        error: nil,
+        # Metadata about the request and response
+        meta: nil,
+        # Indicates whether the request was successful
+        success: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data:
+              T.nilable(Sentdm::Models::MessageRetrieveStatusResponse::Data),
+            error: T.nilable(Sentdm::APIError),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Models::MessageRetrieveStatusResponse::Data,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :id
+
+        sig { params(id: String).void }
+        attr_writer :id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :channel
+
+        sig { params(channel: String).void }
+        attr_writer :channel
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :contact_id
+
+        sig { params(contact_id: String).void }
+        attr_writer :contact_id
+
+        sig { returns(T.nilable(Time)) }
+        attr_reader :created_at
+
+        sig { params(created_at: Time).void }
+        attr_writer :created_at
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :customer_id
+
+        sig { params(customer_id: String).void }
+        attr_writer :customer_id
+
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                Sentdm::Models::MessageRetrieveStatusResponse::Data::Event
+              ]
+            )
+          )
+        end
+        attr_accessor :events
+
+        # Structured message body format for database storage. Preserves channel-specific
+        # components (header, body, footer, buttons).
+        sig do
+          returns(
+            T.nilable(
+              Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody
+            )
+          )
+        end
+        attr_reader :message_body
+
+        sig do
+          params(
+            message_body:
+              T.nilable(
+                Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody::OrHash
+              )
+          ).void
+        end
+        attr_writer :message_body
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :phone
+
+        sig { params(phone: String).void }
+        attr_writer :phone
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :phone_international
+
+        sig { params(phone_international: String).void }
+        attr_writer :phone_international
+
+        sig { returns(T.nilable(Float)) }
+        attr_accessor :price
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :region_code
+
+        sig { params(region_code: String).void }
+        attr_writer :region_code
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :status
+
+        sig { params(status: String).void }
+        attr_writer :status
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :template_category
+
+        sig { params(template_category: String).void }
+        attr_writer :template_category
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :template_id
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :template_name
+
+        sig { params(template_name: String).void }
+        attr_writer :template_name
+
+        # The response data (null if error)
+        sig do
+          params(
+            id: String,
+            channel: String,
+            contact_id: String,
+            created_at: Time,
+            customer_id: String,
+            events:
+              T.nilable(
+                T::Array[
+                  Sentdm::Models::MessageRetrieveStatusResponse::Data::Event::OrHash
+                ]
+              ),
+            message_body:
+              T.nilable(
+                Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody::OrHash
+              ),
+            phone: String,
+            phone_international: String,
+            price: T.nilable(Float),
+            region_code: String,
+            status: String,
+            template_category: String,
+            template_id: T.nilable(String),
+            template_name: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id: nil,
+          channel: nil,
+          contact_id: nil,
+          created_at: nil,
+          customer_id: nil,
+          events: nil,
+          # Structured message body format for database storage. Preserves channel-specific
+          # components (header, body, footer, buttons).
+          message_body: nil,
+          phone: nil,
+          phone_international: nil,
+          price: nil,
+          region_code: nil,
+          status: nil,
+          template_category: nil,
+          template_id: nil,
+          template_name: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              channel: String,
+              contact_id: String,
+              created_at: Time,
+              customer_id: String,
+              events:
+                T.nilable(
+                  T::Array[
+                    Sentdm::Models::MessageRetrieveStatusResponse::Data::Event
+                  ]
+                ),
+              message_body:
+                T.nilable(
+                  Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody
+                ),
+              phone: String,
+              phone_international: String,
+              price: T.nilable(Float),
+              region_code: String,
+              status: String,
+              template_category: String,
+              template_id: T.nilable(String),
+              template_name: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Event < Sentdm::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Sentdm::Models::MessageRetrieveStatusResponse::Data::Event,
+                Sentdm::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :description
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :status
+
+          sig { params(status: String).void }
+          attr_writer :status
+
+          sig { returns(T.nilable(Time)) }
+          attr_reader :timestamp
+
+          sig { params(timestamp: Time).void }
+          attr_writer :timestamp
+
+          # Represents a status change event in a message's lifecycle (v3)
+          sig do
+            params(
+              description: T.nilable(String),
+              status: String,
+              timestamp: Time
+            ).returns(T.attached_class)
+          end
+          def self.new(description: nil, status: nil, timestamp: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                description: T.nilable(String),
+                status: String,
+                timestamp: Time
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class MessageBody < Sentdm::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody,
+                Sentdm::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody::Button
+                ]
+              )
+            )
+          end
+          attr_accessor :buttons
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :content
+
+          sig { params(content: String).void }
+          attr_writer :content
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :footer
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :header
+
+          # Structured message body format for database storage. Preserves channel-specific
+          # components (header, body, footer, buttons).
+          sig do
+            params(
+              buttons:
+                T.nilable(
+                  T::Array[
+                    Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody::Button::OrHash
+                  ]
+                ),
+              content: String,
+              footer: T.nilable(String),
+              header: T.nilable(String)
+            ).returns(T.attached_class)
+          end
+          def self.new(buttons: nil, content: nil, footer: nil, header: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                buttons:
+                  T.nilable(
+                    T::Array[
+                      Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody::Button
+                    ]
+                  ),
+                content: String,
+                footer: T.nilable(String),
+                header: T.nilable(String)
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Button < Sentdm::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Sentdm::Models::MessageRetrieveStatusResponse::Data::MessageBody::Button,
+                  Sentdm::Internal::AnyHash
+                )
+              end
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :type
+
+            sig { params(type: String).void }
+            attr_writer :type
+
+            sig { returns(T.nilable(String)) }
+            attr_reader :value
+
+            sig { params(value: String).void }
+            attr_writer :value
+
+            sig do
+              params(type: String, value: String).returns(T.attached_class)
+            end
+            def self.new(type: nil, value: nil)
+            end
+
+            sig { override.returns({ type: String, value: String }) }
+            def to_hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/message_send_params.rbi

@@ -0,0 +1,143 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class MessageSendParams < Sentdm::Internal::Type::BaseModel
+      extend Sentdm::Internal::Type::RequestParameters::Converter
+      include Sentdm::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::MessageSendParams, Sentdm::Internal::AnyHash)
+        end
+
+      # Channels to broadcast on, e.g. ["whatsapp", "sms"]. Each channel produces a
+      # separate message per recipient. "sent" = auto-detect, "rcs" = reserved
+      # (skipped). Defaults to ["sent"] (auto-detect) if omitted.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_accessor :channel
+
+      # Template reference (by id or name, with optional parameters)
+      sig { returns(T.nilable(Sentdm::MessageSendParams::Template)) }
+      attr_reader :template
+
+      sig { params(template: Sentdm::MessageSendParams::Template::OrHash).void }
+      attr_writer :template
+
+      # Test mode 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 :test_mode
+
+      sig { params(test_mode: T::Boolean).void }
+      attr_writer :test_mode
+
+      # List of recipient phone numbers in E.164 format (multi-recipient fan-out)
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :to
+
+      sig { params(to: T::Array[String]).void }
+      attr_writer :to
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :idempotency_key
+
+      sig { params(idempotency_key: String).void }
+      attr_writer :idempotency_key
+
+      sig do
+        params(
+          channel: T.nilable(T::Array[String]),
+          template: Sentdm::MessageSendParams::Template::OrHash,
+          test_mode: T::Boolean,
+          to: T::Array[String],
+          idempotency_key: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Channels to broadcast on, e.g. ["whatsapp", "sms"]. Each channel produces a
+        # separate message per recipient. "sent" = auto-detect, "rcs" = reserved
+        # (skipped). Defaults to ["sent"] (auto-detect) if omitted.
+        channel: nil,
+        # Template reference (by id or name, with optional parameters)
+        template: nil,
+        # Test mode flag - when true, the operation is simulated without side effects
+        # Useful for testing integrations without actual execution
+        test_mode: nil,
+        # List of recipient phone numbers in E.164 format (multi-recipient fan-out)
+        to: nil,
+        idempotency_key: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            channel: T.nilable(T::Array[String]),
+            template: Sentdm::MessageSendParams::Template,
+            test_mode: T::Boolean,
+            to: T::Array[String],
+            idempotency_key: String,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Template < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::MessageSendParams::Template,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # Template ID (mutually exclusive with name)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :id
+
+        # Template name (mutually exclusive with id)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :name
+
+        # Template variable parameters for personalization
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_accessor :parameters
+
+        # Template reference (by id or name, with optional parameters)
+        sig do
+          params(
+            id: T.nilable(String),
+            name: T.nilable(String),
+            parameters: T.nilable(T::Hash[Symbol, String])
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Template ID (mutually exclusive with name)
+          id: nil,
+          # Template name (mutually exclusive with id)
+          name: nil,
+          # Template variable parameters for personalization
+          parameters: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: T.nilable(String),
+              name: T.nilable(String),
+              parameters: T.nilable(T::Hash[Symbol, String])
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end