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

data/lib/algolia/models/ingestion/auth_api_key.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/ingestion/auth_api_key_partial.rb

@@ -86,15 +86,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 +155,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/auth_basic.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/ingestion/auth_basic_partial.rb

@@ -95,15 +95,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)
@@ -164,6 +164,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/auth_google_service_account.rb

@@ -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/auth_google_service_account_partial.rb

@@ -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/ingestion/auth_input.rb

@@ -74,7 +74,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/auth_input_partial.rb

@@ -74,7 +74,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/auth_o_auth.rb

@@ -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/ingestion/auth_o_auth_partial.rb

@@ -107,15 +107,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)
@@ -176,6 +176,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/authentication.rb

@@ -176,15 +176,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)
@@ -245,6 +245,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/authentication_create.rb

@@ -142,15 +142,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)
@@ -211,6 +211,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/authentication_create_response.rb

@@ -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/ingestion/authentication_search.rb

@@ -90,15 +90,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)
@@ -159,6 +159,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/authentication_update.rb

@@ -136,15 +136,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)
@@ -205,6 +205,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/authentication_update_response.rb

@@ -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/ingestion/big_commerce_channel.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/ingestion/big_commerce_metafield.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/ingestion/delete_response.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/ingestion/destination.rb

@@ -176,15 +176,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)
@@ -245,6 +245,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/destination_create.rb

@@ -143,15 +143,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)
@@ -212,6 +212,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/destination_create_response.rb

@@ -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