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

data/lib/algolia/api/search_client.rb

@@ -14,7 +14,6 @@ module Algolia
 
     def self.create(app_id, api_key, opts = {})
       hosts = []
-
       hosts << Transport::StatefulHost.new("#{app_id}-dsn.algolia.net", accept: CallType::READ)
       hosts << Transport::StatefulHost.new("#{app_id}.algolia.net", accept: CallType::WRITE)
 
@@ -30,8 +29,10 @@ module Algolia
       new(config)
     end
 
-    # Add API key.
     # Add a new API key with specific permissions and restrictions. The request must be authenticated with the admin API key. The response returns an API key string.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param api_key [ApiKey]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -60,18 +61,22 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Add API key.
     # Add a new API key with specific permissions and restrictions. The request must be authenticated with the admin API key. The response returns an API key string.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param api_key [ApiKey]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [AddApiKeyResponse]
     def add_api_key(api_key, request_options = {})
       response = add_api_key_with_http_info(api_key, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::AddApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::AddApiKeyResponse')
     end
 
-    # Add or update a record (using objectID).
     # If you use an existing &#x60;objectID&#x60;, the existing record will be replaced with the new one.  To update only some attributes of an existing record, use the [&#x60;partial&#x60; operation](#tag/Records/operation/partialUpdateObject) instead.  To add multiple records to your index in a single API request, use the [&#x60;batch&#x60; operation](#tag/Records/operation/batch).
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique record (object) identifier. (required)
     # @param body [Object] Algolia record. (required)
@@ -91,8 +96,8 @@ module Algolia
         raise ArgumentError, "Parameter `body` is required when calling `add_or_update_object`."
       end
 
-      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                           @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                         Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -111,8 +116,10 @@ module Algolia
       @api_client.call_api(:PUT, path, new_options)
     end
 
-    # Add or update a record (using objectID).
     # If you use an existing `objectID`, the existing record will be replaced with the new one.  To update only some attributes of an existing record, use the [`partial` operation](#tag/Records/operation/partialUpdateObject) instead.  To add multiple records to your index in a single API request, use the [`batch` operation](#tag/Records/operation/batch).
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique record (object) identifier. (required)
     # @param body [Object] Algolia record. (required)
@@ -120,11 +127,13 @@ module Algolia
     # @return [UpdatedAtWithObjectIdResponse]
     def add_or_update_object(index_name, object_id, body, request_options = {})
       response = add_or_update_object_with_http_info(index_name, object_id, body, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtWithObjectIdResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtWithObjectIdResponse')
     end
 
-    # Add a source.
     # Add a source to the list of allowed sources.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param source [Source] Source to add. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -153,18 +162,22 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Add a source.
     # Add a source to the list of allowed sources.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param source [Source] Source to add. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [CreatedAtResponse]
     def append_source(source, request_options = {})
       response = append_source_with_http_info(source, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
     end
 
-    # Assign or move a user ID.
     # Assign or move a user ID to a cluster. The time it takes to move a user is proportional to the amount of data linked to the user ID.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param x_algolia_user_id [String] userID to assign. (required)
     # @param assign_user_id_params [AssignUserIdParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -205,19 +218,21 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Assign or move a user ID.
     # Assign or move a user ID to a cluster. The time it takes to move a user is proportional to the amount of data linked to the user ID.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param x_algolia_user_id [String] userID to assign. (required)
     # @param assign_user_id_params [AssignUserIdParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [CreatedAtResponse]
     def assign_user_id(x_algolia_user_id, assign_user_id_params, request_options = {})
       response = assign_user_id_with_http_info(x_algolia_user_id, assign_user_id_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
     end
 
-    # Batch write operations on one index.
     # To reduce the time spent on network round trips, you can perform several write actions in a single API call. Actions are applied in the order they are specified. The supported &#x60;action&#x60;s are equivalent to the individual operations of the same name.
+
     # @param index_name [String] Index on which to perform the request. (required)
     # @param batch_write_params [BatchWriteParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -232,7 +247,7 @@ module Algolia
         raise ArgumentError, "Parameter `batch_write_params` is required when calling `batch`."
       end
 
-      path = '/1/indexes/{indexName}/batch'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/batch'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -251,19 +266,21 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Batch write operations on one index.
     # To reduce the time spent on network round trips, you can perform several write actions in a single API call. Actions are applied in the order they are specified. The supported `action`s are equivalent to the individual operations of the same name.
+
     # @param index_name [String] Index on which to perform the request. (required)
     # @param batch_write_params [BatchWriteParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [BatchResponse]
     def batch(index_name, batch_write_params, request_options = {})
       response = batch_with_http_info(index_name, batch_write_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::BatchResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::BatchResponse')
     end
 
-    # Batch assign userIDs.
     # Assign multiple user IDs to a cluster. **You can&#39;t _move_ users with this operation.**.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param x_algolia_user_id [String] userID to assign. (required)
     # @param batch_assign_user_ids_params [BatchAssignUserIdsParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -304,19 +321,23 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Batch assign userIDs.
     # Assign multiple user IDs to a cluster. **You can't _move_ users with this operation.**.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param x_algolia_user_id [String] userID to assign. (required)
     # @param batch_assign_user_ids_params [BatchAssignUserIdsParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [CreatedAtResponse]
     def batch_assign_user_ids(x_algolia_user_id, batch_assign_user_ids_params, request_options = {})
       response = batch_assign_user_ids_with_http_info(x_algolia_user_id, batch_assign_user_ids_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
     end
 
-    # Batch dictionary entries.
     # Add or remove a batch of dictionary entries.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param dictionary_name [DictionaryType] Dictionary to search in. (required)
     # @param batch_dictionary_entries_params [BatchDictionaryEntriesParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -331,7 +352,7 @@ module Algolia
         raise ArgumentError, "Parameter `batch_dictionary_entries_params` is required when calling `batch_dictionary_entries`."
       end
 
-      path = '/1/dictionaries/{dictionaryName}/batch'.sub('{' + 'dictionaryName' + '}', @api_client.encode_uri(dictionary_name.to_s))
+      path = '/1/dictionaries/{dictionaryName}/batch'.sub('{' + 'dictionaryName' + '}', Transport.encode_uri(dictionary_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -350,19 +371,23 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Batch dictionary entries.
     # Add or remove a batch of dictionary entries.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param dictionary_name [DictionaryType] Dictionary to search in. (required)
     # @param batch_dictionary_entries_params [BatchDictionaryEntriesParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UpdatedAtResponse]
     def batch_dictionary_entries(dictionary_name, batch_dictionary_entries_params, request_options = {})
       response = batch_dictionary_entries_with_http_info(dictionary_name, batch_dictionary_entries_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Get all records from an index.
     # Retrieve up to 1,000 records per call. Supports full-text search and filters. For better performance, it doesn&#39;t support: - The &#x60;distinct&#x60; query parameter - Sorting by typos, proximity, words, or geographical distance.
+    #
+    # Required API Key ACLs:
+    #   - browse
     # @param index_name [String] Index on which to perform the request. (required)
     # @param browse_params [BrowseParams]
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -373,7 +398,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `browse`."
       end
 
-      path = '/1/indexes/{indexName}/browse'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/browse'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -392,32 +417,34 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Get all records from an index.
     # Retrieve up to 1,000 records per call. Supports full-text search and filters. For better performance, it doesn't support: - The `distinct` query parameter - Sorting by typos, proximity, words, or geographical distance.
+    #
+    # Required API Key ACLs:
+    #   - browse
     # @param index_name [String] Index on which to perform the request. (required)
     # @param browse_params [BrowseParams]
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [BrowseResponse]
     def browse(index_name, browse_params = nil, request_options = {})
       response = browse_with_http_info(index_name, browse_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::BrowseResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::BrowseResponse')
     end
 
-    # Delete all synonyms.
-    # Delete all synonyms in the index.
+    # Delete the records but leave settings and index-specific API keys untouched.
+    #
+    # Required API Key ACLs:
+    #   - deleteIndex
     # @param index_name [String] Index on which to perform the request. (required)
-    # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
-    def clear_all_synonyms_with_http_info(index_name, forward_to_replicas = nil, request_options = {})
+    def clear_objects_with_http_info(index_name, request_options = {})
       # verify the required parameter 'index_name' is set
       if @api_client.config.client_side_validation && index_name.nil?
-        raise ArgumentError, "Parameter `index_name` is required when calling `clear_all_synonyms`."
+        raise ArgumentError, "Parameter `index_name` is required when calling `clear_objects`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/clear'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/clear'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
-      query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
       header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
@@ -425,7 +452,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.clear_all_synonyms',
+        :operation => :'SearchClient.clear_objects',
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -435,30 +462,35 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Delete all synonyms.
-    # Delete all synonyms in the index.
+    # Delete the records but leave settings and index-specific API keys untouched.
+    #
+    # Required API Key ACLs:
+    #   - deleteIndex
     # @param index_name [String] Index on which to perform the request. (required)
-    # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UpdatedAtResponse]
-    def clear_all_synonyms(index_name, forward_to_replicas = nil, request_options = {})
-      response = clear_all_synonyms_with_http_info(index_name, forward_to_replicas, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+    def clear_objects(index_name, request_options = {})
+      response = clear_objects_with_http_info(index_name, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Delete all records from an index.
-    # Delete the records but leave settings and index-specific API keys untouched.
+    # Delete all rules in the index.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
+    # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
-    def clear_objects_with_http_info(index_name, request_options = {})
+    def clear_rules_with_http_info(index_name, forward_to_replicas = nil, request_options = {})
       # verify the required parameter 'index_name' is set
       if @api_client.config.client_side_validation && index_name.nil?
-        raise ArgumentError, "Parameter `index_name` is required when calling `clear_objects`."
+        raise ArgumentError, "Parameter `index_name` is required when calling `clear_rules`."
       end
 
-      path = '/1/indexes/{indexName}/clear'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/rules/clear'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
+      query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
       header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
@@ -466,7 +498,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.clear_objects',
+        :operation => :'SearchClient.clear_rules',
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -476,29 +508,34 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Delete all records from an index.
-    # Delete the records but leave settings and index-specific API keys untouched.
+    # Delete all rules in the index.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
+    # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UpdatedAtResponse]
-    def clear_objects(index_name, request_options = {})
-      response = clear_objects_with_http_info(index_name, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+    def clear_rules(index_name, forward_to_replicas = nil, request_options = {})
+      response = clear_rules_with_http_info(index_name, forward_to_replicas, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Delete all rules.
-    # Delete all rules in the index.
+    # Delete all synonyms in the index.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
-    def clear_rules_with_http_info(index_name, forward_to_replicas = nil, request_options = {})
+    def clear_synonyms_with_http_info(index_name, forward_to_replicas = nil, request_options = {})
       # verify the required parameter 'index_name' is set
       if @api_client.config.client_side_validation && index_name.nil?
-        raise ArgumentError, "Parameter `index_name` is required when calling `clear_rules`."
+        raise ArgumentError, "Parameter `index_name` is required when calling `clear_synonyms`."
       end
 
-      path = '/1/indexes/{indexName}/rules/clear'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/synonyms/clear'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -508,7 +545,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.clear_rules',
+        :operation => :'SearchClient.clear_synonyms',
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -518,19 +555,21 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Delete all rules.
-    # Delete all rules in the index.
+    # Delete all synonyms in the index.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UpdatedAtResponse]
-    def clear_rules(index_name, forward_to_replicas = nil, request_options = {})
-      response = clear_rules_with_http_info(index_name, forward_to_replicas, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+    def clear_synonyms(index_name, forward_to_replicas = nil, request_options = {})
+      response = clear_synonyms_with_http_info(index_name, forward_to_replicas, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Send requests to the Algolia REST API.
     # This method allow you to send requests to the Algolia REST API.
+
     # @param path [String] Path of the endpoint, anything after \&quot;/1\&quot; must be specified. (required)
     # @param parameters [Hash<String, Object>] Query parameters to apply to the current query.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -561,19 +600,19 @@ module Algolia
       @api_client.call_api(:DELETE, path, new_options)
     end
 
-    # Send requests to the Algolia REST API.
     # This method allow you to send requests to the Algolia REST API.
+
     # @param path [String] Path of the endpoint, anything after \&quot;/1\&quot; must be specified. (required)
     # @param parameters [Hash<String, Object>] Query parameters to apply to the current query.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Object]
     def custom_delete(path, parameters = nil, request_options = {})
       response = custom_delete_with_http_info(path, parameters, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
     end
 
-    # Send requests to the Algolia REST API.
     # This method allow you to send requests to the Algolia REST API.
+
     # @param path [String] Path of the endpoint, anything after \&quot;/1\&quot; must be specified. (required)
     # @param parameters [Hash<String, Object>] Query parameters to apply to the current query.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -604,19 +643,19 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Send requests to the Algolia REST API.
     # This method allow you to send requests to the Algolia REST API.
+
     # @param path [String] Path of the endpoint, anything after \&quot;/1\&quot; must be specified. (required)
     # @param parameters [Hash<String, Object>] Query parameters to apply to the current query.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Object]
     def custom_get(path, parameters = nil, request_options = {})
       response = custom_get_with_http_info(path, parameters, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
     end
 
-    # Send requests to the Algolia REST API.
     # This method allow you to send requests to the Algolia REST API.
+
     # @param path [String] Path of the endpoint, anything after \&quot;/1\&quot; must be specified. (required)
     # @param parameters [Hash<String, Object>] Query parameters to apply to the current query.
     # @param body [Object] Parameters to send with the custom request.
@@ -648,8 +687,8 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Send requests to the Algolia REST API.
     # This method allow you to send requests to the Algolia REST API.
+
     # @param path [String] Path of the endpoint, anything after \&quot;/1\&quot; must be specified. (required)
     # @param parameters [Hash<String, Object>] Query parameters to apply to the current query.
     # @param body [Object] Parameters to send with the custom request.
@@ -657,11 +696,11 @@ module Algolia
     # @return [Object]
     def custom_post(path, parameters = nil, body = nil, request_options = {})
       response = custom_post_with_http_info(path, parameters, body, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
     end
 
-    # Send requests to the Algolia REST API.
     # This method allow you to send requests to the Algolia REST API.
+
     # @param path [String] Path of the endpoint, anything after \&quot;/1\&quot; must be specified. (required)
     # @param parameters [Hash<String, Object>] Query parameters to apply to the current query.
     # @param body [Object] Parameters to send with the custom request.
@@ -693,8 +732,8 @@ module Algolia
       @api_client.call_api(:PUT, path, new_options)
     end
 
-    # Send requests to the Algolia REST API.
     # This method allow you to send requests to the Algolia REST API.
+
     # @param path [String] Path of the endpoint, anything after \&quot;/1\&quot; must be specified. (required)
     # @param parameters [Hash<String, Object>] Query parameters to apply to the current query.
     # @param body [Object] Parameters to send with the custom request.
@@ -702,11 +741,13 @@ module Algolia
     # @return [Object]
     def custom_put(path, parameters = nil, body = nil, request_options = {})
       response = custom_put_with_http_info(path, parameters, body, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
     end
 
-    # Delete API key.
     # Delete an existing API key. The request must be authenticated with the admin API key.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param key [String] API key. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -716,7 +757,7 @@ module Algolia
         raise ArgumentError, "Parameter `key` is required when calling `delete_api_key`."
       end
 
-      path = '/1/keys/{key}'.sub('{' + 'key' + '}', @api_client.encode_uri(key.to_s))
+      path = '/1/keys/{key}'.sub('{' + 'key' + '}', Transport.encode_uri(key.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -735,18 +776,22 @@ module Algolia
       @api_client.call_api(:DELETE, path, new_options)
     end
 
-    # Delete API key.
     # Delete an existing API key. The request must be authenticated with the admin API key.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param key [String] API key. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [DeleteApiKeyResponse]
     def delete_api_key(key, request_options = {})
       response = delete_api_key_with_http_info(key, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::DeleteApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeleteApiKeyResponse')
     end
 
-    # Delete all records matching a query.
     # This operation doesn&#39;t support all the query options, only its filters (numeric, facet, or tag) and geo queries. It doesn&#39;t accept empty filters or queries.
+    #
+    # Required API Key ACLs:
+    #   - deleteIndex
     # @param index_name [String] Index on which to perform the request. (required)
     # @param delete_by_params [DeleteByParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -761,7 +806,7 @@ module Algolia
         raise ArgumentError, "Parameter `delete_by_params` is required when calling `delete_by`."
       end
 
-      path = '/1/indexes/{indexName}/deleteByQuery'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/deleteByQuery'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -780,19 +825,23 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Delete all records matching a query.
     # This operation doesn't support all the query options, only its filters (numeric, facet, or tag) and geo queries. It doesn't accept empty filters or queries.
+    #
+    # Required API Key ACLs:
+    #   - deleteIndex
     # @param index_name [String] Index on which to perform the request. (required)
     # @param delete_by_params [DeleteByParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [DeletedAtResponse]
     def delete_by(index_name, delete_by_params, request_options = {})
       response = delete_by_with_http_info(index_name, delete_by_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
     end
 
-    # Delete index.
     # Delete an existing index.
+    #
+    # Required API Key ACLs:
+    #   - deleteIndex
     # @param index_name [String] Index on which to perform the request. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -802,7 +851,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `delete_index`."
       end
 
-      path = '/1/indexes/{indexName}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -821,18 +870,22 @@ module Algolia
       @api_client.call_api(:DELETE, path, new_options)
     end
 
-    # Delete index.
     # Delete an existing index.
+    #
+    # Required API Key ACLs:
+    #   - deleteIndex
     # @param index_name [String] Index on which to perform the request. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [DeletedAtResponse]
     def delete_index(index_name, request_options = {})
       response = delete_index_with_http_info(index_name, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
     end
 
-    # Delete a record.
     # To delete a set of records matching a query, use the [&#x60;deleteByQuery&#x60; operation](#tag/Records/operation/deleteBy) instead.
+    #
+    # Required API Key ACLs:
+    #   - deleteObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique record (object) identifier. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -847,8 +900,8 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `delete_object`."
       end
 
-      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                           @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                         Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -867,19 +920,23 @@ module Algolia
       @api_client.call_api(:DELETE, path, new_options)
     end
 
-    # Delete a record.
     # To delete a set of records matching a query, use the [`deleteByQuery` operation](#tag/Records/operation/deleteBy) instead.
+    #
+    # Required API Key ACLs:
+    #   - deleteObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique record (object) identifier. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [DeletedAtResponse]
     def delete_object(index_name, object_id, request_options = {})
       response = delete_object_with_http_info(index_name, object_id, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
     end
 
-    # Delete a rule.
     # Delete a rule by its &#x60;objectID&#x60;. To find the &#x60;objectID&#x60; for rules, use the [&#x60;search&#x60; operation](#tag/Rules/operation/searchRules).
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a rule object. (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -895,8 +952,8 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `delete_rule`."
       end
 
-      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                 @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                               Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -916,8 +973,10 @@ module Algolia
       @api_client.call_api(:DELETE, path, new_options)
     end
 
-    # Delete a rule.
     # Delete a rule by its `objectID`. To find the `objectID` for rules, use the [`search` operation](#tag/Rules/operation/searchRules).
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a rule object. (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -925,11 +984,13 @@ module Algolia
     # @return [UpdatedAtResponse]
     def delete_rule(index_name, object_id, forward_to_replicas = nil, request_options = {})
       response = delete_rule_with_http_info(index_name, object_id, forward_to_replicas, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Remove a source.
     # Remove a source from the list of allowed sources.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param source [String] IP address range of the source. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -939,7 +1000,7 @@ module Algolia
         raise ArgumentError, "Parameter `source` is required when calling `delete_source`."
       end
 
-      path = '/1/security/sources/{source}'.sub('{' + 'source' + '}', @api_client.encode_uri(source.to_s))
+      path = '/1/security/sources/{source}'.sub('{' + 'source' + '}', Transport.encode_uri(source.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -958,18 +1019,22 @@ module Algolia
       @api_client.call_api(:DELETE, path, new_options)
     end
 
-    # Remove a source.
     # Remove a source from the list of allowed sources.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param source [String] IP address range of the source. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [DeleteSourceResponse]
     def delete_source(source, request_options = {})
       response = delete_source_with_http_info(source, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::DeleteSourceResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeleteSourceResponse')
     end
 
-    # Delete a synonym.
     # Delete a synonym by its &#x60;objectID&#x60;. To find the object IDs of your synonyms, use the [&#x60;search&#x60; operation](#tag/Synonyms/operation/searchSynonyms).
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a synonym object. (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -985,8 +1050,8 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `delete_synonym`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                    @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                                  Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -1006,8 +1071,10 @@ module Algolia
       @api_client.call_api(:DELETE, path, new_options)
     end
 
-    # Delete a synonym.
     # Delete a synonym by its `objectID`. To find the object IDs of your synonyms, use the [`search` operation](#tag/Synonyms/operation/searchSynonyms).
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a synonym object. (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -1015,11 +1082,11 @@ module Algolia
     # @return [DeletedAtResponse]
     def delete_synonym(index_name, object_id, forward_to_replicas = nil, request_options = {})
       response = delete_synonym_with_http_info(index_name, object_id, forward_to_replicas, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
     end
 
-    # Get API key permissions.
     # Get the permissions and restrictions of a specific API key. When authenticating with the admin API key, you can request information for any of your application&#39;s keys. When authenticating with other API keys, you can only retrieve information for that key.
+
     # @param key [String] API key. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1029,7 +1096,7 @@ module Algolia
         raise ArgumentError, "Parameter `key` is required when calling `get_api_key`."
       end
 
-      path = '/1/keys/{key}'.sub('{' + 'key' + '}', @api_client.encode_uri(key.to_s))
+      path = '/1/keys/{key}'.sub('{' + 'key' + '}', Transport.encode_uri(key.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1048,18 +1115,20 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get API key permissions.
     # Get the permissions and restrictions of a specific API key. When authenticating with the admin API key, you can request information for any of your application's keys. When authenticating with other API keys, you can only retrieve information for that key.
+
     # @param key [String] API key. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [GetApiKeyResponse]
     def get_api_key(key, request_options = {})
       response = get_api_key_with_http_info(key, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::GetApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetApiKeyResponse')
     end
 
-    # List available languages.
     # Lists Algolia&#39;s [supported languages](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages/) and any customizations applied to each language&#39;s [stop word](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-stop-words/), [plural](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-plurals-and-other-declensions/), and [segmentation (compound)](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-segmentation/) features.
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
     def get_dictionary_languages_with_http_info(request_options = {})
@@ -1082,17 +1151,21 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # List available languages.
     # Lists Algolia's [supported languages](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages/) and any customizations applied to each language's [stop word](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-stop-words/), [plural](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-plurals-and-other-declensions/), and [segmentation (compound)](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-segmentation/) features.
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Hash<String, Languages>]
     def get_dictionary_languages(request_options = {})
       response = get_dictionary_languages_with_http_info(request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::Hash<String, Languages>')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::Hash<String, Languages>')
     end
 
-    # Get stop word settings.
     # Get the languages for which [stop words are turned off](#tag/Dictionaries/operation/setDictionarySettings).
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
     def get_dictionary_settings_with_http_info(request_options = {})
@@ -1115,17 +1188,21 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get stop word settings.
     # Get the languages for which [stop words are turned off](#tag/Dictionaries/operation/setDictionarySettings).
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [GetDictionarySettingsResponse]
     def get_dictionary_settings(request_options = {})
       response = get_dictionary_settings_with_http_info(request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::GetDictionarySettingsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetDictionarySettingsResponse')
     end
 
-    # Return the latest log entries.
     # The request must be authenticated by an API key with the [&#x60;logs&#x60; ACL](https://www.algolia.com/doc/guides/security/api-keys/#access-control-list-acl). Logs are held for the last seven days. There&#39;s also a logging limit of 1,000 API calls per server. This request counts towards your [operations quota](https://support.algolia.com/hc/en-us/articles/4406981829777-How-does-Algolia-count-records-and-operations-) but doesn&#39;t appear in the logs itself. &gt; **Note**: To fetch the logs for a Distributed Search Network (DSN) cluster, target the [DSN&#39;s endpoint](https://www.algolia.com/doc/guides/scaling/distributed-search-network-dsn/#accessing-dsn-servers).
+    #
+    # Required API Key ACLs:
+    #   - logs
     # @param offset [Integer] First log entry to retrieve. Sorted by decreasing date with 0 being the most recent. (default to 0)
     # @param length [Integer] Maximum number of entries to retrieve. (default to 10)
     # @param index_name [String] Index for which log entries should be retrieved. When omitted, log entries are retrieved for all indices.
@@ -1160,8 +1237,10 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Return the latest log entries.
     # The request must be authenticated by an API key with the [`logs` ACL](https://www.algolia.com/doc/guides/security/api-keys/#access-control-list-acl). Logs are held for the last seven days. There's also a logging limit of 1,000 API calls per server. This request counts towards your [operations quota](https://support.algolia.com/hc/en-us/articles/4406981829777-How-does-Algolia-count-records-and-operations-) but doesn't appear in the logs itself. > **Note**: To fetch the logs for a Distributed Search Network (DSN) cluster, target the [DSN's endpoint](https://www.algolia.com/doc/guides/scaling/distributed-search-network-dsn/#accessing-dsn-servers).
+    #
+    # Required API Key ACLs:
+    #   - logs
     # @param offset [Integer] First log entry to retrieve. Sorted by decreasing date with 0 being the most recent. (default to 0)
     # @param length [Integer] Maximum number of entries to retrieve. (default to 10)
     # @param index_name [String] Index for which log entries should be retrieved. When omitted, log entries are retrieved for all indices.
@@ -1170,11 +1249,13 @@ module Algolia
     # @return [GetLogsResponse]
     def get_logs(offset = nil, length = nil, index_name = nil, type = nil, request_options = {})
       response = get_logs_with_http_info(offset, length, index_name, type, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::GetLogsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetLogsResponse')
     end
 
-    # Get a record.
     # To get more than one record, use the [&#x60;objects&#x60; operation](#tag/Records/operation/getObjects).
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique record (object) identifier. (required)
     # @param attributes_to_retrieve [Array<String>] Attributes to include with the records in the response. This is useful to reduce the size of the API response. By default, all retrievable attributes are returned. &#x60;objectID&#x60; is always retrieved, even when not specified. [&#x60;unretrievableAttributes&#x60;](https://www.algolia.com/doc/api-reference/api-parameters/unretrievableAttributes/) won&#39;t be retrieved unless the request is authenticated with the admin API key.
@@ -1190,8 +1271,8 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `get_object`."
       end
 
-      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                           @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                         Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params[:attributesToRetrieve] = @api_client.build_collection_param(attributes_to_retrieve, :multi) unless attributes_to_retrieve.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -1211,8 +1292,10 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get a record.
     # To get more than one record, use the [`objects` operation](#tag/Records/operation/getObjects).
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique record (object) identifier. (required)
     # @param attributes_to_retrieve [Array<String>] Attributes to include with the records in the response. This is useful to reduce the size of the API response. By default, all retrievable attributes are returned. &#x60;objectID&#x60; is always retrieved, even when not specified. [&#x60;unretrievableAttributes&#x60;](https://www.algolia.com/doc/api-reference/api-parameters/unretrievableAttributes/) won&#39;t be retrieved unless the request is authenticated with the admin API key.
@@ -1220,11 +1303,13 @@ module Algolia
     # @return [Hash<String, String>]
     def get_object(index_name, object_id, attributes_to_retrieve = nil, request_options = {})
       response = get_object_with_http_info(index_name, object_id, attributes_to_retrieve, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::Hash<String, String>')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::Hash<String, String>')
     end
 
-    # Get multiple records.
     # Retrieve one or more records, potentially from different indices, in a single API operation. Results will be received in the same order as the requests.
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param get_objects_params [GetObjectsParams] Request object. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1247,24 +1332,28 @@ module Algolia
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
-        :use_read_transporter => false
+        :use_read_transporter => true
       )
 
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Get multiple records.
     # Retrieve one or more records, potentially from different indices, in a single API operation. Results will be received in the same order as the requests.
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param get_objects_params [GetObjectsParams] Request object. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [GetObjectsResponse]
     def get_objects(get_objects_params, request_options = {})
       response = get_objects_with_http_info(get_objects_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::GetObjectsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetObjectsResponse')
     end
 
-    # Get a rule.
     # Get a rule by its &#x60;objectID&#x60;. To find the &#x60;objectID&#x60; for rules, use the [&#x60;search&#x60; operation](#tag/Rules/operation/searchRules).
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a rule object. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -1279,8 +1368,8 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `get_rule`."
       end
 
-      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                 @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                               Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1299,19 +1388,23 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get a rule.
     # Get a rule by its `objectID`. To find the `objectID` for rules, use the [`search` operation](#tag/Rules/operation/searchRules).
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a rule object. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Rule]
     def get_rule(index_name, object_id, request_options = {})
       response = get_rule_with_http_info(index_name, object_id, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::Rule')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::Rule')
     end
 
-    # Get index settings.
     # Return an object containing an index&#39;s [configuration settings](https://www.algolia.com/doc/api-reference/settings-api-parameters/).
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param index_name [String] Index on which to perform the request. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1321,7 +1414,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `get_settings`."
       end
 
-      path = '/1/indexes/{indexName}/settings'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/settings'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1340,18 +1433,22 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get index settings.
     # Return an object containing an index's [configuration settings](https://www.algolia.com/doc/api-reference/settings-api-parameters/).
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param index_name [String] Index on which to perform the request. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [IndexSettings]
     def get_settings(index_name, request_options = {})
       response = get_settings_with_http_info(index_name, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::IndexSettings')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::IndexSettings')
     end
 
-    # Get all allowed IP addresses.
     # Get all allowed sources (IP addresses).
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
     def get_sources_with_http_info(request_options = {})
@@ -1374,17 +1471,21 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get all allowed IP addresses.
     # Get all allowed sources (IP addresses).
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Array<Source>]
     def get_sources(request_options = {})
       response = get_sources_with_http_info(request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Array<Search::Source>')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Array<Search::Source>')
     end
 
-    # Get a synonym object.
     # Get a syonym by its &#x60;objectID&#x60;. To find the object IDs for your synonyms, use the [&#x60;search&#x60; operation](#tag/Synonyms/operation/searchSynonyms).
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a synonym object. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -1399,8 +1500,8 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `get_synonym`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                    @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                                  Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1419,19 +1520,23 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get a synonym object.
     # Get a syonym by its `objectID`. To find the object IDs for your synonyms, use the [`search` operation](#tag/Synonyms/operation/searchSynonyms).
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a synonym object. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [SynonymHit]
     def get_synonym(index_name, object_id, request_options = {})
       response = get_synonym_with_http_info(index_name, object_id, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SynonymHit')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SynonymHit')
     end
 
-    # Check a task&#39;s status.
     # Some operations, such as copying an index, will respond with a &#x60;taskID&#x60; value. Use this value here to check the status of that task.
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param task_id [Integer] Unique task identifier. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -1446,8 +1551,8 @@ module Algolia
         raise ArgumentError, "Parameter `task_id` is required when calling `get_task`."
       end
 
-      path = '/1/indexes/{indexName}/task/{taskID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'taskID' + '}',
-                                                                                                                              @api_client.encode_uri(task_id.to_s))
+      path = '/1/indexes/{indexName}/task/{taskID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'taskID' + '}',
+                                                                                                                            Transport.encode_uri(task_id.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1466,19 +1571,23 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Check a task's status.
     # Some operations, such as copying an index, will respond with a `taskID` value. Use this value here to check the status of that task.
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param task_id [Integer] Unique task identifier. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [GetTaskResponse]
     def get_task(index_name, task_id, request_options = {})
       response = get_task_with_http_info(index_name, task_id, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::GetTaskResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetTaskResponse')
     end
 
-    # Get top userID.
     # Get the IDs of the 10 users with the highest number of records per cluster. Since it can take up to a few seconds to get the data from the different clusters, the response isn&#39;t real-time.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
     def get_top_user_ids_with_http_info(request_options = {})
@@ -1501,17 +1610,21 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get top userID.
     # Get the IDs of the 10 users with the highest number of records per cluster. Since it can take up to a few seconds to get the data from the different clusters, the response isn't real-time.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [GetTopUserIdsResponse]
     def get_top_user_ids(request_options = {})
       response = get_top_user_ids_with_http_info(request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::GetTopUserIdsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetTopUserIdsResponse')
     end
 
-    # Get userID.
     # Returns the userID data stored in the mapping. Since it can take up to a few seconds to get the data from the different clusters, the response isn&#39;t real-time.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param user_id [String] userID to assign. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1526,7 +1639,7 @@ module Algolia
         raise ArgumentError, "invalid value for 'user_id' when calling SearchClient.get_user_id, must conform to the pattern #{pattern}."
       end
 
-      path = '/1/clusters/mapping/{userID}'.sub('{' + 'userID' + '}', @api_client.encode_uri(user_id.to_s))
+      path = '/1/clusters/mapping/{userID}'.sub('{' + 'userID' + '}', Transport.encode_uri(user_id.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1545,18 +1658,22 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get userID.
     # Returns the userID data stored in the mapping. Since it can take up to a few seconds to get the data from the different clusters, the response isn't real-time.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param user_id [String] userID to assign. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UserId]
     def get_user_id(user_id, request_options = {})
       response = get_user_id_with_http_info(user_id, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UserId')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UserId')
     end
 
-    # Get migration and user mapping status.
     # To determine when the time-consuming process of creating a large batch of users or migrating users from one cluster to another is complete, this operation retrieves the status of the process.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param get_clusters [Boolean] Indicates whether to include the cluster&#39;s pending mapping state in the response.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1581,18 +1698,22 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # Get migration and user mapping status.
     # To determine when the time-consuming process of creating a large batch of users or migrating users from one cluster to another is complete, this operation retrieves the status of the process.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param get_clusters [Boolean] Indicates whether to include the cluster&#39;s pending mapping state in the response.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [HasPendingMappingsResponse]
     def has_pending_mappings(get_clusters = nil, request_options = {})
       response = has_pending_mappings_with_http_info(get_clusters, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::HasPendingMappingsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::HasPendingMappingsResponse')
     end
 
-    # List API keys.
     # List all API keys associated with your Algolia application, including their permissions and restrictions.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
     def list_api_keys_with_http_info(request_options = {})
@@ -1615,17 +1736,21 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # List API keys.
     # List all API keys associated with your Algolia application, including their permissions and restrictions.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [ListApiKeysResponse]
     def list_api_keys(request_options = {})
       response = list_api_keys_with_http_info(request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::ListApiKeysResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ListApiKeysResponse')
     end
 
-    # List clusters.
     # List the available clusters in a multi-cluster setup.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
     def list_clusters_with_http_info(request_options = {})
@@ -1648,17 +1773,21 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # List clusters.
     # List the available clusters in a multi-cluster setup.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [ListClustersResponse]
     def list_clusters(request_options = {})
       response = list_clusters_with_http_info(request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::ListClustersResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ListClustersResponse')
     end
 
-    # List indices.
     # List indices in an Algolia application.
+    #
+    # Required API Key ACLs:
+    #   - listIndexes
     # @param page [Integer] Returns the requested page number. The page size is determined by the &#x60;hitsPerPage&#x60; parameter. You can see the number of available pages in the &#x60;nbPages&#x60; response attribute. When &#x60;page&#x60; is null, the API response is not paginated.
     # @param hits_per_page [Integer] Maximum number of hits per page. (default to 100)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -1689,19 +1818,23 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # List indices.
     # List indices in an Algolia application.
+    #
+    # Required API Key ACLs:
+    #   - listIndexes
     # @param page [Integer] Returns the requested page number. The page size is determined by the &#x60;hitsPerPage&#x60; parameter. You can see the number of available pages in the &#x60;nbPages&#x60; response attribute. When &#x60;page&#x60; is null, the API response is not paginated.
     # @param hits_per_page [Integer] Maximum number of hits per page. (default to 100)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [ListIndicesResponse]
     def list_indices(page = nil, hits_per_page = nil, request_options = {})
       response = list_indices_with_http_info(page, hits_per_page, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::ListIndicesResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ListIndicesResponse')
     end
 
-    # List userIDs.
     # List the userIDs assigned to a multi-cluster application. Since it can take up to a few seconds to get the data from the different clusters, the response isn&#39;t real-time.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param page [Integer] Returns the requested page number. The page size is determined by the &#x60;hitsPerPage&#x60; parameter. You can see the number of available pages in the &#x60;nbPages&#x60; response attribute. When &#x60;page&#x60; is null, the API response is not paginated.
     # @param hits_per_page [Integer] Maximum number of hits per page. (default to 100)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -1732,19 +1865,21 @@ module Algolia
       @api_client.call_api(:GET, path, new_options)
     end
 
-    # List userIDs.
     # List the userIDs assigned to a multi-cluster application. Since it can take up to a few seconds to get the data from the different clusters, the response isn't real-time.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param page [Integer] Returns the requested page number. The page size is determined by the &#x60;hitsPerPage&#x60; parameter. You can see the number of available pages in the &#x60;nbPages&#x60; response attribute. When &#x60;page&#x60; is null, the API response is not paginated.
     # @param hits_per_page [Integer] Maximum number of hits per page. (default to 100)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [ListUserIdsResponse]
     def list_user_ids(page = nil, hits_per_page = nil, request_options = {})
       response = list_user_ids_with_http_info(page, hits_per_page, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::ListUserIdsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ListUserIdsResponse')
     end
 
-    # Batch write operations on multiple indices.
     # To reduce the time spent on network round trips, you can perform several write actions in a single request. It&#39;s a multi-index version of the [&#x60;batch&#x60; operation](#tag/Records/operation/batch). Actions are applied in the order they are specified. The supported actions are equivalent to the individual operations of the same name.
+
     # @param batch_params [BatchParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1773,18 +1908,20 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Batch write operations on multiple indices.
     # To reduce the time spent on network round trips, you can perform several write actions in a single request. It's a multi-index version of the [`batch` operation](#tag/Records/operation/batch). Actions are applied in the order they are specified. The supported actions are equivalent to the individual operations of the same name.
+
     # @param batch_params [BatchParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [MultipleBatchResponse]
     def multiple_batch(batch_params, request_options = {})
       response = multiple_batch_with_http_info(batch_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::MultipleBatchResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::MultipleBatchResponse')
     end
 
-    # Copy, move, or rename an index.
     # This &#x60;operation&#x60;, _copy_ or _move_, will copy or move a source index&#39;s (&#x60;IndexName&#x60;) records, settings, synonyms, and rules to a &#x60;destination&#x60; index. If the destination index exists, it will be replaced, except for index-specific API keys and analytics data. If the destination index doesn&#39;t exist, it will be created.  The choice between moving or copying an index depends on your needs. Choose:  - **Move** to rename an index. - **Copy** to create a new index with the same records and configuration as an existing one.  &gt; **Note**: When considering copying or moving, be aware of the [rate limitations](https://www.algolia.com/doc/guides/scaling/algolia-service-limits/#application-record-and-index-limits) on these processes and the [impact on your analytics data](https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/concepts/indices-analytics/).
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param operation_index_params [OperationIndexParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -1799,7 +1936,7 @@ module Algolia
         raise ArgumentError, "Parameter `operation_index_params` is required when calling `operation_index`."
       end
 
-      path = '/1/indexes/{indexName}/operation'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/operation'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1818,19 +1955,23 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Copy, move, or rename an index.
     # This `operation`, _copy_ or _move_, will copy or move a source index's (`IndexName`) records, settings, synonyms, and rules to a `destination` index. If the destination index exists, it will be replaced, except for index-specific API keys and analytics data. If the destination index doesn't exist, it will be created.  The choice between moving or copying an index depends on your needs. Choose:  - **Move** to rename an index. - **Copy** to create a new index with the same records and configuration as an existing one.  > **Note**: When considering copying or moving, be aware of the [rate limitations](https://www.algolia.com/doc/guides/scaling/algolia-service-limits/#application-record-and-index-limits) on these processes and the [impact on your analytics data](https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/concepts/indices-analytics/).
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param operation_index_params [OperationIndexParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UpdatedAtResponse]
     def operation_index(index_name, operation_index_params, request_options = {})
       response = operation_index_with_http_info(index_name, operation_index_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Update record attributes.
     # Add new attributes or update current ones in an existing record. You can use any first-level attribute but not nested attributes. If you specify a [nested attribute](https://www.algolia.com/doc/guides/sending-and-managing-data/prepare-your-data/how-to/creating-and-using-nested-attributes/), the engine treats it as a replacement for its first-level ancestor.
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique record (object) identifier. (required)
     # @param attributes_to_update [Hash<String, AttributeToUpdate>] Object with attributes to update. (required)
@@ -1851,8 +1992,8 @@ module Algolia
         raise ArgumentError, "Parameter `attributes_to_update` is required when calling `partial_update_object`."
       end
 
-      path = '/1/indexes/{indexName}/{objectID}/partial'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                   @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/{objectID}/partial'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                                 Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params[:createIfNotExists] = create_if_not_exists unless create_if_not_exists.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -1872,8 +2013,10 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Update record attributes.
     # Add new attributes or update current ones in an existing record. You can use any first-level attribute but not nested attributes. If you specify a [nested attribute](https://www.algolia.com/doc/guides/sending-and-managing-data/prepare-your-data/how-to/creating-and-using-nested-attributes/), the engine treats it as a replacement for its first-level ancestor.
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique record (object) identifier. (required)
     # @param attributes_to_update [Hash<String, AttributeToUpdate>] Object with attributes to update. (required)
@@ -1882,11 +2025,13 @@ module Algolia
     # @return [UpdatedAtWithObjectIdResponse]
     def partial_update_object(index_name, object_id, attributes_to_update, create_if_not_exists = nil, request_options = {})
       response = partial_update_object_with_http_info(index_name, object_id, attributes_to_update, create_if_not_exists, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtWithObjectIdResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtWithObjectIdResponse')
     end
 
-    # Remove userID.
     # Remove a userID and its associated data from the multi-clusters.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param user_id [String] userID to assign. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1901,7 +2046,7 @@ module Algolia
         raise ArgumentError, "invalid value for 'user_id' when calling SearchClient.remove_user_id, must conform to the pattern #{pattern}."
       end
 
-      path = '/1/clusters/mapping/{userID}'.sub('{' + 'userID' + '}', @api_client.encode_uri(user_id.to_s))
+      path = '/1/clusters/mapping/{userID}'.sub('{' + 'userID' + '}', Transport.encode_uri(user_id.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1920,18 +2065,22 @@ module Algolia
       @api_client.call_api(:DELETE, path, new_options)
     end
 
-    # Remove userID.
     # Remove a userID and its associated data from the multi-clusters.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param user_id [String] userID to assign. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [RemoveUserIdResponse]
     def remove_user_id(user_id, request_options = {})
       response = remove_user_id_with_http_info(user_id, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::RemoveUserIdResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::RemoveUserIdResponse')
     end
 
-    # Replace all sources.
     # Replace all allowed sources.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param source [Array<Source>] Allowed sources. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1960,18 +2109,22 @@ module Algolia
       @api_client.call_api(:PUT, path, new_options)
     end
 
-    # Replace all sources.
     # Replace all allowed sources.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param source [Array<Source>] Allowed sources. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [ReplaceSourceResponse]
     def replace_sources(source, request_options = {})
       response = replace_sources_with_http_info(source, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::ReplaceSourceResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ReplaceSourceResponse')
     end
 
-    # Restore API key.
     # Restore a deleted API key, along with its associated permissions. The request must be authenticated with the admin API key.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param key [String] API key. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -1981,7 +2134,7 @@ module Algolia
         raise ArgumentError, "Parameter `key` is required when calling `restore_api_key`."
       end
 
-      path = '/1/keys/{key}/restore'.sub('{' + 'key' + '}', @api_client.encode_uri(key.to_s))
+      path = '/1/keys/{key}/restore'.sub('{' + 'key' + '}', Transport.encode_uri(key.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2000,18 +2153,22 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Restore API key.
     # Restore a deleted API key, along with its associated permissions. The request must be authenticated with the admin API key.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param key [String] API key. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [AddApiKeyResponse]
     def restore_api_key(key, request_options = {})
       response = restore_api_key_with_http_info(key, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::AddApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::AddApiKeyResponse')
     end
 
-    # Add or update a record.
     # Add a record (object) to an index or replace it. If the record doesn&#39;t contain an &#x60;objectID&#x60;, Algolia automatically adds it. If you use an existing &#x60;objectID&#x60;, the existing record is replaced with the new one. To add multiple records to your index in a single API request, use the [&#x60;batch&#x60; operation](#tag/Records/operation/batch).
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param body [Object] The Algolia record. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -2026,7 +2183,7 @@ module Algolia
         raise ArgumentError, "Parameter `body` is required when calling `save_object`."
       end
 
-      path = '/1/indexes/{indexName}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2045,19 +2202,23 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Add or update a record.
     # Add a record (object) to an index or replace it. If the record doesn't contain an `objectID`, Algolia automatically adds it. If you use an existing `objectID`, the existing record is replaced with the new one. To add multiple records to your index in a single API request, use the [`batch` operation](#tag/Records/operation/batch).
+    #
+    # Required API Key ACLs:
+    #   - addObject
     # @param index_name [String] Index on which to perform the request. (required)
     # @param body [Object] The Algolia record. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [SaveObjectResponse]
     def save_object(index_name, body, request_options = {})
       response = save_object_with_http_info(index_name, body, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SaveObjectResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SaveObjectResponse')
     end
 
-    # Create or update a rule.
     # To create or update more than one rule, use the [&#x60;batch&#x60; operation](#tag/Rules/operation/saveRules).
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a rule object. (required)
     # @param rule [Rule]  (required)
@@ -2078,8 +2239,8 @@ module Algolia
         raise ArgumentError, "Parameter `rule` is required when calling `save_rule`."
       end
 
-      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                 @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                               Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -2099,8 +2260,10 @@ module Algolia
       @api_client.call_api(:PUT, path, new_options)
     end
 
-    # Create or update a rule.
     # To create or update more than one rule, use the [`batch` operation](#tag/Rules/operation/saveRules).
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a rule object. (required)
     # @param rule [Rule]  (required)
@@ -2109,11 +2272,13 @@ module Algolia
     # @return [UpdatedRuleResponse]
     def save_rule(index_name, object_id, rule, forward_to_replicas = nil, request_options = {})
       response = save_rule_with_http_info(index_name, object_id, rule, forward_to_replicas, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedRuleResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedRuleResponse')
     end
 
-    # Save a batch of rules.
     # Create or update multiple rules.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param rules [Array<Rule>]  (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -2130,7 +2295,7 @@ module Algolia
         raise ArgumentError, "Parameter `rules` is required when calling `save_rules`."
       end
 
-      path = '/1/indexes/{indexName}/rules/batch'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/rules/batch'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params[:clearExistingRules] = clear_existing_rules unless clear_existing_rules.nil?
@@ -2151,8 +2316,10 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Save a batch of rules.
     # Create or update multiple rules.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param rules [Array<Rule>]  (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -2161,11 +2328,13 @@ module Algolia
     # @return [UpdatedAtResponse]
     def save_rules(index_name, rules, forward_to_replicas = nil, clear_existing_rules = nil, request_options = {})
       response = save_rules_with_http_info(index_name, rules, forward_to_replicas, clear_existing_rules, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Save a synonym.
     # Add a [synonym](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/#the-different-types-of-synonyms) to an index or replace it. If the synonym &#x60;objectID&#x60; doesn&#39;t exist, Algolia adds a new one. If you use an existing synonym &#x60;objectID&#x60;, the existing synonym is replaced with the new one. To add multiple synonyms in a single API request, use the [&#x60;batch&#x60; operation](#tag/Synonyms/operation/saveSynonyms).
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a synonym object. (required)
     # @param synonym_hit [SynonymHit]  (required)
@@ -2186,8 +2355,8 @@ module Algolia
         raise ArgumentError, "Parameter `synonym_hit` is required when calling `save_synonym`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                    @api_client.encode_uri(object_id.to_s))
+      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
+                                                                                                                                  Transport.encode_uri(object_id.to_s))
       query_params = {}
       query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -2207,8 +2376,10 @@ module Algolia
       @api_client.call_api(:PUT, path, new_options)
     end
 
-    # Save a synonym.
     # Add a [synonym](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/#the-different-types-of-synonyms) to an index or replace it. If the synonym `objectID` doesn't exist, Algolia adds a new one. If you use an existing synonym `objectID`, the existing synonym is replaced with the new one. To add multiple synonyms in a single API request, use the [`batch` operation](#tag/Synonyms/operation/saveSynonyms).
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param object_id [String] Unique identifier of a synonym object. (required)
     # @param synonym_hit [SynonymHit]  (required)
@@ -2217,11 +2388,13 @@ module Algolia
     # @return [SaveSynonymResponse]
     def save_synonym(index_name, object_id, synonym_hit, forward_to_replicas = nil, request_options = {})
       response = save_synonym_with_http_info(index_name, object_id, synonym_hit, forward_to_replicas, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SaveSynonymResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SaveSynonymResponse')
     end
 
-    # Save a batch of synonyms.
     # Create or update multiple synonyms.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param synonym_hit [Array<SynonymHit>]  (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -2238,7 +2411,7 @@ module Algolia
         raise ArgumentError, "Parameter `synonym_hit` is required when calling `save_synonyms`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/batch'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/synonyms/batch'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params[:replaceExistingSynonyms] = replace_existing_synonyms unless replace_existing_synonyms.nil?
@@ -2259,8 +2432,10 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Save a batch of synonyms.
     # Create or update multiple synonyms.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param synonym_hit [Array<SynonymHit>]  (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -2269,11 +2444,13 @@ module Algolia
     # @return [UpdatedAtResponse]
     def save_synonyms(index_name, synonym_hit, forward_to_replicas = nil, replace_existing_synonyms = nil, request_options = {})
       response = save_synonyms_with_http_info(index_name, synonym_hit, forward_to_replicas, replace_existing_synonyms, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Search multiple indices.
     # Send multiple search queries to one or more indices.
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param search_method_params [SearchMethodParams] Query requests and strategies. Results will be received in the same order as the queries. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -2296,24 +2473,28 @@ module Algolia
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
-        :use_read_transporter => false
+        :use_read_transporter => true
       )
 
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Search multiple indices.
     # Send multiple search queries to one or more indices.
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param search_method_params [SearchMethodParams] Query requests and strategies. Results will be received in the same order as the queries. (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [SearchResponses]
     def search(search_method_params, request_options = {})
       response = search_with_http_info(search_method_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchResponses')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchResponses')
     end
 
-    # Search dictionary entries.
     # Search for standard and [custom](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-stop-words/) entries in the [stop words](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-stop-words/), [plurals](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-plurals-and-other-declensions/), or [segmentation (compounds)](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-segmentation/) dictionaries.
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param dictionary_name [DictionaryType] Dictionary to search in. (required)
     # @param search_dictionary_entries_params [SearchDictionaryEntriesParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -2328,7 +2509,7 @@ module Algolia
         raise ArgumentError, "Parameter `search_dictionary_entries_params` is required when calling `search_dictionary_entries`."
       end
 
-      path = '/1/dictionaries/{dictionaryName}/search'.sub('{' + 'dictionaryName' + '}', @api_client.encode_uri(dictionary_name.to_s))
+      path = '/1/dictionaries/{dictionaryName}/search'.sub('{' + 'dictionaryName' + '}', Transport.encode_uri(dictionary_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2341,25 +2522,29 @@ module Algolia
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
-        :use_read_transporter => false
+        :use_read_transporter => true
       )
 
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Search dictionary entries.
     # Search for standard and [custom](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-stop-words/) entries in the [stop words](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-stop-words/), [plurals](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-plurals-and-other-declensions/), or [segmentation (compounds)](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-segmentation/) dictionaries.
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param dictionary_name [DictionaryType] Dictionary to search in. (required)
     # @param search_dictionary_entries_params [SearchDictionaryEntriesParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UpdatedAtResponse]
     def search_dictionary_entries(dictionary_name, search_dictionary_entries_params, request_options = {})
       response = search_dictionary_entries_with_http_info(dictionary_name, search_dictionary_entries_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Search for facet values.
     # [Search for a facet&#39;s values](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#search-for-facet-values), optionally restricting the returned values to those contained in records matching other search criteria. &gt; **Note**: Pagination isn&#39;t supported (&#x60;page&#x60; and &#x60;hitsPerPage&#x60; are ignored). By default, the engine returns a maximum of 10 values but you can adjust this with &#x60;maxFacetHits&#x60;.
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param index_name [String] Index on which to perform the request. (required)
     # @param facet_name [String] Facet name. (required)
     # @param search_for_facet_values_request [SearchForFacetValuesRequest]
@@ -2375,8 +2560,8 @@ module Algolia
         raise ArgumentError, "Parameter `facet_name` is required when calling `search_for_facet_values`."
       end
 
-      path = '/1/indexes/{indexName}/facets/{facetName}/query'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s)).sub('{' + 'facetName' + '}',
-                                                                                                                                         @api_client.encode_uri(facet_name.to_s))
+      path = '/1/indexes/{indexName}/facets/{facetName}/query'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'facetName' + '}',
+                                                                                                                                       Transport.encode_uri(facet_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2389,14 +2574,16 @@ module Algolia
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
-        :use_read_transporter => false
+        :use_read_transporter => true
       )
 
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Search for facet values.
     # [Search for a facet's values](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#search-for-facet-values), optionally restricting the returned values to those contained in records matching other search criteria. > **Note**: Pagination isn't supported (`page` and `hitsPerPage` are ignored). By default, the engine returns a maximum of 10 values but you can adjust this with `maxFacetHits`.
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param index_name [String] Index on which to perform the request. (required)
     # @param facet_name [String] Facet name. (required)
     # @param search_for_facet_values_request [SearchForFacetValuesRequest]
@@ -2404,11 +2591,13 @@ module Algolia
     # @return [SearchForFacetValuesResponse]
     def search_for_facet_values(index_name, facet_name, search_for_facet_values_request = nil, request_options = {})
       response = search_for_facet_values_with_http_info(index_name, facet_name, search_for_facet_values_request, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchForFacetValuesResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchForFacetValuesResponse')
     end
 
-    # Search for rules.
     # Search for rules in your index. You can control the search with parameters. To list all rules, send an empty request body.
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param search_rules_params [SearchRulesParams]
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -2419,7 +2608,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `search_rules`."
       end
 
-      path = '/1/indexes/{indexName}/rules/search'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/rules/search'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2432,25 +2621,29 @@ module Algolia
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
-        :use_read_transporter => false
+        :use_read_transporter => true
       )
 
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Search for rules.
     # Search for rules in your index. You can control the search with parameters. To list all rules, send an empty request body.
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param search_rules_params [SearchRulesParams]
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [SearchRulesResponse]
     def search_rules(index_name, search_rules_params = nil, request_options = {})
       response = search_rules_with_http_info(index_name, search_rules_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchRulesResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchRulesResponse')
     end
 
-    # Search an index.
     # Return records that match the query.
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param index_name [String] Index on which to perform the request. (required)
     # @param search_params [SearchParams]
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -2461,7 +2654,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `search_single_index`."
       end
 
-      path = '/1/indexes/{indexName}/query'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/query'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2474,46 +2667,41 @@ module Algolia
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
-        :use_read_transporter => false
+        :use_read_transporter => true
       )
 
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Search an index.
     # Return records that match the query.
+    #
+    # Required API Key ACLs:
+    #   - search
     # @param index_name [String] Index on which to perform the request. (required)
     # @param search_params [SearchParams]
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [SearchResponse]
     def search_single_index(index_name, search_params = nil, request_options = {})
       response = search_single_index_with_http_info(index_name, search_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchResponse')
     end
 
-    # Search for synonyms.
     # Search for synonyms in your index. You can control and filter the search with parameters. To get all synonyms, send an empty request body.
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param index_name [String] Index on which to perform the request. (required)
-    # @param type [SynonymType] Search for specific [types of synonyms](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/#the-different-types-of-synonyms).
-    # @param page [Integer] Returns the requested page number (the first page is 0). Page size is set by &#x60;hitsPerPage&#x60;. When null, there&#39;s no pagination.  (default to 0)
-    # @param hits_per_page [Integer] Maximum number of hits per page. (default to 100)
     # @param search_synonyms_params [SearchSynonymsParams] Body of the &#x60;searchSynonyms&#x60; operation.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
-    def search_synonyms_with_http_info(index_name, type = nil, page = nil, hits_per_page = nil, search_synonyms_params = nil, request_options = {})
+    def search_synonyms_with_http_info(index_name, search_synonyms_params = nil, request_options = {})
       # verify the required parameter 'index_name' is set
       if @api_client.config.client_side_validation && index_name.nil?
         raise ArgumentError, "Parameter `index_name` is required when calling `search_synonyms`."
       end
-      if @api_client.config.client_side_validation && !page.nil? && page < 0
-        raise ArgumentError, 'invalid value for ""page"" when calling SearchClient.search_synonyms, must be greater than or equal to 0.'
-      end
 
-      path = '/1/indexes/{indexName}/synonyms/search'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/synonyms/search'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
-      query_params[:type] = type unless type.nil?
-      query_params[:page] = page unless page.nil?
-      query_params[:hitsPerPage] = hits_per_page unless hits_per_page.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
       header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
@@ -2525,28 +2713,29 @@ module Algolia
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
-        :use_read_transporter => false
+        :use_read_transporter => true
       )
 
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Search for synonyms.
     # Search for synonyms in your index. You can control and filter the search with parameters. To get all synonyms, send an empty request body.
+    #
+    # Required API Key ACLs:
+    #   - settings
     # @param index_name [String] Index on which to perform the request. (required)
-    # @param type [SynonymType] Search for specific [types of synonyms](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/#the-different-types-of-synonyms).
-    # @param page [Integer] Returns the requested page number (the first page is 0). Page size is set by &#x60;hitsPerPage&#x60;. When null, there&#39;s no pagination.  (default to 0)
-    # @param hits_per_page [Integer] Maximum number of hits per page. (default to 100)
     # @param search_synonyms_params [SearchSynonymsParams] Body of the &#x60;searchSynonyms&#x60; operation.
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [SearchSynonymsResponse]
-    def search_synonyms(index_name, type = nil, page = nil, hits_per_page = nil, search_synonyms_params = nil, request_options = {})
-      response = search_synonyms_with_http_info(index_name, type, page, hits_per_page, search_synonyms_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchSynonymsResponse')
+    def search_synonyms(index_name, search_synonyms_params = nil, request_options = {})
+      response = search_synonyms_with_http_info(index_name, search_synonyms_params, request_options)
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchSynonymsResponse')
     end
 
-    # Search for a user ID.
     # Since it can take up to a few seconds to get the data from the different clusters, the response isn&#39;t real-time. To ensure rapid updates, the user IDs index isn&#39;t built at the same time as the mapping. Instead, it&#39;s built every 12 hours, at the same time as the update of user ID usage. For example, if you add or move a user ID, the search will show an old value until the next time the mapping is rebuilt (every 12 hours).
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param search_user_ids_params [SearchUserIdsParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -2569,24 +2758,28 @@ module Algolia
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
-        :use_read_transporter => false
+        :use_read_transporter => true
       )
 
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Search for a user ID.
     # Since it can take up to a few seconds to get the data from the different clusters, the response isn't real-time. To ensure rapid updates, the user IDs index isn't built at the same time as the mapping. Instead, it's built every 12 hours, at the same time as the update of user ID usage. For example, if you add or move a user ID, the search will show an old value until the next time the mapping is rebuilt (every 12 hours).
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param search_user_ids_params [SearchUserIdsParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [SearchUserIdsResponse]
     def search_user_ids(search_user_ids_params, request_options = {})
       response = search_user_ids_with_http_info(search_user_ids_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchUserIdsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchUserIdsResponse')
     end
 
-    # Set stop word settings.
     # Set stop word settings for a specific language.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param dictionary_settings_params [DictionarySettingsParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [Http::Response] the response
@@ -2615,18 +2808,22 @@ module Algolia
       @api_client.call_api(:PUT, path, new_options)
     end
 
-    # Set stop word settings.
     # Set stop word settings for a specific language.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param dictionary_settings_params [DictionarySettingsParams]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UpdatedAtResponse]
     def set_dictionary_settings(dictionary_settings_params, request_options = {})
       response = set_dictionary_settings_with_http_info(dictionary_settings_params, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Update index settings.
     # Update the specified [index settings](https://www.algolia.com/doc/api-reference/settings-api-parameters/). Specifying null for a setting resets it to its default value.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param index_settings [IndexSettings]  (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -2642,7 +2839,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_settings` is required when calling `set_settings`."
       end
 
-      path = '/1/indexes/{indexName}/settings'.sub('{' + 'indexName' + '}', @api_client.encode_uri(index_name.to_s))
+      path = '/1/indexes/{indexName}/settings'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
       query_params = {}
       query_params[:forwardToReplicas] = forward_to_replicas unless forward_to_replicas.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -2662,8 +2859,10 @@ module Algolia
       @api_client.call_api(:PUT, path, new_options)
     end
 
-    # Update index settings.
     # Update the specified [index settings](https://www.algolia.com/doc/api-reference/settings-api-parameters/). Specifying null for a setting resets it to its default value.
+    #
+    # Required API Key ACLs:
+    #   - editSettings
     # @param index_name [String] Index on which to perform the request. (required)
     # @param index_settings [IndexSettings]  (required)
     # @param forward_to_replicas [Boolean] Indicates whether changed index settings are forwarded to the replica indices.
@@ -2671,11 +2870,13 @@ module Algolia
     # @return [UpdatedAtResponse]
     def set_settings(index_name, index_settings, forward_to_replicas = nil, request_options = {})
       response = set_settings_with_http_info(index_name, index_settings, forward_to_replicas, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
     end
 
-    # Update an API key.
     # Replace the permissions of an existing API key. Any unspecified parameter resets that permission to its default value. The request must be authenticated with the admin API key.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param key [String] API key. (required)
     # @param api_key [ApiKey]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
@@ -2690,7 +2891,7 @@ module Algolia
         raise ArgumentError, "Parameter `api_key` is required when calling `update_api_key`."
       end
 
-      path = '/1/keys/{key}'.sub('{' + 'key' + '}', @api_client.encode_uri(key.to_s))
+      path = '/1/keys/{key}'.sub('{' + 'key' + '}', Transport.encode_uri(key.to_s))
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2709,15 +2910,159 @@ module Algolia
       @api_client.call_api(:PUT, path, new_options)
     end
 
-    # Update an API key.
     # Replace the permissions of an existing API key. Any unspecified parameter resets that permission to its default value. The request must be authenticated with the admin API key.
+    #
+    # Required API Key ACLs:
+    #   - admin
     # @param key [String] API key. (required)
     # @param api_key [ApiKey]  (required)
     # @param request_options: The request options to send along with the query, they will be merged with the transporter base parameters (headers, query params, timeouts, etc.). (optional)
     # @return [UpdateApiKeyResponse]
     def update_api_key(key, api_key, request_options = {})
       response = update_api_key_with_http_info(key, api_key, request_options)
-      deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdateApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdateApiKeyResponse')
+    end
+
+    # Helper: Wait for a task to be published (completed) for a given `index_name` and `task_id`.
+    #
+    # @param index_name [String] the `index_name` where the operation was performed. (required)
+    # @param task_id [Integer] the `task_id` returned in the method response. (required)
+    # @param max_retries [Integer] the maximum number of retries. (optional, default to 50)
+    # @param timeout [Proc] the function to decide how long to wait between retries. (optional)
+    # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `get_task` method.
+    # @return [Http::Response] the last get_task response
+    def wait_for_task(index_name, task_id, max_retries = 50, timeout = ->(retry_count) { [retry_count * 200, 5000].min }, request_options = {})
+      retries = 0
+      while retries < max_retries
+        res = get_task(index_name, task_id, request_options)
+        if res.status == 'published'
+          return res
+        end
+
+        retries += 1
+        sleep(timeout.call(retries) / 1000.0)
+      end
+      raise ApiError, "The maximum number of retries exceeded. (#{max_retries})"
+    end
+
+    # Helper: Wait for an API key to be added, updated or deleted based on a given `operation`.
+    #
+    # @param operation [String] the `operation` that was done on a `key`.
+    # @param key [String] the `key` that has been added, deleted or updated.
+    # @param api_key [Hash] necessary to know if an `update` operation has been processed, compare fields of the response with it.
+    # @param max_retries [Integer] the maximum number of retries.
+    # @param timeout [Proc] the function to decide how long to wait between retries.
+    # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `getApikey` method and merged with the transporter requestOptions.
+    # @return [Http::Response] the last get_api_key response
+    def wait_for_api_key(operation, key, api_key = {}, max_retries = 50, timeout = ->(retry_count) { [retry_count * 200, 5000].min }, request_options = {})
+      retries = 0
+      if operation == 'update'
+        raise ArgumentError, '`api_key` is required when waiting for an `update` operation.' if api_key.nil?
+
+        while retries < max_retries
+          begin
+            updatad_key = get_api_key(key, request_options)
+            updated_key_hash = updatad_key.to_hash
+            equals = true
+            api_key.to_hash.each do |k, v|
+              equals &&= updated_key_hash[k] == v
+            end
+
+            return updatad_key if equals
+          rescue AlgoliaError => e
+            raise e unless e.code == 404
+          end
+
+          retries += 1
+          sleep(timeout.call(retries) / 1000.0)
+        end
+
+        raise ApiError, "The maximum number of retries exceeded. (#{max_retries})"
+      end
+
+      while retries < max_retries
+        begin
+          res = get_api_key(key, request_options)
+          return res if operation == 'add'
+        rescue AlgoliaError => e
+          return res if operation == 'delete' && e.code == 404
+        end
+        retries += 1
+        sleep(timeout.call(retries) / 1000.0)
+      end
+      raise ApiError, "The maximum number of retries exceeded. (#{max_retries})"
+    end
+
+    # Helper: Iterate on the `browse` method of the client to allow aggregating objects of an index.
+    #
+    # @param index_name [String] the `index_name` to browse. (required)
+    # @param browse_params [BrowseParamsObject] the `browse_params` to send along with the query, they will be forwarded to the `browse` method.
+    # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `browse` method.
+    # @param block [Proc] the block to execute on each object of the index.
+    def browse_objects(index_name, browse_params = Search::BrowseParamsObject.new, request_options = {}, &block)
+      hits = []
+      loop do
+        res = browse(index_name, browse_params, request_options)
+        if block_given?
+          res.hits.each do |hit|
+            block.call(hit)
+          end
+        else
+          hits.concat(res.hits)
+        end
+        browse_params.cursor = res.cursor
+        break if browse_params.cursor.nil?
+      end
+
+      hits unless block_given?
+    end
+
+    # Helper: Iterate on the `searchRules` method of the client to allow aggregating rules of an index.
+    #
+    # @param index_name [String] the `index_name` to browse rules from. (required)
+    # @param search_rules_params [SearchRulesParams] the parameters to send along with the query, they will be forwarded to the `searchRules` method.
+    # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `searchRules` method.
+    # @param block [Proc] the block to execute on each rule of the index.
+    def browse_rules(index_name, search_rules_params = Search::SearchRulesParams.new(hits_per_page: 1000, page: 0), request_options = {}, &block)
+      rules = []
+      loop do
+        res = search_rules(index_name, search_rules_params, request_options)
+        if block_given?
+          res.hits.each do |rule|
+            block.call(rule)
+          end
+        else
+          rules.concat(res.hits)
+        end
+        search_rules_params.page += 1
+        break if res.nb_hits < search_rules_params.hits_per_page
+      end
+
+      rules unless block_given?
+    end
+
+    # Helper: Iterate on the `searchSynonyms` method of the client to allow aggregating synonyms of an index.
+    #
+    # @param index_name [String] the `index_name` to browse synonyms from. (required)
+    # @param search_synonyms_params [SearchSynonymsParams] the parameters to send along with the query, they will be forwarded to the `searchSynonyms` method.
+    # @param request_options [Hash] the requestOptions to send along with the query, they will be forwarded to the `searchSynonyms` method.
+    # @param block [Proc] the block to execute on each synonym of the index.
+    def browse_synonyms(index_name, search_synonyms_params = Search::SearchSynonymsParams.new(hits_per_page: 1000, page: 0), request_options = {}, &block)
+      synonyms = []
+      loop do
+        res = search_synonyms(index_name, search_synonyms_params, request_options)
+        if block_given?
+          res.hits.each do |synonym|
+            block.call(synonym)
+          end
+        else
+          synonyms.concat(res.hits)
+        end
+        search_synonyms_params.page += 1
+        break if res.nb_hits < search_synonyms_params.hits_per_page
+      end
+
+      synonyms unless block_given?
     end
   end
 end