sentdm 0.1.0 → 0.3.0

data/rbi/sentdm/models/template_definition.rbi

@@ -10,28 +10,44 @@ module Sentdm
 
       # Required template body with content for different channels (multi-channel,
       # SMS-specific, or WhatsApp-specific)
-      sig { returns(Sentdm::TemplateDefinition::Body) }
+      sig { returns(Sentdm::SentDmServicesCommonContractsPocOsTemplateBody) }
       attr_reader :body
 
-      sig { params(body: Sentdm::TemplateDefinition::Body::OrHash).void }
+      sig do
+        params(
+          body: Sentdm::SentDmServicesCommonContractsPocOsTemplateBody::OrHash
+        ).void
+      end
       attr_writer :body
 
       # Configuration specific to AUTHENTICATION category templates (optional)
       sig do
-        returns(T.nilable(Sentdm::TemplateDefinition::AuthenticationConfig))
+        returns(
+          T.nilable(
+            Sentdm::SentDmServicesCommonContractsPocOsAuthenticationConfig
+          )
+        )
       end
       attr_reader :authentication_config
 
       sig do
         params(
           authentication_config:
-            T.nilable(Sentdm::TemplateDefinition::AuthenticationConfig::OrHash)
+            T.nilable(
+              Sentdm::SentDmServicesCommonContractsPocOsAuthenticationConfig::OrHash
+            )
         ).void
       end
       attr_writer :authentication_config
 
       # Optional list of interactive buttons (e.g., quick replies, URLs, phone numbers)
-      sig { returns(T.nilable(T::Array[Sentdm::TemplateDefinition::Button])) }
+      sig do
+        returns(
+          T.nilable(
+            T::Array[Sentdm::SentDmServicesCommonContractsPocOsTemplateButton]
+          )
+        )
+      end
       attr_accessor :buttons
 
       # The version of the template definition format
@@ -39,23 +55,37 @@ module Sentdm
       attr_accessor :definition_version
 
       # Optional template footer with optional variables
-      sig { returns(T.nilable(Sentdm::TemplateDefinition::Footer)) }
+      sig do
+        returns(
+          T.nilable(Sentdm::SentDmServicesCommonContractsPocOsTemplateFooter)
+        )
+      end
       attr_reader :footer
 
       sig do
         params(
-          footer: T.nilable(Sentdm::TemplateDefinition::Footer::OrHash)
+          footer:
+            T.nilable(
+              Sentdm::SentDmServicesCommonContractsPocOsTemplateFooter::OrHash
+            )
         ).void
       end
       attr_writer :footer
 
       # Optional template header with optional variables
-      sig { returns(T.nilable(Sentdm::TemplateDefinition::Header)) }
+      sig do
+        returns(
+          T.nilable(Sentdm::SentDmServicesCommonContractsPocOsTemplateHeader)
+        )
+      end
       attr_reader :header
 
       sig do
         params(
-          header: T.nilable(Sentdm::TemplateDefinition::Header::OrHash)
+          header:
+            T.nilable(
+              Sentdm::SentDmServicesCommonContractsPocOsTemplateHeader::OrHash
+            )
         ).void
       end
       attr_writer :header
