RubyGems - algolia - Versions diffs - 3.0.0.alpha.5 → 3.0.0.alpha.6 - Mend

algolia 3.0.0.alpha.5 → 3.0.0.alpha.6

Files changed (418) hide show

data/lib/algolia/models/recommend/get_recommend_task_response.rb CHANGED Viewed

@@ -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/get_recommendations_params.rb CHANGED Viewed

@@ -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/recommend/get_recommendations_response.rb CHANGED Viewed

@@ -87,15 +87,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)
@@ -156,6 +156,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/highlight_result.rb CHANGED Viewed

@@ -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::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/highlight_result_option.rb CHANGED Viewed

@@ -146,15 +146,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)
@@ -215,6 +215,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/ignore_plurals.rb CHANGED Viewed

@@ -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/index_settings_as_search_params.rb CHANGED Viewed

@@ -616,15 +616,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)
@@ -685,6 +685,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/matched_geo_location.rb CHANGED Viewed

@@ -106,15 +106,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)
@@ -175,6 +175,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/mixed_search_filters.rb CHANGED Viewed

@@ -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::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/numeric_filters.rb CHANGED Viewed

@@ -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/optional_filters.rb CHANGED Viewed

@@ -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/params.rb CHANGED Viewed

@@ -113,15 +113,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)
@@ -182,6 +182,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/personalization.rb CHANGED Viewed

@@ -106,15 +106,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)
@@ -175,6 +175,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/promote.rb CHANGED Viewed

@@ -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::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/promote_object_id.rb CHANGED Viewed

@@ -101,15 +101,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)
@@ -170,6 +170,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/promote_object_ids.rb CHANGED Viewed

@@ -103,15 +103,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)
@@ -172,6 +172,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/ranking_info.rb CHANGED Viewed

@@ -221,15 +221,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)
@@ -290,6 +290,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/re_ranking_apply_filter.rb CHANGED Viewed

@@ -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/recommend_hit.rb CHANGED Viewed

@@ -157,19 +157,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
@@ -228,6 +233,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/recommendations_hit.rb CHANGED Viewed

@@ -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::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/recommendations_hits.rb CHANGED Viewed

@@ -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/recommendations_query.rb CHANGED Viewed

@@ -197,15 +197,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)
@@ -266,6 +266,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/recommendations_request.rb CHANGED Viewed

@@ -73,7 +73,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/recommendations_results.rb CHANGED Viewed

@@ -446,15 +446,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)
@@ -515,6 +515,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/recommended_for_you_query.rb CHANGED Viewed

@@ -185,15 +185,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)
@@ -254,6 +254,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/recommended_for_you_query_parameters.rb CHANGED Viewed

@@ -998,15 +998,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)
@@ -1067,6 +1067,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