messente_api 2.4.1 → 2.5.0

data/docs/RcsWebviewViewMode.md

@@ -0,0 +1,15 @@
+# MessenteApi::RcsWebviewViewMode
+
+## Properties
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+
+## Example
+
+```ruby
+require 'messente_api'
+
+instance = MessenteApi::RcsWebviewViewMode.new()
+```
+

data/docs/StatisticsReportSettings.md

@@ -6,7 +6,7 @@
 | ---- | ---- | ----------- | ----- |
 | **start_date** | **Date** | Start date for the report |  |
 | **end_date** | **Date** | End date for the report |  |
-| **message_types** | **Array<String>** | Optional list of message types (sms, viber, whatsapp, hlr, telegram) | [optional] |
+| **message_types** | **Array<String>** | Optional list of message types (sms, viber, whatsapp, rcs, hlr) | [optional] |
 
 ## Example
 

data/lib/messente_api/models/channel.rb

@@ -18,10 +18,10 @@ module MessenteApi
     SMS = "sms".freeze
     VIBER = "viber".freeze
     WHATSAPP = "whatsapp".freeze
-    TELEGRAM = "telegram".freeze
+    RCS = "rcs".freeze
 
     def self.all_vars
-      @all_vars ||= [SMS, VIBER, WHATSAPP, TELEGRAM].freeze
+      @all_vars ||= [SMS, VIBER, WHATSAPP, RCS].freeze
     end
 
     # Builds the enum from string

data/lib/messente_api/models/omnimessage_messages_inner.rb

@@ -16,28 +16,27 @@ require 'time'
 module MessenteApi
   module OmnimessageMessagesInner
     class << self
-      # List of class defined in oneOf (OpenAPI v3)
-      def openapi_one_of
+      # List of class defined in anyOf (OpenAPI v3)
+      def openapi_any_of
         [
+          :'Rcs',
           :'SMS',
-          :'Telegram',
           :'Viber',
           :'WhatsApp'
         ]
       end
 
       # Builds the object
-      # @param [Mixed] Data to be matched against the list of oneOf items
+      # @param [Mixed] Data to be matched against the list of anyOf items
       # @return [Object] Returns the model or the data itself
       def build(data)
-        # Go through the list of oneOf items and attempt to identify the appropriate one.
+        # Go through the list of anyOf items and attempt to identify the appropriate one.
         # Note:
-        # - We do not attempt to check whether exactly one item matches.
         # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
         #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
         # - TODO: scalar values are de facto behaving as if they were nullable.
         # - TODO: logging when debugging is set.
-        openapi_one_of.each do |klass|
+        openapi_any_of.each do |klass|
           begin
             next if klass == :AnyType # "nullable: true"
             typed_data = find_and_cast_into_type(klass, data)
@@ -46,7 +45,7 @@ module MessenteApi
           end
         end
 
-        openapi_one_of.include?(:AnyType) ? data : nil
+        openapi_any_of.include?(:AnyType) ? data : nil
       end
 
       private
@@ -85,7 +84,7 @@ module MessenteApi
         else # model
           const = MessenteApi.const_get(klass)
           if const
-            if const.respond_to?(:openapi_one_of) # nested oneOf model
+            if const.respond_to?(:openapi_any_of) # nested anyOf model
               model = const.build(data)
               return model if model
             else

data/lib/messente_api/models/{telegram.rb → rcs.rb}

@@ -14,28 +14,29 @@ require 'date'
 require 'time'
 
 module MessenteApi
-  # Telegram message content
-  class Telegram
+  # RCS message object. Exactly one of 'text', 'content_info' or 'rich_card' must be provided.
+  class Rcs
+    # The channel used to deliver the message
+    attr_accessor :channel
+
     # Phone number or alphanumeric sender name
     attr_accessor :sender
 
-    # After how many minutes this channel is considered as failed and the next channel is attempted
+    # After how many minutes this channel is considered as failed and the next channel is attempted.Only one of \"ttl\" and \"validity\" can be used.
     attr_accessor :validity
 
