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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (418) hide show

data/lib/algolia/models/ingestion/task_update_response.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/ingestion/trigger.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::Ingestion.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/ingestion/trigger_update_input.rb CHANGED Viewed

@@ -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/ingestion/window.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/insights/added_to_cart_object_ids.rb CHANGED Viewed

@@ -327,15 +327,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)
@@ -396,6 +396,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/insights/added_to_cart_object_ids_after_search.rb CHANGED Viewed

@@ -362,15 +362,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)
@@ -431,6 +431,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/insights/clicked_filters.rb CHANGED Viewed

@@ -267,15 +267,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)
@@ -336,6 +336,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/insights/clicked_object_ids.rb CHANGED Viewed

@@ -267,15 +267,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)
@@ -336,6 +336,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/insights/clicked_object_ids_after_search.rb CHANGED Viewed

@@ -334,15 +334,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)
@@ -403,6 +403,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/insights/converted_filters.rb CHANGED Viewed

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

@@ -267,15 +267,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)
@@ -336,6 +336,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/insights/converted_object_ids_after_search.rb CHANGED Viewed

@@ -302,15 +302,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)
@@ -371,6 +371,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/insights/discount.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::Insights.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/insights/error_base.rb CHANGED Viewed

@@ -82,19 +82,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
@@ -153,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/insights/events_items.rb CHANGED Viewed

@@ -81,7 +81,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::Insights.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/insights/events_response.rb CHANGED Viewed

@@ -97,15 +97,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)
@@ -166,6 +166,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/insights/insights_events.rb CHANGED Viewed

@@ -108,15 +108,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)
@@ -177,6 +177,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/insights/object_data.rb CHANGED Viewed

@@ -104,15 +104,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)
@@ -173,6 +173,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/insights/object_data_after_search.rb CHANGED Viewed

@@ -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/insights/price.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::Insights.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/insights/purchased_object_ids.rb CHANGED Viewed

@@ -327,15 +327,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)
@@ -396,6 +396,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/insights/purchased_object_ids_after_search.rb CHANGED Viewed

@@ -327,15 +327,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)
@@ -396,6 +396,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/insights/value.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::Insights.const_get(klass)
             if const
               if const.respond_to?(:openapi_one_of) # nested oneOf model
                 model = const.build(data)

data/lib/algolia/models/insights/viewed_filters.rb CHANGED Viewed

@@ -267,15 +267,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)
@@ -336,6 +336,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