@@ -64,14 +94,26 @@ module Sentdm
       # buttons
       sig do
         params(
-          body: Sentdm::TemplateDefinition::Body::OrHash,
+          body: Sentdm::SentDmServicesCommonContractsPocOsTemplateBody::OrHash,
           authentication_config:
-            T.nilable(Sentdm::TemplateDefinition::AuthenticationConfig::OrHash),
+            T.nilable(
+              Sentdm::SentDmServicesCommonContractsPocOsAuthenticationConfig::OrHash
+            ),
           buttons:
-            T.nilable(T::Array[Sentdm::TemplateDefinition::Button::OrHash]),
+            T.nilable(
+              T::Array[
+                Sentdm::SentDmServicesCommonContractsPocOsTemplateButton::OrHash
+              ]
+            ),
           definition_version: T.nilable(String),
-          footer: T.nilable(Sentdm::TemplateDefinition::Footer::OrHash),
-          header: T.nilable(Sentdm::TemplateDefinition::Header::OrHash)
+          footer:
+            T.nilable(
+              Sentdm::SentDmServicesCommonContractsPocOsTemplateFooter::OrHash
+            ),
+          header:
+            T.nilable(
+              Sentdm::SentDmServicesCommonContractsPocOsTemplateHeader::OrHash
+            )
         ).returns(T.attached_class)
       end
       def self.new(
@@ -94,404 +136,31 @@ module Sentdm
       sig do
         override.returns(
           {
-            body: Sentdm::TemplateDefinition::Body,
+            body: Sentdm::SentDmServicesCommonContractsPocOsTemplateBody,
             authentication_config:
-              T.nilable(Sentdm::TemplateDefinition::AuthenticationConfig),
-            buttons: T.nilable(T::Array[Sentdm::TemplateDefinition::Button]),
+              T.nilable(
+                Sentdm::SentDmServicesCommonContractsPocOsAuthenticationConfig
+              ),
+            buttons:
+              T.nilable(
+                T::Array[
+                  Sentdm::SentDmServicesCommonContractsPocOsTemplateButton
+                ]
+              ),
             definition_version: T.nilable(String),
-            footer: T.nilable(Sentdm::TemplateDefinition::Footer),
-            header: T.nilable(Sentdm::TemplateDefinition::Header)
+            footer:
+              T.nilable(
+                Sentdm::SentDmServicesCommonContractsPocOsTemplateFooter
+              ),
+            header:
+              T.nilable(
+                Sentdm::SentDmServicesCommonContractsPocOsTemplateHeader
+              )
           }
         )
       end
       def to_hash
       end
-
-      class Body < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Sentdm::TemplateDefinition::Body, Sentdm::Internal::AnyHash)
-          end
-
-        # Content that will be used for all channels (SMS and WhatsApp) unless
-        # channel-specific content is provided
-        sig { returns(T.nilable(Sentdm::TemplateBodyContent)) }
-        attr_reader :multi_channel
-
-        sig do
-          params(
-            multi_channel: T.nilable(Sentdm::TemplateBodyContent::OrHash)
-          ).void
-        end
-        attr_writer :multi_channel
-
-        # SMS-specific content that overrides multi-channel content for SMS messages
-        sig { returns(T.nilable(Sentdm::TemplateBodyContent)) }
-        attr_reader :sms
-
-        sig { params(sms: T.nilable(Sentdm::TemplateBodyContent::OrHash)).void }
-        attr_writer :sms
-
-        # WhatsApp-specific content that overrides multi-channel content for WhatsApp
-        # messages
-        sig { returns(T.nilable(Sentdm::TemplateBodyContent)) }
-        attr_reader :whatsapp
-
-        sig do
-          params(whatsapp: T.nilable(Sentdm::TemplateBodyContent::OrHash)).void
-        end
-        attr_writer :whatsapp
-
-        # Required template body with content for different channels (multi-channel,
-        # SMS-specific, or WhatsApp-specific)
-        sig do
-          params(
-            multi_channel: T.nilable(Sentdm::TemplateBodyContent::OrHash),
-            sms: T.nilable(Sentdm::TemplateBodyContent::OrHash),
-            whatsapp: T.nilable(Sentdm::TemplateBodyContent::OrHash)
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Content that will be used for all channels (SMS and WhatsApp) unless
-          # channel-specific content is provided
-          multi_channel: nil,
-          # SMS-specific content that overrides multi-channel content for SMS messages
-          sms: nil,
-          # WhatsApp-specific content that overrides multi-channel content for WhatsApp
-          # messages
-          whatsapp: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              multi_channel: T.nilable(Sentdm::TemplateBodyContent),
-              sms: T.nilable(Sentdm::TemplateBodyContent),
-              whatsapp: T.nilable(Sentdm::TemplateBodyContent)
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-
-      class AuthenticationConfig < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              Sentdm::TemplateDefinition::AuthenticationConfig,
-              Sentdm::Internal::AnyHash
-            )
-          end
-
-        # Whether to add the security recommendation text: "For your security, do not
-        # share this code."
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_reader :add_security_recommendation
-
-        sig { params(add_security_recommendation: T::Boolean).void }
-        attr_writer :add_security_recommendation
-
-        # Code expiration time in minutes (1-90). If set, adds footer: "This code expires
-        # in X minutes."
-        sig { returns(T.nilable(Integer)) }
-        attr_accessor :code_expiration_minutes
-
-        # Configuration specific to AUTHENTICATION category templates (optional)
-        sig do
-          params(
-            add_security_recommendation: T::Boolean,
-            code_expiration_minutes: T.nilable(Integer)
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # Whether to add the security recommendation text: "For your security, do not
-          # share this code."
-          add_security_recommendation: nil,
-          # Code expiration time in minutes (1-90). If set, adds footer: "This code expires
-          # in X minutes."
-          code_expiration_minutes: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              add_security_recommendation: T::Boolean,
-              code_expiration_minutes: T.nilable(Integer)
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-
-      class Button < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Sentdm::TemplateDefinition::Button, Sentdm::Internal::AnyHash)
-          end
-
-        # The unique identifier of the button (1-based index)
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :id
-
-        sig { params(id: Integer).void }
-        attr_writer :id
-
-        # Properties specific to the button type
-        sig { returns(T.nilable(Sentdm::TemplateDefinition::Button::Props)) }
-        attr_reader :props
-
-        sig do
-          params(props: Sentdm::TemplateDefinition::Button::Props::OrHash).void
-        end
-        attr_writer :props
-
-        # The type of button (e.g., QUICK_REPLY, URL, PHONE_NUMBER, VOICE_CALL, COPY_CODE)
-        sig { returns(T.nilable(String)) }
-        attr_reader :type
-
-        sig { params(type: String).void }
-        attr_writer :type
-
-        # Interactive button in a message template
-        sig do
-          params(
-            id: Integer,
-            props: Sentdm::TemplateDefinition::Button::Props::OrHash,
-            type: String
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The unique identifier of the button (1-based index)
-          id: nil,
-          # Properties specific to the button type
-          props: nil,
-          # The type of button (e.g., QUICK_REPLY, URL, PHONE_NUMBER, VOICE_CALL, COPY_CODE)
-          type: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              id: Integer,
-              props: Sentdm::TemplateDefinition::Button::Props,
-              type: String
-            }
-          )
-        end
-        def to_hash
-        end
-
-        class Props < Sentdm::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                Sentdm::TemplateDefinition::Button::Props,
-                Sentdm::Internal::AnyHash
-              )
-            end
-
-          sig { returns(T.nilable(Integer)) }
-          attr_accessor :active_for
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :autofill_text
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :country_code
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :offer_code
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :otp_type
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :package_name
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :phone_number
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :quick_reply_type
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :signature_hash
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :text
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :url
-
-          sig { returns(T.nilable(String)) }
-          attr_accessor :url_type
-
-          # Properties specific to the button type
-          sig do
-            params(
-              active_for: T.nilable(Integer),
-              autofill_text: T.nilable(String),
-              country_code: T.nilable(String),
-              offer_code: T.nilable(String),
-              otp_type: T.nilable(String),
-              package_name: T.nilable(String),
-              phone_number: T.nilable(String),
-              quick_reply_type: T.nilable(String),
-              signature_hash: T.nilable(String),
-              text: T.nilable(String),
-              url: T.nilable(String),
-              url_type: T.nilable(String)
-            ).returns(T.attached_class)
-          end
-          def self.new(
-            active_for: nil,
-            autofill_text: nil,
-            country_code: nil,
-            offer_code: nil,
-            otp_type: nil,
-            package_name: nil,
-            phone_number: nil,
-            quick_reply_type: nil,
-            signature_hash: nil,
-            text: nil,
-            url: nil,
-            url_type: nil
-          )
-          end
-
-          sig do
-            override.returns(
-              {
-                active_for: T.nilable(Integer),
-                autofill_text: T.nilable(String),
-                country_code: T.nilable(String),
-                offer_code: T.nilable(String),
-                otp_type: T.nilable(String),
-                package_name: T.nilable(String),
-                phone_number: T.nilable(String),
-                quick_reply_type: T.nilable(String),
-                signature_hash: T.nilable(String),
-                text: T.nilable(String),
-                url: T.nilable(String),
-                url_type: T.nilable(String)
-              }
-            )
-          end
-          def to_hash
-          end
-        end
-      end
-
-      class Footer < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Sentdm::TemplateDefinition::Footer, Sentdm::Internal::AnyHash)
-          end
-
-        # The footer template text with optional variable placeholders
-        sig { returns(T.nilable(String)) }
-        attr_reader :template
-
-        sig { params(template: String).void }
-        attr_writer :template
-
-        # The type of footer (typically "text")
-        sig { returns(T.nilable(String)) }
-        attr_accessor :type
-
-        # List of variables used in the footer template
-        sig { returns(T.nilable(T::Array[Sentdm::TemplateVariable])) }
-        attr_accessor :variables
-
-        # Optional template footer with optional variables
-        sig do
-          params(
-            template: String,
-            type: T.nilable(String),
-            variables: T.nilable(T::Array[Sentdm::TemplateVariable::OrHash])
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The footer template text with optional variable placeholders
-          template: nil,
-          # The type of footer (typically "text")
-          type: nil,
-          # List of variables used in the footer template
-          variables: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              template: String,
-              type: T.nilable(String),
-              variables: T.nilable(T::Array[Sentdm::TemplateVariable])
-            }
-          )
-        end
-        def to_hash
-        end
-      end
-
-      class Header < Sentdm::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Sentdm::TemplateDefinition::Header, Sentdm::Internal::AnyHash)
-          end
-
-        # The header template text with optional variable placeholders (e.g., "Welcome to
-        # {{0:variable}}")
-        sig { returns(T.nilable(String)) }
-        attr_reader :template
-
-        sig { params(template: String).void }
-        attr_writer :template
-
-        # The type of header (e.g., "text", "image", "video", "document")
-        sig { returns(T.nilable(String)) }
-        attr_accessor :type
-
-        # List of variables used in the header template
-        sig { returns(T.nilable(T::Array[Sentdm::TemplateVariable])) }
-        attr_accessor :variables
-
-        # Optional template header with optional variables
-        sig do
-          params(
-            template: String,
-            type: T.nilable(String),
-            variables: T.nilable(T::Array[Sentdm::TemplateVariable::OrHash])
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          # The header template text with optional variable placeholders (e.g., "Welcome to
-          # {{0:variable}}")
-          template: nil,
-          # The type of header (e.g., "text", "image", "video", "document")
-          type: nil,
-          # List of variables used in the header template
-          variables: nil
-        )
-        end
-
-        sig do
-          override.returns(
-            {
-              template: String,
-              type: T.nilable(String),
-              variables: T.nilable(T::Array[Sentdm::TemplateVariable])
-            }
-          )
-        end
-        def to_hash
-        end
-      end
     end
   end
 end