-    # Plaintext content for Telegram
-    attr_accessor :text
+    # After how many seconds this channel is considered as failed and the next channel is attempted. Only one of \"ttl\" and \"validity\" can be used.
+    attr_accessor :ttl
 
-    # URL for the embedded image. Mutually exclusive with \"document_url\" and \"audio_url\"
-    attr_accessor :image_url
+    # Text content of the RCS message
+    attr_accessor :text
 
-    # URL for the embedded image. Mutually exclusive with \"audio_url\" and \"image_url\"
-    attr_accessor :document_url
+    # List of suggestions to include with the message
+    attr_accessor :suggestions
 
-    # URL for the embedded image. Mutually exclusive with \"document_url\" and \"image_url\"
-    attr_accessor :audio_url
+    attr_accessor :rich_card
 
-    # The channel used to deliver the message
-    attr_accessor :channel
+    attr_accessor :content_info
 
     class EnumAttributeValidator
       attr_reader :datatype
@@ -62,13 +63,14 @@ module MessenteApi
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
+        :'channel' => :'channel',
         :'sender' => :'sender',
         :'validity' => :'validity',
+        :'ttl' => :'ttl',
         :'text' => :'text',
-        :'image_url' => :'image_url',
-        :'document_url' => :'document_url',
-        :'audio_url' => :'audio_url',
-        :'channel' => :'channel'
+        :'suggestions' => :'suggestions',
+        :'rich_card' => :'rich_card',
+        :'content_info' => :'content_info'
       }
     end
 
@@ -80,13 +82,14 @@ module MessenteApi
     # Attribute type mapping.
     def self.openapi_types
       {
+        :'channel' => :'String',
         :'sender' => :'String',
         :'validity' => :'Integer',
+        :'ttl' => :'Integer',
         :'text' => :'String',
-        :'image_url' => :'String',
-        :'document_url' => :'String',
-        :'audio_url' => :'String',
-        :'channel' => :'String'
+        :'suggestions' => :'Array<RcsSuggestion>',
+        :'rich_card' => :'RcsRichCard',
+        :'content_info' => :'RcsContentInfo'
       }
     end
 
@@ -100,45 +103,53 @@ module MessenteApi
     # @param [Hash] attributes Model attributes in the form of hash
     def initialize(attributes = {})
       if (!attributes.is_a?(Hash))
-        fail ArgumentError, "The input argument (attributes) must be a hash in `MessenteApi::Telegram` initialize method"
+        fail ArgumentError, "The input argument (attributes) must be a hash in `MessenteApi::Rcs` initialize method"
       end
 
       # check to see if the attribute exists and convert string to symbol for hash key
       attributes = attributes.each_with_object({}) { |(k, v), h|
         if (!self.class.attribute_map.key?(k.to_sym))
-          fail ArgumentError, "`#{k}` is not a valid attribute in `MessenteApi::Telegram`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+          fail ArgumentError, "`#{k}` is not a valid attribute in `MessenteApi::Rcs`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
         end
         h[k.to_sym] = v
       }
 
+      if attributes.key?(:'channel')
+        self.channel = attributes[:'channel']
+      else
+        self.channel = 'rcs'
+      end
+
       if attributes.key?(:'sender')
         self.sender = attributes[:'sender']
+      else
+        self.sender = nil
       end
 
       if attributes.key?(:'validity')
         self.validity = attributes[:'validity']
       end
 
+      if attributes.key?(:'ttl')
+        self.ttl = attributes[:'ttl']
+      end
+
       if attributes.key?(:'text')
         self.text = attributes[:'text']
       end
 
-      if attributes.key?(:'image_url')
-        self.image_url = attributes[:'image_url']
+      if attributes.key?(:'suggestions')
+        if (value = attributes[:'suggestions']).is_a?(Array)
+          self.suggestions = value
+        end
       end
 
-      if attributes.key?(:'document_url')
-        self.document_url = attributes[:'document_url']
+      if attributes.key?(:'rich_card')
+        self.rich_card = attributes[:'rich_card']
       end
 
