sentdm 0.1.0 → 0.3.0

data/rbi/sentdm/models/brands/campaign_data.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Brands
+      class CampaignData < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Brands::CampaignData, Sentdm::Internal::AnyHash)
+          end
+
+        # Campaign description
+        sig { returns(String) }
+        attr_accessor :description
+
+        # Campaign name
+        sig { returns(String) }
+        attr_accessor :name
+
+        # Campaign type (e.g., "KYC", "App")
+        sig { returns(String) }
+        attr_accessor :type
+
+        # List of use cases with sample messages
+        sig do
+          returns(
+            T::Array[
+              Sentdm::Brands::SentDmServicesEndpointsCustomerApIv3ContractsRequestsCampaignsCampaignUseCaseData
+            ]
+          )
+        end
+        attr_accessor :use_cases
+
+        # Comma-separated keywords that trigger help message (e.g., "HELP, INFO, SUPPORT")
+        sig { returns(T.nilable(String)) }
+        attr_accessor :help_keywords
+
+        # Message sent when user requests help
+        sig { returns(T.nilable(String)) }
+        attr_accessor :help_message
+
+        # Description of how messages flow in the campaign
+        sig { returns(T.nilable(String)) }
+        attr_accessor :message_flow
+
+        # Comma-separated keywords that trigger opt-in (e.g., "YES, START, SUBSCRIBE")
+        sig { returns(T.nilable(String)) }
+        attr_accessor :optin_keywords
+
+        # Message sent when user opts in
+        sig { returns(T.nilable(String)) }
+        attr_accessor :optin_message
+
+        # Comma-separated keywords that trigger opt-out (e.g., "STOP, UNSUBSCRIBE, END")
+        sig { returns(T.nilable(String)) }
+        attr_accessor :optout_keywords
+
+        # Message sent when user opts out
+        sig { returns(T.nilable(String)) }
+        attr_accessor :optout_message
+
+        # URL to privacy policy
+        sig { returns(T.nilable(String)) }
+        attr_accessor :privacy_policy_link
+
+        # URL to terms and conditions
+        sig { returns(T.nilable(String)) }
+        attr_accessor :terms_and_conditions_link
+
+        # Campaign data for create or update operation
+        sig do
+          params(
+            description: String,
+            name: String,
+            type: String,
+            use_cases:
+              T::Array[
+                Sentdm::Brands::SentDmServicesEndpointsCustomerApIv3ContractsRequestsCampaignsCampaignUseCaseData::OrHash
+              ],
+            help_keywords: T.nilable(String),
+            help_message: T.nilable(String),
+            message_flow: T.nilable(String),
+            optin_keywords: T.nilable(String),
+            optin_message: T.nilable(String),
+            optout_keywords: T.nilable(String),
+            optout_message: T.nilable(String),
+            privacy_policy_link: T.nilable(String),
+            terms_and_conditions_link: T.nilable(String)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Campaign description
+          description:,
+          # Campaign name
+          name:,
+          # Campaign type (e.g., "KYC", "App")
+          type:,
+          # List of use cases with sample messages
+          use_cases:,
+          # Comma-separated keywords that trigger help message (e.g., "HELP, INFO, SUPPORT")
+          help_keywords: nil,
+          # Message sent when user requests help
+          help_message: nil,
+          # Description of how messages flow in the campaign
+          message_flow: nil,
+          # Comma-separated keywords that trigger opt-in (e.g., "YES, START, SUBSCRIBE")
+          optin_keywords: nil,
+          # Message sent when user opts in
+          optin_message: nil,
+          # Comma-separated keywords that trigger opt-out (e.g., "STOP, UNSUBSCRIBE, END")
+          optout_keywords: nil,
+          # Message sent when user opts out
+          optout_message: nil,
+          # URL to privacy policy
+          privacy_policy_link: nil,
+          # URL to terms and conditions
+          terms_and_conditions_link: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              description: String,
+              name: String,
+              type: String,
+              use_cases:
+                T::Array[
+                  Sentdm::Brands::SentDmServicesEndpointsCustomerApIv3ContractsRequestsCampaignsCampaignUseCaseData
+                ],
+              help_keywords: T.nilable(String),
+              help_message: T.nilable(String),
+              message_flow: T.nilable(String),
+              optin_keywords: T.nilable(String),
+              optin_message: T.nilable(String),
+              optout_keywords: T.nilable(String),
+              optout_message: T.nilable(String),
+              privacy_policy_link: T.nilable(String),
+              terms_and_conditions_link: T.nilable(String)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/brands/campaign_delete_params.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Brands
+      class CampaignDeleteParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Brands::CampaignDeleteParams,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :brand_id
+
+        # Request to delete a campaign from a brand
+        sig { returns(Sentdm::Brands::CampaignDeleteParams::Body) }
+        attr_reader :body
+
+        sig do
+          params(body: Sentdm::Brands::CampaignDeleteParams::Body::OrHash).void
+        end
+        attr_writer :body
+
+        sig do
+          params(
+            brand_id: String,
+            body: Sentdm::Brands::CampaignDeleteParams::Body::OrHash,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          brand_id:,
+          # Request to delete a campaign from a brand
+          body:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              brand_id: String,
+              body: Sentdm::Brands::CampaignDeleteParams::Body,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Body < Sentdm::Models::MutationRequest
+          OrHash =
+            T.type_alias do
+              T.any(
+                Sentdm::Brands::CampaignDeleteParams::Body,
+                Sentdm::Internal::AnyHash
+              )
+            end
+
+          # Request to delete a campaign from a brand
+          sig { returns(T.attached_class) }
+          def self.new
+          end
+
+          sig { override.returns({}) }
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/brands/campaign_list_params.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Brands
+      class CampaignListParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(Sentdm::Brands::CampaignListParams, Sentdm::Internal::AnyHash)
+          end
+
+        sig do
+          params(request_options: Sentdm::RequestOptions::OrHash).returns(
+            T.attached_class
+          )
+        end
+        def self.new(request_options: {})
+        end
+
+        sig { override.returns({ request_options: Sentdm::RequestOptions }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/brands/campaign_list_response.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Brands
+      class CampaignListResponse < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Models::Brands::CampaignListResponse,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # The response data (null if error)
+        sig do
+          returns(T.nilable(T::Array[Sentdm::Brands::TcrCampaignWithUseCases]))
+        end
+        attr_accessor :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(
+                T::Array[Sentdm::Brands::TcrCampaignWithUseCases::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(T::Array[Sentdm::Brands::TcrCampaignWithUseCases]),
+              error: T.nilable(Sentdm::APIError),
+              meta: Sentdm::APIMeta,
+              success: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/brands/campaign_update_params.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Brands
+      class CampaignUpdateParams < Sentdm::Internal::Type::BaseModel
+        extend Sentdm::Internal::Type::RequestParameters::Converter
+        include Sentdm::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Brands::CampaignUpdateParams,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :brand_id
+
+        # Campaign data
+        sig { returns(Sentdm::Brands::CampaignData) }
+        attr_reader :campaign
+
+        sig { params(campaign: Sentdm::Brands::CampaignData::OrHash).void }
+        attr_writer :campaign
+
+        # 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_id: String,
+            campaign: Sentdm::Brands::CampaignData::OrHash,
+            test_mode: T::Boolean,
+            idempotency_key: String,
+            request_options: Sentdm::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          brand_id:,
+          # Campaign data
+          campaign:,
+          # 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_id: String,
+              campaign: Sentdm::Brands::CampaignData,
+              test_mode: T::Boolean,
+              idempotency_key: String,
+              request_options: Sentdm::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/brands/messaging_use_case_us.rbi

@@ -0,0 +1,69 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Brands
+      module MessagingUseCaseUs
+        extend Sentdm::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Sentdm::Brands::MessagingUseCaseUs) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        MARKETING =
+          T.let(:MARKETING, Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol)
+        ACCOUNT_NOTIFICATION =
+          T.let(
+            :ACCOUNT_NOTIFICATION,
+            Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol
+          )
+        CUSTOMER_CARE =
+          T.let(
+            :CUSTOMER_CARE,
+            Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol
+          )
+        FRAUD_ALERT =
+          T.let(:FRAUD_ALERT, Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol)
+        TWO_FA =
+          T.let(:TWO_FA, Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol)
+        DELIVERY_NOTIFICATION =
+          T.let(
+            :DELIVERY_NOTIFICATION,
+            Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol
+          )
+        SECURITY_ALERT =
+          T.let(
+            :SECURITY_ALERT,
+            Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol
+          )
+        M2_M = T.let(:M2M, Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol)
+        MIXED = T.let(:MIXED, Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol)
+        HIGHER_EDUCATION =
+          T.let(
+            :HIGHER_EDUCATION,
+            Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol
+          )
+        POLLING_VOTING =
+          T.let(
+            :POLLING_VOTING,
+            Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol
+          )
+        PUBLIC_SERVICE_ANNOUNCEMENT =
+          T.let(
+            :PUBLIC_SERVICE_ANNOUNCEMENT,
+            Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol
+          )
+        LOW_VOLUME =
+          T.let(:LOW_VOLUME, Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Sentdm::Brands::MessagingUseCaseUs::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/sentdm/models/brands/sent_dm_services_endpoints_customer_ap_iv3_contracts_requests_campaigns_campaign_use_case_data.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Sentdm
+  module Models
+    module Brands
+      class SentDmServicesEndpointsCustomerApIv3ContractsRequestsCampaignsCampaignUseCaseData < Sentdm::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Sentdm::Brands::SentDmServicesEndpointsCustomerApIv3ContractsRequestsCampaignsCampaignUseCaseData,
+              Sentdm::Internal::AnyHash
+            )
+          end
+
+        # US messaging use case category
+        sig { returns(Sentdm::Brands::MessagingUseCaseUs::OrSymbol) }
+        attr_accessor :messaging_use_case_us
+
+        # Sample messages for this use case (1-5 messages, max 1024 characters each)
+        sig { returns(T::Array[String]) }
+        attr_accessor :sample_messages
+
+        # Campaign use case with sample messages
+        sig do
+          params(
+            messaging_use_case_us: Sentdm::Brands::MessagingUseCaseUs::OrSymbol,
+            sample_messages: T::Array[String]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # US messaging use case category
+          messaging_use_case_us:,
+          # Sample messages for this use case (1-5 messages, max 1024 characters each)
+          sample_messages:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              messaging_use_case_us:
+                Sentdm::Brands::MessagingUseCaseUs::OrSymbol,
+              sample_messages: T::Array[String]
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end