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

data/lib/algolia/models/query-suggestions/query_suggestions_configuration_response.rb

@@ -6,9 +6,6 @@ require 'time'
 module Algolia
   module QuerySuggestions
     class QuerySuggestionsConfigurationResponse
-      # Your Algolia application ID.
-      attr_accessor :app_id
-
       # API key used to read from your source index.
       attr_accessor :source_indices_api_key
 
@@ -38,7 +35,6 @@ module Algolia
       # Attribute mapping from ruby-style variable name to JSON key.
       def self.attribute_map
         {
-          :app_id => :appId,
           :source_indices_api_key => :sourceIndicesAPIKey,
           :suggestions_indices_api_key => :suggestionsIndicesAPIKey,
           :external_indices_api_key => :externalIndicesAPIKey,
@@ -59,7 +55,6 @@ module Algolia
       # Attribute type mapping.
       def self.types_mapping
         {
-          :app_id => :String,
           :source_indices_api_key => :String,
           :suggestions_indices_api_key => :String,
           :external_indices_api_key => :String,
@@ -104,10 +99,6 @@ module Algolia
           h[k.to_sym] = v
         end
 
-        if attributes.key?(:app_id)
-          self.app_id = attributes[:app_id]
-        end
-
         if attributes.key?(:source_indices_api_key)
           self.source_indices_api_key = attributes[:source_indices_api_key]
         end
@@ -173,7 +164,6 @@ module Algolia
         return true if equal?(other)
 
         self.class == other.class &&
-          app_id == other.app_id &&
           source_indices_api_key == other.source_indices_api_key &&
           suggestions_indices_api_key == other.suggestions_indices_api_key &&
           external_indices_api_key == other.external_indices_api_key &&
@@ -194,7 +184,7 @@ module Algolia
       # Calculates hash code according to all attributes.
       # @return [Integer] Hash code
       def hash
-        [app_id, source_indices_api_key, suggestions_indices_api_key, external_indices_api_key, index_name, source_indices, languages, exclude, enable_personalization,
+        [source_indices_api_key, suggestions_indices_api_key, external_indices_api_key, index_name, source_indices, languages, exclude, enable_personalization,
          allow_special_characters].hash
       end
 
@@ -208,15 +198,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)
@@ -277,6 +267,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/query-suggestions/query_suggestions_configuration_with_index.rb

@@ -168,15 +168,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)
@@ -237,6 +237,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/query-suggestions/source_index.rb

@@ -198,15 +198,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)
@@ -267,6 +267,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/recommend/around_precision.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::Recommend.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/recommend/around_precision_from_value_inner.rb

@@ -94,15 +94,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)
@@ -163,6 +163,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/recommend/around_radius.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::Recommend.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/recommend/automatic_facet_filter.rb

@@ -109,15 +109,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)
@@ -178,6 +178,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/recommend/automatic_facet_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::Recommend.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/recommend/base_recommend_request.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/recommend/base_recommendations_query.rb

@@ -139,15 +139,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)
@@ -208,6 +208,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/recommend/base_recommended_for_you_query.rb

@@ -127,15 +127,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)
@@ -196,6 +196,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/recommend/base_recommended_for_you_query_parameters.rb

@@ -88,15 +88,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)
@@ -157,6 +157,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/recommend/base_search_params.rb

@@ -457,15 +457,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)
@@ -526,6 +526,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/recommend/base_search_params_without_query.rb

@@ -439,15 +439,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)
@@ -508,6 +508,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/recommend/base_search_response.rb

@@ -403,19 +403,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
 
@@ -474,6 +479,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/recommend/base_trending_facets_query.rb

@@ -119,15 +119,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)
@@ -188,6 +188,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/recommend/base_trending_items_query.rb

@@ -145,15 +145,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)
@@ -214,6 +214,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/recommend/condition.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/recommend/consequence.rb

@@ -132,15 +132,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)
@@ -201,6 +201,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/recommend/consequence_hide.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/recommend/consequence_params.rb

@@ -1014,15 +1014,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)
@@ -1083,6 +1083,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/recommend/consequence_query.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::Recommend.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)