-      if attributes.key?(:'audio_url')
-        self.audio_url = attributes[:'audio_url']
-      end
-
-      if attributes.key?(:'channel')
-        self.channel = attributes[:'channel']
-      else
-        self.channel = 'telegram'
+      if attributes.key?(:'content_info')
+        self.content_info = attributes[:'content_info']
       end
     end
 
@@ -147,6 +158,18 @@ module MessenteApi
     def list_invalid_properties
       warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
       invalid_properties = Array.new
+      if @sender.nil?
+        invalid_properties.push('invalid value for "sender", sender cannot be nil.')
+      end
+
+      if !@text.nil? && @text.to_s.length > 3072
+        invalid_properties.push('invalid value for "text", the character length must be smaller than or equal to 3072.')
+      end
+
+      if !@suggestions.nil? && @suggestions.length > 11
+        invalid_properties.push('invalid value for "suggestions", number of items must be less than or equal to 11.')
+      end
+
       invalid_properties
     end
 
@@ -154,33 +177,65 @@ module MessenteApi
     # @return true if the model is valid
     def valid?
       warn '[DEPRECATED] the `valid?` method is obsolete'
-      channel_validator = EnumAttributeValidator.new('String', ["telegram"])
+      channel_validator = EnumAttributeValidator.new('String', ["rcs"])
       return false unless channel_validator.valid?(@channel)
+      return false if @sender.nil?
+      return false if !@text.nil? && @text.to_s.length > 3072
+      return false if !@suggestions.nil? && @suggestions.length > 11
       true
     end
 
     # Custom attribute writer method checking allowed values (enum).
     # @param [Object] channel Object to be assigned
     def channel=(channel)
-      validator = EnumAttributeValidator.new('String', ["telegram"])
+      validator = EnumAttributeValidator.new('String', ["rcs"])
       unless validator.valid?(channel)
         fail ArgumentError, "invalid value for \"channel\", must be one of #{validator.allowable_values}."
       end
       @channel = channel
     end
 
+    # Custom attribute writer method with validation
+    # @param [Object] text Value to be assigned
+    def text=(text)
+      if text.nil?
+        fail ArgumentError, 'text cannot be nil'
+      end
+
+      if text.to_s.length > 3072
+        fail ArgumentError, 'invalid value for "text", the character length must be smaller than or equal to 3072.'
+      end
+
+      @text = text
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] suggestions Value to be assigned
+    def suggestions=(suggestions)
+      if suggestions.nil?
+        fail ArgumentError, 'suggestions cannot be nil'
+      end
+
+      if suggestions.length > 11
+        fail ArgumentError, 'invalid value for "suggestions", number of items must be less than or equal to 11.'
+      end
+
+      @suggestions = suggestions
+    end
+
     # Checks equality by comparing each attribute.
     # @param [Object] Object to be compared
     def ==(o)
       return true if self.equal?(o)
       self.class == o.class &&
+          channel == o.channel &&
           sender == o.sender &&
           validity == o.validity &&
+          ttl == o.ttl &&
           text == o.text &&
-          image_url == o.image_url &&
-          document_url == o.document_url &&
-          audio_url == o.audio_url &&
-          channel == o.channel
+          suggestions == o.suggestions &&
+          rich_card == o.rich_card &&
+          content_info == o.content_info
     end
 
     # @see the `==` method
@@ -192,7 +247,7 @@ module MessenteApi
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [sender, validity, text, image_url, document_url, audio_url, channel].hash
+      [channel, sender, validity, ttl, text, suggestions, rich_card, content_info].hash
     end
 
     # Builds the object from hash

data/lib/messente_api/models/rcs_card_content.rb