data/rbi/sentdm/models/template_delete_params.rbi

@@ -11,15 +11,46 @@ module Sentdm
           T.any(Sentdm::TemplateDeleteParams, Sentdm::Internal::AnyHash)
         end
 
+      # Whether to also delete the template from WhatsApp/Meta (optional, defaults to
+      # false)
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_accessor :delete_from_meta
+
+      # 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 do
-        params(request_options: Sentdm::RequestOptions::OrHash).returns(
-          T.attached_class
-        )
+        params(
+          delete_from_meta: T.nilable(T::Boolean),
+          test_mode: T::Boolean,
+          request_options: Sentdm::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
-      def self.new(request_options: {})
+      def self.new(
+        # Whether to also delete the template from WhatsApp/Meta (optional, defaults to
+        # false)
+        delete_from_meta: nil,
+        # Test mode flag - when true, the operation is simulated without side effects
+        # Useful for testing integrations without actual execution
+        test_mode: nil,
+        request_options: {}
+      )
       end
 
-      sig { override.returns({ request_options: Sentdm::RequestOptions }) }
+      sig do
+        override.returns(
+          {
+            delete_from_meta: T.nilable(T::Boolean),
+            test_mode: T::Boolean,
+            request_options: Sentdm::RequestOptions
+          }
+        )
+      end
       def to_hash
       end
     end

data/rbi/sentdm/models/template_list_params.rbi

@@ -11,23 +11,22 @@ module Sentdm
           T.any(Sentdm::TemplateListParams, Sentdm::Internal::AnyHash)
         end
 
-      # The page number (zero-indexed). Default is 0.
+      # Page number (1-indexed)
       sig { returns(Integer) }
       attr_accessor :page
 
-      # The number of items per page (1-1000). Default is 100.
       sig { returns(Integer) }
       attr_accessor :page_size
 
-      # Optional filter by template category (e.g., MARKETING, UTILITY, AUTHENTICATION)
+      # Optional category filter: MARKETING, UTILITY, AUTHENTICATION
       sig { returns(T.nilable(String)) }
       attr_accessor :category
 
-      # Optional search term to filter templates by name or content
+      # Optional search term for filtering templates
       sig { returns(T.nilable(String)) }
       attr_accessor :search
 
-      # Optional filter by template status (e.g., APPROVED, PENDING, REJECTED, DRAFT)
+      # Optional status filter: APPROVED, PENDING, REJECTED
       sig { returns(T.nilable(String)) }
       attr_accessor :status
 
@@ -42,15 +41,14 @@ module Sentdm
         ).returns(T.attached_class)
       end
       def self.new(
-        # The page number (zero-indexed). Default is 0.
+        # Page number (1-indexed)
         page:,
-        # The number of items per page (1-1000). Default is 100.
         page_size:,
-        # Optional filter by template category (e.g., MARKETING, UTILITY, AUTHENTICATION)
+        # Optional category filter: MARKETING, UTILITY, AUTHENTICATION
         category: nil,
-        # Optional search term to filter templates by name or content
+        # Optional search term for filtering templates
         search: nil,
-        # Optional filter by template status (e.g., APPROVED, PENDING, REJECTED, DRAFT)
+        # Optional status filter: APPROVED, PENDING, REJECTED
         status: nil,
         request_options: {}
       )