sentdm 0.3.1 → 0.5.0

data/rbi/sentdm/models/api_meta.rbi

@@ -13,10 +13,6 @@ module Sentdm
       sig { params(request_id: String).void }
       attr_writer :request_id
 
-      # Response time in milliseconds (optional)
-      sig { returns(T.nilable(Integer)) }
-      attr_accessor :response_time_ms
-
       # Server timestamp when the response was generated
       sig { returns(T.nilable(Time)) }
       attr_reader :timestamp
@@ -33,18 +29,13 @@ module Sentdm
 
       # Request and response metadata
       sig do
-        params(
-          request_id: String,
-          response_time_ms: T.nilable(Integer),
-          timestamp: Time,
-          version: String
-        ).returns(T.attached_class)
+        params(request_id: String, timestamp: Time, version: String).returns(
+          T.attached_class
+        )
       end
       def self.new(
         # Unique identifier for this request (for tracing and support)
         request_id: nil,
-        # Response time in milliseconds (optional)
-        response_time_ms: nil,
         # Server timestamp when the response was generated
         timestamp: nil,
         # API version used for this request
@@ -54,12 +45,7 @@ module Sentdm
 
       sig do
         override.returns(
-          {
-            request_id: String,
-            response_time_ms: T.nilable(Integer),
-            timestamp: Time,
-            version: String
-          }
+          { request_id: String, timestamp: Time, version: String }
         )
       end
       def to_hash

data/rbi/sentdm/models/{api_response_brand_with_kyc.rbi → api_response_of_contact.rbi}

@@ -2,17 +2,17 @@
 
 module Sentdm
   module Models
-    class APIResponseBrandWithKYC < Sentdm::Internal::Type::BaseModel
+    class APIResponseOfContact < Sentdm::Internal::Type::BaseModel
       OrHash =
         T.type_alias do
-          T.any(Sentdm::APIResponseBrandWithKYC, Sentdm::Internal::AnyHash)
+          T.any(Sentdm::APIResponseOfContact, Sentdm::Internal::AnyHash)
         end
 
       # The response data (null if error)
-      sig { returns(T.nilable(Sentdm::BrandWithKYC)) }
+      sig { returns(T.nilable(Sentdm::ContactResponse)) }
       attr_reader :data
 
-      sig { params(data: T.nilable(Sentdm::BrandWithKYC::OrHash)).void }
+      sig { params(data: T.nilable(Sentdm::ContactResponse::OrHash)).void }
       attr_writer :data
 
       # Error details (null if successful)
@@ -39,7 +39,7 @@ module Sentdm
       # Standard API response envelope for all v3 endpoints
       sig do
         params(
-          data: T.nilable(Sentdm::BrandWithKYC::OrHash),
+          data: T.nilable(Sentdm::ContactResponse::OrHash),
           error: T.nilable(Sentdm::APIError::OrHash),
           meta: Sentdm::APIMeta::OrHash,
           success: T::Boolean
@@ -60,7 +60,7 @@ module Sentdm
       sig do
         override.returns(
           {
-            data: T.nilable(Sentdm::BrandWithKYC),
+            data: T.nilable(Sentdm::ContactResponse),
             error: T.nilable(Sentdm::APIError),
             meta: Sentdm::APIMeta,
             success: T::Boolean

data/rbi/sentdm/models/base_dto.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class BaseDto < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::BaseDto, Sentdm::Internal::AnyHash) }
+
+      # Unique identifier
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      sig { returns(T.nilable(Time)) }
+      attr_reader :created_at
+
+      sig { params(created_at: Time).void }
+      attr_writer :created_at
+
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :updated_at
+
+      sig do
+        params(
+          id: String,
+          created_at: Time,
+          updated_at: T.nilable(Time)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier
+        id: nil,
+        created_at: nil,
+        updated_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { id: String, created_at: Time, updated_at: T.nilable(Time) }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/billing_contact_info.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class BillingContactInfo < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::BillingContactInfo, Sentdm::Internal::AnyHash)
+        end
+
+      # Email address where invoices will be sent (required)
+      sig { returns(String) }
+      attr_accessor :email
+
+      # Full name of the billing contact or company (required)
+      sig { returns(String) }
+      attr_accessor :name
+
+      # Billing address (optional). Free-form text including street, city, state, postal
+      # code, and country.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :address
+
+      # Phone number for the billing contact (optional)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :phone
+
+      # Billing contact information for a profile. Required when billing_model is
+      # "profile" or "profile_and_organization".
+      sig do
+        params(
+          email: String,
+          name: String,
+          address: T.nilable(String),
+          phone: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Email address where invoices will be sent (required)
+        email:,
+        # Full name of the billing contact or company (required)
+        name:,
+        # Billing address (optional). Free-form text including street, city, state, postal
+        # code, and country.
+        address: nil,
+        # Phone number for the billing contact (optional)
+        phone: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            email: String,
+            name: String,
+            address: T.nilable(String),
+            phone: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/brands_brand_data.rbi

@@ -0,0 +1,406 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class BrandsBrandData < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::BrandsBrandData, Sentdm::Internal::AnyHash)
+        end
+
+      # Compliance and TCR-related information
+      sig { returns(Sentdm::BrandsBrandData::Compliance) }
+      attr_reader :compliance
+
+      sig do
+        params(compliance: Sentdm::BrandsBrandData::Compliance::OrHash).void
+      end
+      attr_writer :compliance
+
+      # Contact information for the brand
+      sig { returns(Sentdm::BrandsBrandData::Contact) }
+      attr_reader :contact
+
+      sig { params(contact: Sentdm::BrandsBrandData::Contact::OrHash).void }
+      attr_writer :contact
+
+      # Business details and address information
+      sig { returns(T.nilable(Sentdm::BrandsBrandData::Business)) }
+      attr_reader :business
+
+      sig do
+        params(
+          business: T.nilable(Sentdm::BrandsBrandData::Business::OrHash)
+        ).void
+      end
+      attr_writer :business
+
+      # Brand and KYC data grouped into contact, business, and compliance sections
+      sig do
+        params(
+          compliance: Sentdm::BrandsBrandData::Compliance::OrHash,
+          contact: Sentdm::BrandsBrandData::Contact::OrHash,
+          business: T.nilable(Sentdm::BrandsBrandData::Business::OrHash)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Compliance and TCR-related information
+        compliance:,
+        # Contact information for the brand
+        contact:,
+        # Business details and address information
+        business: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            compliance: Sentdm::BrandsBrandData::Compliance,
+            contact: Sentdm::BrandsBrandData::Contact,
+            business: T.nilable(Sentdm::BrandsBrandData::Business)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Compliance < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::BrandsBrandData::Compliance,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # Brand relationship level with TCR (required for TCR)
+        sig { returns(Sentdm::TcrBrandRelationship::OrSymbol) }
+        attr_accessor :brand_relationship
+
+        # Business vertical/industry category (required for TCR)
+        sig { returns(Sentdm::TcrVertical::OrSymbol) }
+        attr_accessor :vertical
+
+        # List of destination countries for messaging
+        sig { returns(T.nilable(T::Array[Sentdm::DestinationCountry])) }
+        attr_accessor :destination_countries
+
+        # Expected daily messaging volume
+        sig { returns(T.nilable(String)) }
+        attr_accessor :expected_messaging_volume
+
+        # Whether this is a TCR (Campaign Registry) application
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :is_tcr_application
+
+        # Additional notes about the business or use case
+        sig { returns(T.nilable(String)) }
+        attr_accessor :notes
+
+        # Phone number prefix for messaging (e.g., "+1")
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone_number_prefix
+
+        # Primary messaging use case description
+        sig { returns(T.nilable(String)) }
+        attr_accessor :primary_use_case
+
+        # Compliance and TCR-related information
+        sig do
+          params(
+            brand_relationship: Sentdm::TcrBrandRelationship::OrSymbol,
+            vertical: Sentdm::TcrVertical::OrSymbol,
+            destination_countries:
+              T.nilable(T::Array[Sentdm::DestinationCountry::OrHash]),
+            expected_messaging_volume: T.nilable(String),
+            is_tcr_application: T.nilable(T::Boolean),
+            notes: T.nilable(String),
+            phone_number_prefix: T.nilable(String),
+            primary_use_case: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Brand relationship level with TCR (required for TCR)
+          brand_relationship:,
+          # Business vertical/industry category (required for TCR)
+          vertical:,
+          # List of destination countries for messaging
+          destination_countries: nil,
+          # Expected daily messaging volume
+          expected_messaging_volume: nil,
+          # Whether this is a TCR (Campaign Registry) application
+          is_tcr_application: nil,
+          # Additional notes about the business or use case
+          notes: nil,
+          # Phone number prefix for messaging (e.g., "+1")
+          phone_number_prefix: nil,
+          # Primary messaging use case description
+          primary_use_case: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              brand_relationship: Sentdm::TcrBrandRelationship::OrSymbol,
+              vertical: Sentdm::TcrVertical::OrSymbol,
+              destination_countries:
+                T.nilable(T::Array[Sentdm::DestinationCountry]),
+              expected_messaging_volume: T.nilable(String),
+              is_tcr_application: T.nilable(T::Boolean),
+              notes: T.nilable(String),
+              phone_number_prefix: T.nilable(String),
+              primary_use_case: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Contact < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::BrandsBrandData::Contact, Sentdm::Internal::AnyHash)
+          end
+
+        # Primary contact name (required)
+        sig { returns(String) }
+        attr_accessor :name
+
+        # Business/brand name
+        sig { returns(T.nilable(String)) }
+        attr_accessor :business_name
+
+        # Contact email address
+        sig { returns(T.nilable(String)) }
+        attr_accessor :email
+
+        # Contact phone number in E.164 format
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone
+
+        # Contact phone country code (e.g., "1" for US)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone_country_code
+
+        # Contact's role in the business
+        sig { returns(T.nilable(String)) }
+        attr_accessor :role
+
+        # Contact information for the brand
+        sig do
+          params(
+            name: String,
+            business_name: T.nilable(String),
+            email: T.nilable(String),
+            phone: T.nilable(String),
+            phone_country_code: T.nilable(String),
+            role: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Primary contact name (required)
+          name:,
+          # Business/brand name
+          business_name: nil,
+          # Contact email address
+          email: nil,
+          # Contact phone number in E.164 format
+          phone: nil,
+          # Contact phone country code (e.g., "1" for US)
+          phone_country_code: nil,
+          # Contact's role in the business
+          role: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: String,
+              business_name: T.nilable(String),
+              email: T.nilable(String),
+              phone: T.nilable(String),
+              phone_country_code: T.nilable(String),
+              role: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Business < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::BrandsBrandData::Business, Sentdm::Internal::AnyHash)
+          end
+
+        # City
+        sig { returns(T.nilable(String)) }
+        attr_accessor :city
+
+        # Country code (e.g., US, CA)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :country
+
+        # Country where the business is registered
+        sig { returns(T.nilable(String)) }
+        attr_accessor :country_of_registration
+
+        # Business entity type
+        sig do
+          returns(
+            T.nilable(Sentdm::BrandsBrandData::Business::EntityType::OrSymbol)
+          )
+        end
+        attr_accessor :entity_type
+
+        # Legal business name
+        sig { returns(T.nilable(String)) }
+        attr_accessor :legal_name
+
+        # Postal/ZIP code
+        sig { returns(T.nilable(String)) }
+        attr_accessor :postal_code
+
+        # State/province code
+        sig { returns(T.nilable(String)) }
+        attr_accessor :state
+
+        # Street address
+        sig { returns(T.nilable(String)) }
+        attr_accessor :street
+
+        # Tax ID/EIN number
+        sig { returns(T.nilable(String)) }
+        attr_accessor :tax_id
+
+        # Type of tax ID (e.g., us_ein, ca_bn)
+        sig { returns(T.nilable(String)) }
+        attr_accessor :tax_id_type
+
+        # Business website URL
+        sig { returns(T.nilable(String)) }
+        attr_accessor :url
+
+        # Business details and address information
+        sig do
+          params(
+            city: T.nilable(String),
+            country: T.nilable(String),
+            country_of_registration: T.nilable(String),
+            entity_type:
+              T.nilable(
+                Sentdm::BrandsBrandData::Business::EntityType::OrSymbol
+              ),
+            legal_name: T.nilable(String),
+            postal_code: T.nilable(String),
+            state: T.nilable(String),
+            street: T.nilable(String),
+            tax_id: T.nilable(String),
+            tax_id_type: T.nilable(String),
+            url: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # City
+          city: nil,
+          # Country code (e.g., US, CA)
+          country: nil,
+          # Country where the business is registered
+          country_of_registration: nil,
+          # Business entity type
+          entity_type: nil,
+          # Legal business name
+          legal_name: nil,
+          # Postal/ZIP code
+          postal_code: nil,
+          # State/province code
+          state: nil,
+          # Street address
+          street: nil,
+          # Tax ID/EIN number
+          tax_id: nil,
+          # Type of tax ID (e.g., us_ein, ca_bn)
+          tax_id_type: nil,
+          # Business website URL
+          url: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              city: T.nilable(String),
+              country: T.nilable(String),
+              country_of_registration: T.nilable(String),
+              entity_type:
+                T.nilable(
+                  Sentdm::BrandsBrandData::Business::EntityType::OrSymbol
+                ),
+              legal_name: T.nilable(String),
+              postal_code: T.nilable(String),
+              state: T.nilable(String),
+              street: T.nilable(String),
+              tax_id: T.nilable(String),
+              tax_id_type: T.nilable(String),
+              url: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Business entity type
+        module EntityType
+          extend Sentdm::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Sentdm::BrandsBrandData::Business::EntityType)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PRIVATE_PROFIT =
+            T.let(
+              :PRIVATE_PROFIT,
+              Sentdm::BrandsBrandData::Business::EntityType::TaggedSymbol
+            )
+          PUBLIC_PROFIT =
+            T.let(
+              :PUBLIC_PROFIT,
+              Sentdm::BrandsBrandData::Business::EntityType::TaggedSymbol
+            )
+          NON_PROFIT =
+            T.let(
+              :NON_PROFIT,
+              Sentdm::BrandsBrandData::Business::EntityType::TaggedSymbol
+            )
+          SOLE_PROPRIETOR =
+            T.let(
+              :SOLE_PROPRIETOR,
+              Sentdm::BrandsBrandData::Business::EntityType::TaggedSymbol
+            )
+          GOVERNMENT =
+            T.let(
+              :GOVERNMENT,
+              Sentdm::BrandsBrandData::Business::EntityType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Sentdm::BrandsBrandData::Business::EntityType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/contact_create_params.rbi

@@ -18,13 +18,13 @@ module Sentdm
       sig { params(phone_number: String).void }
       attr_writer :phone_number
 
-      # Test mode flag - when true, the operation is simulated without side effects
-      # Useful for testing integrations without actual execution
+      # Sandbox 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
+      attr_reader :sandbox
 
-      sig { params(test_mode: T::Boolean).void }
-      attr_writer :test_mode
+      sig { params(sandbox: T::Boolean).void }
+      attr_writer :sandbox
 
       sig { returns(T.nilable(String)) }
       attr_reader :idempotency_key
@@ -32,21 +32,29 @@ module Sentdm
       sig { params(idempotency_key: String).void }
       attr_writer :idempotency_key
 
+      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(
           phone_number: String,
-          test_mode: T::Boolean,
+          sandbox: T::Boolean,
           idempotency_key: String,
+          x_profile_id: String,
           request_options: Sentdm::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
         # Phone number of the contact to create
         phone_number: nil,
-        # Test mode flag - when true, the operation is simulated without side effects
-        # Useful for testing integrations without actual execution
-        test_mode: nil,
+        # Sandbox flag - when true, the operation is simulated without side effects Useful
+        # for testing integrations without actual execution
+        sandbox: nil,
         idempotency_key: nil,
+        x_profile_id: nil,
         request_options: {}
       )
       end
@@ -55,8 +63,9 @@ module Sentdm
         override.returns(
           {
             phone_number: String,
-            test_mode: T::Boolean,
+            sandbox: T::Boolean,
             idempotency_key: String,
+            x_profile_id: String,
             request_options: Sentdm::RequestOptions
           }
         )