@@ -0,0 +1,298 @@
+=begin
+#Messente API
+
+#[Messente](https://messente.com) is a global provider of messaging and user verification services.  * Send and receive SMS, Viber and WhatsApp messages. * Manage contacts and groups. * Fetch detailed info about phone numbers. * Blacklist phone numbers to make sure you're not sending any unwanted messages.  Messente builds [tools](https://messente.com/documentation) to help organizations connect their services to people anywhere in the world.
+
+The version of the OpenAPI document: 2.0.0
+Contact: messente@messente.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.11.0
+
+=end
+
+require 'date'
+require 'time'
+
+module MessenteApi
+  # RCS Card Content
+  class RcsCardContent
+    # Title of the card content
+    attr_accessor :title
+
+    # Description of the card content
+    attr_accessor :description
+
+    attr_accessor :media
+
+    # List of suggestions that the recipient can use to respond.
+    attr_accessor :suggestions
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'title' => :'title',
+        :'description' => :'description',
+        :'media' => :'media',
+        :'suggestions' => :'suggestions'
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'title' => :'String',
+        :'description' => :'String',
+        :'media' => :'RcsMedia',
+        :'suggestions' => :'Array<RcsSuggestion>'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'title',
+        :'description',
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `MessenteApi::RcsCardContent` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!self.class.attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `MessenteApi::RcsCardContent`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'title')
+        self.title = attributes[:'title']
+      end
+
+      if attributes.key?(:'description')
+        self.description = attributes[:'description']
+      end
+
+      if attributes.key?(:'media')
+        self.media = attributes[:'media']
+      end
+
+      if attributes.key?(:'suggestions')
+        if (value = attributes[:'suggestions']).is_a?(Array)
+          self.suggestions = value
+        end
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if !@title.nil? && @title.to_s.length > 200
+        invalid_properties.push('invalid value for "title", the character length must be smaller than or equal to 200.')
+      end
+
+      if !@description.nil? && @description.to_s.length > 2000
+        invalid_properties.push('invalid value for "description", the character length must be smaller than or equal to 2000.')
+      end
+
+      if !@suggestions.nil? && @suggestions.length > 4
+        invalid_properties.push('invalid value for "suggestions", number of items must be less than or equal to 4.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if !@title.nil? && @title.to_s.length > 200
+      return false if !@description.nil? && @description.to_s.length > 2000
+      return false if !@suggestions.nil? && @suggestions.length > 4
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] title Value to be assigned
+    def title=(title)
+      if !title.nil? && title.to_s.length > 200
+        fail ArgumentError, 'invalid value for "title", the character length must be smaller than or equal to 200.'
+      end
+
+      @title = title
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] description Value to be assigned
+    def description=(description)
+      if !description.nil? && description.to_s.length > 2000
+        fail ArgumentError, 'invalid value for "description", the character length must be smaller than or equal to 2000.'
+      end
+
+      @description = description
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] suggestions Value to be assigned
+    def suggestions=(suggestions)
+      if suggestions.nil?
+        fail ArgumentError, 'suggestions cannot be nil'
+      end
+
+      if suggestions.length > 4
+        fail ArgumentError, 'invalid value for "suggestions", number of items must be less than or equal to 4.'
+      end
+
+      @suggestions = suggestions
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          title == o.title &&
+          description == o.description &&
+          media == o.media &&
+          suggestions == o.suggestions
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [title, description, media, suggestions].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = MessenteApi.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/lib/messente_api/models/rcs_card_orientation.rb

@@ -0,0 +1,40 @@
+=begin
+#Messente API
+
+#[Messente](https://messente.com) is a global provider of messaging and user verification services.  * Send and receive SMS, Viber and WhatsApp messages. * Manage contacts and groups. * Fetch detailed info about phone numbers. * Blacklist phone numbers to make sure you're not sending any unwanted messages.  Messente builds [tools](https://messente.com/documentation) to help organizations connect their services to people anywhere in the world.
+
+The version of the OpenAPI document: 2.0.0
+Contact: messente@messente.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.11.0
+
+=end
+
+require 'date'
+require 'time'
+
+module MessenteApi
+  class RcsCardOrientation
+    VERTICAL = "VERTICAL".freeze
+    HORIZONTAL = "HORIZONTAL".freeze
+
+    def self.all_vars
+      @all_vars ||= [VERTICAL, HORIZONTAL].freeze
+    end
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def self.build_from_hash(value)
+      new.build_from_hash(value)
+    end
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def build_from_hash(value)
+      return value if RcsCardOrientation.all_vars.include?(value)
+      raise "Invalid ENUM value #{value} for class #RcsCardOrientation"
+    end
+  end
+end