sentdm 0.2.0 → 0.3.0

data/rbi/sentdm/models/api_error.rbi

@@ -0,0 +1,66 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIError < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::APIError, Sentdm::Internal::AnyHash) }
+
+      # Machine-readable error code (e.g., "RESOURCE_001")
+      sig { returns(T.nilable(String)) }
+      attr_reader :code
+
+      sig { params(code: String).void }
+      attr_writer :code
+
+      # Additional validation error details (field-level errors)
+      sig { returns(T.nilable(T::Hash[Symbol, T::Array[String]])) }
+      attr_accessor :details
+
+      # URL to documentation about this error
+      sig { returns(T.nilable(String)) }
+      attr_accessor :doc_url
+
+      # Human-readable error message
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      # Error information
+      sig do
+        params(
+          code: String,
+          details: T.nilable(T::Hash[Symbol, T::Array[String]]),
+          doc_url: T.nilable(String),
+          message: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Machine-readable error code (e.g., "RESOURCE_001")
+        code: nil,
+        # Additional validation error details (field-level errors)
+        details: nil,
+        # URL to documentation about this error
+        doc_url: nil,
+        # Human-readable error message
+        message: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            code: String,
+            details: T.nilable(T::Hash[Symbol, T::Array[String]]),
+            doc_url: T.nilable(String),
+            message: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_meta.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIMeta < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Sentdm::APIMeta, Sentdm::Internal::AnyHash) }
+
+      # Unique identifier for this request (for tracing and support)
+      sig { returns(T.nilable(String)) }
+      attr_reader :request_id
+
+      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
+
+      sig { params(timestamp: Time).void }
+      attr_writer :timestamp
+
+      # API version used for this request
+      sig { returns(T.nilable(String)) }
+      attr_reader :version
+
+      sig { params(version: String).void }
+      attr_writer :version
+
+      # Request and response metadata
+      sig do
+        params(
+          request_id: String,
+          response_time_ms: T.nilable(Integer),
+          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
+        version: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            request_id: String,
+            response_time_ms: T.nilable(Integer),
+            timestamp: Time,
+            version: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_brand_with_kyc.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseBrandWithKYC < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseBrandWithKYC, Sentdm::Internal::AnyHash)
+        end
+
+      # The response data (null if error)
+      sig { returns(T.nilable(Sentdm::BrandWithKYC)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::BrandWithKYC::OrHash)).void }
+      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::BrandWithKYC::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::BrandWithKYC),
+            error: T.nilable(Sentdm::APIError),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_contact.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseContact < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseContact, Sentdm::Internal::AnyHash)
+        end
+
+      # The response data (null if error)
+      sig { returns(T.nilable(Sentdm::Contact)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::Contact::OrHash)).void }
+      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::Contact::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::Contact),
+            error: T.nilable(Sentdm::APIError),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_of_profile_detail.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfProfileDetail < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseOfProfileDetail, Sentdm::Internal::AnyHash)
+        end
+
+      # The response data (null if error)
+      sig { returns(T.nilable(Sentdm::ProfileDetail)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::ProfileDetail::OrHash)).void }
+      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::ProfileDetail::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::ProfileDetail),
+            error: T.nilable(Sentdm::APIError),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_of_user.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseOfUser < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseOfUser, Sentdm::Internal::AnyHash)
+        end
+
+      # The response data (null if error)
+      sig { returns(T.nilable(Sentdm::UserResponse)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::UserResponse::OrHash)).void }
+      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::UserResponse::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::UserResponse),
+            error: T.nilable(Sentdm::APIError),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_template.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseTemplate < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseTemplate, Sentdm::Internal::AnyHash)
+        end
+
+      # The response data (null if error)
+      sig { returns(T.nilable(Sentdm::Template)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::Template::OrHash)).void }
+      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::Template::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::Template),
+            error: T.nilable(Sentdm::APIError),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/api_response_webhook.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class APIResponseWebhook < Sentdm::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::APIResponseWebhook, Sentdm::Internal::AnyHash)
+        end
+
+      # The response data (null if error)
+      sig { returns(T.nilable(Sentdm::WebhookResponse)) }
+      attr_reader :data
+
+      sig { params(data: T.nilable(Sentdm::WebhookResponse::OrHash)).void }
+      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::WebhookResponse::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::WebhookResponse),
+            error: T.nilable(Sentdm::APIError),
+            meta: Sentdm::APIMeta,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/sentdm/models/brand_create_params.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    class BrandCreateParams < Sentdm::Internal::Type::BaseModel
+      extend Sentdm::Internal::Type::RequestParameters::Converter
+      include Sentdm::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Sentdm::BrandCreateParams, Sentdm::Internal::AnyHash)
+        end
+
+      # Brand and KYC information
+      sig { returns(Sentdm::BrandData) }
+      attr_reader :brand
+
+      sig { params(brand: Sentdm::BrandData::OrHash).void }
+      attr_writer :brand
+
+      # 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
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :idempotency_key
+
+      sig { params(idempotency_key: String).void }
+      attr_writer :idempotency_key
+
+      sig do
+        params(
+          brand: Sentdm::BrandData::OrHash,
+          test_mode: T::Boolean,
+          idempotency_key: String,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Brand and KYC information
+        brand:,
+        # Test mode flag - when true, the operation is simulated without side effects
+        # Useful for testing integrations without actual execution
+        test_mode: nil,
+        idempotency_key: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            brand: Sentdm::BrandData,
+            test_mode: T::Boolean,
+            idempotency_key: String,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end