algolia 3.0.0.alpha.5 → 3.0.0.alpha.7

data/lib/algolia/models/search/search_response.rb

@@ -446,19 +446,24 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
 
-        transformed_hash.merge!(attributes.reject { |k, _| attribute_map.key?(k.to_sym) })
+        # merge additional_properties into transformed_hash
+        unless @additional_properties.nil?
+          @additional_properties.each_pair do |k, v|
+            transformed_hash[k.to_sym] = v
+          end
+        end
         new(transformed_hash)
       end
 
@@ -517,6 +522,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/search_responses.rb

@@ -89,15 +89,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -158,6 +158,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/search_result.rb

@@ -71,7 +71,7 @@ module Algolia
               return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
             end
           else # model
-            const = Algolia.const_get(klass)
+            const = Algolia::Search.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/search/search_rules_params.rb

@@ -204,15 +204,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -273,6 +273,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/search_rules_response.rb

@@ -126,15 +126,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -195,6 +195,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/search_synonyms_params.rb

@@ -9,10 +9,43 @@ module Algolia
       # Text to search for in an index.
       attr_accessor :query
 
+      attr_accessor :type
+
+      # Page to retrieve (the first page is `0`, not `1`).
+      attr_accessor :page
+
+      # Number of hits per page.
+      attr_accessor :hits_per_page
+
+      class EnumAttributeValidator
+        attr_reader :datatype
+        attr_reader :allowable_values
+
+        def initialize(datatype, allowable_values)
+          @allowable_values = allowable_values.map do |value|
+            case datatype.to_s
+            when /Integer/i
+              value.to_i
+            when /Float/i
+              value.to_f
+            else
+              value
+            end
+          end
+        end
+
+        def valid?(value)
+          !value || allowable_values.include?(value)
+        end
+      end
+
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
-          :query => :query
+          :query => :query,
+          :type => :type,
+          :page => :page,
+          :hits_per_page => :hitsPerPage
         }
       end
 
@@ -24,7 +57,10 @@ module Algolia
       # Attribute type mapping.
       def self.types_mapping
         {
-          :query => :String
+          :query => :String,
+          :type => :SynonymType,
+          :page => :Integer,
+          :hits_per_page => :Integer
         }
       end
 
@@ -53,6 +89,36 @@ module Algolia
         if attributes.key?(:query)
           self.query = attributes[:query]
         end
+
+        if attributes.key?(:type)
+          self.type = attributes[:type]
+        end
+
+        if attributes.key?(:page)
+          self.page = attributes[:page]
+        end
+
+        if attributes.key?(:hits_per_page)
+          self.hits_per_page = attributes[:hits_per_page]
+        end
+      end
+
+      # Custom attribute writer method with validation
+      # @param [Object] hits_per_page Value to be assigned
+      def hits_per_page=(hits_per_page)
+        if hits_per_page.nil?
+          raise ArgumentError, 'hits_per_page cannot be nil'
+        end
+
+        if hits_per_page > 1000
+          raise ArgumentError, 'invalid value for "hits_per_page", must be smaller than or equal to 1000.'
+        end
+
+        if hits_per_page < 1
+          raise ArgumentError, 'invalid value for "hits_per_page", must be greater than or equal to 1.'
+        end
+
+        @hits_per_page = hits_per_page
       end
 
       # Checks equality by comparing each attribute.
@@ -61,7 +127,10 @@ module Algolia
         return true if equal?(other)
 
         self.class == other.class &&
-          query == other.query
+          query == other.query &&
+          type == other.type &&
+          page == other.page &&
+          hits_per_page == other.hits_per_page
       end
 
       # @see the `==` method
@@ -73,7 +142,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [query].hash
+        [query, type, page, hits_per_page].hash
       end
 
       # Builds the object from hash
@@ -86,15 +155,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -155,6 +224,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/search_synonyms_response.rb

@@ -98,19 +98,24 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
 
-        transformed_hash.merge!(attributes.reject { |k, _| attribute_map.key?(k.to_sym) })
+        # merge additional_properties into transformed_hash
+        unless @additional_properties.nil?
+          @additional_properties.each_pair do |k, v|
+            transformed_hash[k.to_sym] = v
+          end
+        end
         new(transformed_hash)
       end
 
@@ -169,6 +174,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/search_user_ids_params.rb

@@ -137,15 +137,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -206,6 +206,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/search_user_ids_response.rb

@@ -157,15 +157,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -226,6 +226,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/semantic_search.rb

@@ -91,15 +91,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -160,6 +160,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/snippet_result.rb

@@ -10,6 +10,7 @@ module Algolia
         # List of class defined in oneOf (OpenAPI v3)
         def openapi_one_of
           [
+            :'Array<SnippetResultOption>',
             :'Hash<String, SnippetResultOption>',
             :SnippetResultOption
           ]
@@ -71,7 +72,7 @@ module Algolia
               return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
             end
           else # model
-            const = Algolia.const_get(klass)
+            const = Algolia::Search.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/search/snippet_result_option.rb

@@ -122,15 +122,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -191,6 +191,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/source.rb

@@ -99,15 +99,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -168,6 +168,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/standard_entries.rb

@@ -117,15 +117,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -186,6 +186,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/synonym_hit.rb

@@ -188,15 +188,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -257,6 +257,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/tag_filters.rb

@@ -72,7 +72,7 @@ module Algolia
               return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
             end
           else # model
-            const = Algolia.const_get(klass)
+            const = Algolia::Search.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/search/time_range.rb

@@ -100,15 +100,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -169,6 +169,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash

data/lib/algolia/models/search/typo_tolerance.rb

@@ -72,7 +72,7 @@ module Algolia
               return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
             end
           else # model
-            const = Algolia.const_get(klass)
+            const = Algolia::Search.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/search/update_api_key_response.rb

@@ -100,15 +100,15 @@ module Algolia
         transformed_hash = {}
         types_mapping.each_pair do |key, type|
           if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = nil
+            transformed_hash[key.to_sym] = 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.to_s] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
+              transformed_hash[key.to_sym] = attributes[attribute_map[key]].map { |v| _deserialize(::Regexp.last_match(1), v) }
             end
           elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_s] = _deserialize(type, attributes[attribute_map[key]])
+            transformed_hash[key.to_sym] = _deserialize(type, attributes[attribute_map[key]])
           end
         end
         new(transformed_hash)
@@ -169,6 +169,10 @@ module Algolia
         to_hash
       end
 
+      def to_json(*_args)
+        to_hash.to_json
+      end
+
       # Returns the object in the form of hash
       # @return [Hash] Returns the object in the form of hash
       def to_hash