algolia 3.0.0.beta.8 → 3.0.0.beta.10

data/lib/algolia/api/search_client.rb

@@ -1,16 +1,16 @@
 # Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
 
-require 'openssl'
-require 'base64'
+require "openssl"
+require "base64"
 
 module Algolia
   class SearchClient
     attr_accessor :api_client
 
     def initialize(config = nil)
-      raise '`config` is missing.' if config.nil?
-      raise '`app_id` is missing.' if config.app_id.nil? || config.app_id == ''
-      raise '`api_key` is missing.' if config.api_key.nil? || config.api_key == ''
+      raise "`config` is missing." if config.nil?
+      raise "`app_id` is missing." if config.app_id.nil? || config.app_id == ""
+      raise "`api_key` is missing." if config.api_key.nil? || config.api_key == ""
 
       @api_client = Algolia::ApiClient.new(config)
     end
@@ -20,11 +20,14 @@ module Algolia
       hosts << Transport::StatefulHost.new("#{app_id}-dsn.algolia.net", accept: CallType::READ)
       hosts << Transport::StatefulHost.new("#{app_id}.algolia.net", accept: CallType::WRITE)
 
-      hosts += 1.upto(3).map do |i|
-        Transport::StatefulHost.new("#{app_id}-#{i}.algolianet.com", accept: CallType::READ | CallType::WRITE)
-      end.shuffle
+      hosts += 1
+        .upto(3)
+        .map do |i|
+          Transport::StatefulHost.new("#{app_id}-#{i}.algolianet.com", accept: CallType::READ | CallType::WRITE)
+        end
+        .shuffle
 
-      config = Algolia::Configuration.new(app_id, api_key, hosts, 'Search', opts)
+      config = Algolia::Configuration.new(app_id, api_key, hosts, "Search", opts)
       create_with_config(config)
     end
 
@@ -45,7 +48,7 @@ module Algolia
         raise ArgumentError, "Parameter `api_key` is required when calling `add_api_key`."
       end
 
-      path = '/1/keys'
+      path = "/1/keys"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -54,7 +57,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(api_key)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.add_api_key',
+        :operation => :"SearchClient.add_api_key",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -73,7 +76,7 @@ module Algolia
     # @return [AddApiKeyResponse]
     def add_api_key(api_key, request_options = {})
       response = add_api_key_with_http_info(api_key, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::AddApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::AddApiKeyResponse")
     end
 
     # If a record with the specified object ID exists, the existing record is replaced. Otherwise, a new record is added to the index.  To update _some_ attributes of an existing record, use the [&#x60;partial&#x60; operation](#tag/Records/operation/partialUpdateObject) instead. To add, update, or replace multiple records, use the [&#x60;batch&#x60; operation](#tag/Records/operation/batch).
@@ -99,8 +102,10 @@ module Algolia
         raise ArgumentError, "Parameter `body` is required when calling `add_or_update_object`."
       end
 
-      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                         Transport.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 = {}
@@ -109,7 +114,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(body)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.add_or_update_object',
+        :operation => :"SearchClient.add_or_update_object",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -130,7 +135,10 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtWithObjectIdResponse')
+      @api_client.deserialize(
+        response.body,
+        request_options[:debug_return_type] || "Search::UpdatedAtWithObjectIdResponse"
+      )
     end
 
     # Adds a source to the list of allowed sources.
@@ -146,7 +154,7 @@ module Algolia
         raise ArgumentError, "Parameter `source` is required when calling `append_source`."
       end
 
-      path = '/1/security/sources/append'
+      path = "/1/security/sources/append"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -155,7 +163,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(source)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.append_source',
+        :operation => :"SearchClient.append_source",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -174,7 +182,7 @@ module Algolia
     # @return [CreatedAtResponse]
     def append_source(source, request_options = {})
       response = append_source_with_http_info(source, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::CreatedAtResponse")
     end
 
     # Assigns or moves 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.
@@ -193,7 +201,10 @@ module Algolia
 
       pattern = /^[a-zA-Z0-9 \-*.]+$/
       if @api_client.config.client_side_validation && x_algolia_user_id !~ pattern
-        raise ArgumentError, "invalid value for 'x_algolia_user_id' when calling SearchClient.assign_user_id, must conform to the pattern #{pattern}."
+        raise(
+          ArgumentError,
+          "invalid value for 'x_algolia_user_id' when calling SearchClient.assign_user_id, must conform to the pattern #{pattern}."
+        )
       end
 
       # verify the required parameter 'assign_user_id_params' is set
@@ -201,17 +212,17 @@ module Algolia
         raise ArgumentError, "Parameter `assign_user_id_params` is required when calling `assign_user_id`."
       end
 
-      path = '/1/clusters/mapping'
+      path = "/1/clusters/mapping"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
-      header_params[:'X-Algolia-User-ID'] = x_algolia_user_id
+      header_params[:"X-Algolia-User-ID"] = x_algolia_user_id
       header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
 
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(assign_user_id_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.assign_user_id',
+        :operation => :"SearchClient.assign_user_id",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -231,7 +242,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::CreatedAtResponse")
     end
 
     # Adds, updates, or deletes records in one index with a single API request.  Batching index updates reduces latency and increases data integrity.  - Actions are applied in the order they&#39;re specified. - Actions are equivalent to the individual API requests of the same name.
@@ -250,7 +261,7 @@ module Algolia
         raise ArgumentError, "Parameter `batch_write_params` is required when calling `batch`."
       end
 
-      path = '/1/indexes/{indexName}/batch'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -259,7 +270,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(batch_write_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.batch',
+        :operation => :"SearchClient.batch",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -277,7 +288,7 @@ module Algolia
     # @return [BatchResponse]
     def batch(index_name, batch_write_params, request_options = {})
       response = batch_with_http_info(index_name, batch_write_params, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::BatchResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::BatchResponse")
     end
 
     # Assigns multiple user IDs to a cluster.  **You can&#39;t move users with this operation**.
@@ -296,25 +307,31 @@ module Algolia
 
       pattern = /^[a-zA-Z0-9 \-*.]+$/
       if @api_client.config.client_side_validation && x_algolia_user_id !~ pattern
-        raise ArgumentError, "invalid value for 'x_algolia_user_id' when calling SearchClient.batch_assign_user_ids, must conform to the pattern #{pattern}."
+        raise(
+          ArgumentError,
+          "invalid value for 'x_algolia_user_id' when calling SearchClient.batch_assign_user_ids, must conform to the pattern #{pattern}."
+        )
       end
 
       # verify the required parameter 'batch_assign_user_ids_params' is set
       if @api_client.config.client_side_validation && batch_assign_user_ids_params.nil?
-        raise ArgumentError, "Parameter `batch_assign_user_ids_params` is required when calling `batch_assign_user_ids`."
+        raise(
+          ArgumentError,
+          "Parameter `batch_assign_user_ids_params` is required when calling `batch_assign_user_ids`."
+        )
       end
 
-      path = '/1/clusters/mapping/batch'
+      path = "/1/clusters/mapping/batch"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
-      header_params[:'X-Algolia-User-ID'] = x_algolia_user_id
+      header_params[:"X-Algolia-User-ID"] = x_algolia_user_id
       header_params = header_params.merge(request_options[:header_params]) unless request_options[:header_params].nil?
 
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(batch_assign_user_ids_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.batch_assign_user_ids',
+        :operation => :"SearchClient.batch_assign_user_ids",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -334,7 +351,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::CreatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::CreatedAtResponse")
     end
 
     # Adds or deletes multiple entries from your plurals, segmentation, or stop word dictionaries.
@@ -352,10 +369,16 @@ module Algolia
       end
       # verify the required parameter 'batch_dictionary_entries_params' is set
       if @api_client.config.client_side_validation && batch_dictionary_entries_params.nil?
-        raise ArgumentError, "Parameter `batch_dictionary_entries_params` is required when calling `batch_dictionary_entries`."
+        raise(
+          ArgumentError,
+          "Parameter `batch_dictionary_entries_params` is required when calling `batch_dictionary_entries`."
+        )
       end
 
-      path = '/1/dictionaries/{dictionaryName}/batch'.sub('{' + 'dictionaryName' + '}', Transport.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 = {}
@@ -364,7 +387,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(batch_dictionary_entries_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.batch_dictionary_entries',
+        :operation => :"SearchClient.batch_dictionary_entries",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -383,11 +406,15 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      response = batch_dictionary_entries_with_http_info(
+        dictionary_name,
+        batch_dictionary_entries_params,
+        request_options
+      )
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
-    # Retrieves records from an index, up to 1,000 per request.  While searching retrieves _hits_ (records augmented with attributes for highlighting and ranking details), browsing _just_ returns matching records. This can be useful if you want to export your indices.  - The Analytics API doesn&#39;t collect data when using &#x60;browse&#x60;. - Records are ranked by attributes and custom ranking. - Deduplication (&#x60;distinct&#x60;) is turned off. - There&#39;s no ranking for: typo-tolerance, number of matched words, proximity, geo distance.
+    # Retrieves records from an index, up to 1,000 per request.  While searching retrieves _hits_ (records augmented with attributes for highlighting and ranking details), browsing _just_ returns matching records. This can be useful if you want to export your indices.  - The Analytics API doesn&#39;t collect data when using &#x60;browse&#x60;. - Records are ranked by attributes and custom ranking. - There&#39;s no ranking for: typo-tolerance, number of matched words, proximity, geo distance.  Browse requests automatically apply these settings:  - &#x60;advancedSyntax&#x60;: &#x60;false&#x60; - &#x60;attributesToHighlight&#x60;: &#x60;[]&#x60; - &#x60;attributesToSnippet&#x60;: &#x60;[]&#x60; - &#x60;distinct&#x60;: &#x60;false&#x60; - &#x60;enablePersonalization&#x60;: &#x60;false&#x60; - &#x60;enableRules&#x60;: &#x60;false&#x60; - &#x60;facets&#x60;: &#x60;[]&#x60; - &#x60;getRankingInfo&#x60;: &#x60;false&#x60; - &#x60;ignorePlurals&#x60;: &#x60;false&#x60; - &#x60;optionalFilters&#x60;: &#x60;[]&#x60; - &#x60;typoTolerance&#x60;: &#x60;true&#x60; or &#x60;false&#x60; (&#x60;min&#x60; and &#x60;strict&#x60; is evaluated to &#x60;true&#x60;)  If you send these parameters with your browse requests, they&#39;ll be ignored.
     #
     # Required API Key ACLs:
     #   - browse
@@ -401,7 +428,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `browse`."
       end
 
-      path = '/1/indexes/{indexName}/browse'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -410,7 +437,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(browse_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.browse',
+        :operation => :"SearchClient.browse",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -420,7 +447,7 @@ module Algolia
       @api_client.call_api(:POST, path, new_options)
     end
 
-    # Retrieves records from an index, up to 1,000 per request.  While searching retrieves _hits_ (records augmented with attributes for highlighting and ranking details), browsing _just_ returns matching records. This can be useful if you want to export your indices.  - The Analytics API doesn't collect data when using `browse`. - Records are ranked by attributes and custom ranking. - Deduplication (`distinct`) is turned off. - There's no ranking for: typo-tolerance, number of matched words, proximity, geo distance.
+    # Retrieves records from an index, up to 1,000 per request.  While searching retrieves _hits_ (records augmented with attributes for highlighting and ranking details), browsing _just_ returns matching records. This can be useful if you want to export your indices.  - The Analytics API doesn't collect data when using `browse`. - Records are ranked by attributes and custom ranking. - There's no ranking for: typo-tolerance, number of matched words, proximity, geo distance.  Browse requests automatically apply these settings:  - `advancedSyntax`: `false` - `attributesToHighlight`: `[]` - `attributesToSnippet`: `[]` - `distinct`: `false` - `enablePersonalization`: `false` - `enableRules`: `false` - `facets`: `[]` - `getRankingInfo`: `false` - `ignorePlurals`: `false` - `optionalFilters`: `[]` - `typoTolerance`: `true` or `false` (`min` and `strict` is evaluated to `true`)  If you send these parameters with your browse requests, they'll be ignored.
     #
     # Required API Key ACLs:
     #   - browse
@@ -430,7 +457,7 @@ module Algolia
     # @return [BrowseResponse]
     def browse(index_name, browse_params = nil, request_options = {})
       response = browse_with_http_info(index_name, browse_params, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::BrowseResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::BrowseResponse")
     end
 
     # Deletes only the records from an index while keeping settings, synonyms, and rules.
@@ -446,7 +473,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `clear_objects`."
       end
 
-      path = '/1/indexes/{indexName}/clear'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s))
+      path = "/1/indexes/{indexName}/clear".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 = {}
@@ -455,7 +482,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.clear_objects',
+        :operation => :"SearchClient.clear_objects",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -474,7 +501,7 @@ module Algolia
     # @return [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')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # Deletes all rules from the index.
@@ -491,7 +518,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `clear_rules`."
       end
 
-      path = '/1/indexes/{indexName}/rules/clear'.sub('{' + 'indexName' + '}', Transport.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?
@@ -501,7 +528,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.clear_rules',
+        :operation => :"SearchClient.clear_rules",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -521,7 +548,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # Deletes all synonyms from the index.
@@ -538,7 +565,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `clear_synonyms`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/clear'.sub('{' + 'indexName' + '}', Transport.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?
@@ -548,7 +575,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.clear_synonyms',
+        :operation => :"SearchClient.clear_synonyms",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -568,7 +595,7 @@ module Algolia
     # @return [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')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # This method allow you to send requests to the Algolia REST API.
@@ -583,7 +610,7 @@ module Algolia
         raise ArgumentError, "Parameter `path` is required when calling `custom_delete`."
       end
 
-      path = '/{path}'.sub('{' + 'path' + '}', path.to_s)
+      path = "/{path}".sub("{" + "path" + "}", path.to_s)
       query_params = {}
       query_params = query_params.merge(parameters) unless parameters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -593,7 +620,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.custom_delete',
+        :operation => :"SearchClient.custom_delete",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -611,7 +638,7 @@ module Algolia
     # @return [Object]
     def custom_delete(path, parameters = nil, request_options = {})
       response = custom_delete_with_http_info(path, parameters, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Object")
     end
 
     # This method allow you to send requests to the Algolia REST API.
@@ -626,7 +653,7 @@ module Algolia
         raise ArgumentError, "Parameter `path` is required when calling `custom_get`."
       end
 
-      path = '/{path}'.sub('{' + 'path' + '}', path.to_s)
+      path = "/{path}".sub("{" + "path" + "}", path.to_s)
       query_params = {}
       query_params = query_params.merge(parameters) unless parameters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -636,7 +663,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.custom_get',
+        :operation => :"SearchClient.custom_get",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -654,7 +681,7 @@ module Algolia
     # @return [Object]
     def custom_get(path, parameters = nil, request_options = {})
       response = custom_get_with_http_info(path, parameters, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Object")
     end
 
     # This method allow you to send requests to the Algolia REST API.
@@ -670,7 +697,7 @@ module Algolia
         raise ArgumentError, "Parameter `path` is required when calling `custom_post`."
       end
 
-      path = '/{path}'.sub('{' + 'path' + '}', path.to_s)
+      path = "/{path}".sub("{" + "path" + "}", path.to_s)
       query_params = {}
       query_params = query_params.merge(parameters) unless parameters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -680,7 +707,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(body)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.custom_post',
+        :operation => :"SearchClient.custom_post",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -699,7 +726,7 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Object")
     end
 
     # This method allow you to send requests to the Algolia REST API.
@@ -715,7 +742,7 @@ module Algolia
         raise ArgumentError, "Parameter `path` is required when calling `custom_put`."
       end
 
-      path = '/{path}'.sub('{' + 'path' + '}', path.to_s)
+      path = "/{path}".sub("{" + "path" + "}", path.to_s)
       query_params = {}
       query_params = query_params.merge(parameters) unless parameters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -725,7 +752,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(body)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.custom_put',
+        :operation => :"SearchClient.custom_put",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -744,7 +771,7 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Object')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Object")
     end
 
     # Deletes the API key.
@@ -760,7 +787,7 @@ module Algolia
         raise ArgumentError, "Parameter `key` is required when calling `delete_api_key`."
       end
 
-      path = '/1/keys/{key}'.sub('{' + 'key' + '}', Transport.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 = {}
@@ -769,7 +796,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.delete_api_key',
+        :operation => :"SearchClient.delete_api_key",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -788,7 +815,7 @@ module Algolia
     # @return [DeleteApiKeyResponse]
     def delete_api_key(key, request_options = {})
       response = delete_api_key_with_http_info(key, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeleteApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::DeleteApiKeyResponse")
     end
 
     # This operation doesn&#39;t accept empty queries or filters.  It&#39;s more efficient to get a list of object IDs with the [&#x60;browse&#x60; operation](#tag/Search/operation/browse), and then delete the records using the [&#x60;batch&#x60; operation](tag/Records/operation/batch).
@@ -809,7 +836,7 @@ module Algolia
         raise ArgumentError, "Parameter `delete_by_params` is required when calling `delete_by`."
       end
 
-      path = '/1/indexes/{indexName}/deleteByQuery'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -818,7 +845,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(delete_by_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.delete_by',
+        :operation => :"SearchClient.delete_by",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -838,7 +865,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::DeletedAtResponse")
     end
 
     # Deletes an index and all its settings.  - Deleting an index doesn&#39;t delete its analytics data. - If you try to delete a non-existing index, the operation is ignored without warning. - If the index you want to delete has replica indices, the replicas become independent indices. - If the index you want to delete is a replica index, you must first unlink it from its primary index before you can delete it.   For more information, see [Delete replica indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/how-to/deleting-replicas/).
@@ -854,7 +881,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `delete_index`."
       end
 
-      path = '/1/indexes/{indexName}'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -863,7 +890,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.delete_index',
+        :operation => :"SearchClient.delete_index",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -882,7 +909,7 @@ module Algolia
     # @return [DeletedAtResponse]
     def delete_index(index_name, request_options = {})
       response = delete_index_with_http_info(index_name, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::DeletedAtResponse")
     end
 
     # Deletes a record by its object ID.  To delete more than one record, use the [&#x60;batch&#x60; operation](#tag/Records/operation/batch). To delete records matching a query, use the [&#x60;deleteByQuery&#x60; operation](#tag/Records/operation/deleteBy).
@@ -903,8 +930,10 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `delete_object`."
       end
 
-      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                         Transport.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 = {}
@@ -913,7 +942,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.delete_object',
+        :operation => :"SearchClient.delete_object",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -933,7 +962,7 @@ module Algolia
     # @return [DeletedAtResponse]
     def delete_object(index_name, object_id, request_options = {})
       response = delete_object_with_http_info(index_name, object_id, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::DeletedAtResponse")
     end
 
     # Deletes a rule by its ID. To find the object ID for rules, use the [&#x60;search&#x60; operation](#tag/Rules/operation/searchRules).
@@ -955,8 +984,9 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `delete_rule`."
       end
 
-      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                               Transport.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?
@@ -966,7 +996,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.delete_rule',
+        :operation => :"SearchClient.delete_rule",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -987,7 +1017,7 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # Deletes a source from the list of allowed sources.
@@ -1003,7 +1033,7 @@ module Algolia
         raise ArgumentError, "Parameter `source` is required when calling `delete_source`."
       end
 
-      path = '/1/security/sources/{source}'.sub('{' + 'source' + '}', Transport.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 = {}
@@ -1012,7 +1042,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.delete_source',
+        :operation => :"SearchClient.delete_source",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1031,7 +1061,7 @@ module Algolia
     # @return [DeleteSourceResponse]
     def delete_source(source, request_options = {})
       response = delete_source_with_http_info(source, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeleteSourceResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::DeleteSourceResponse")
     end
 
     # Deletes a synonym by its ID. To find the object IDs of your synonyms, use the [&#x60;search&#x60; operation](#tag/Synonyms/operation/searchSynonyms).
@@ -1053,8 +1083,9 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `delete_synonym`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                  Transport.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?
@@ -1064,7 +1095,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.delete_synonym',
+        :operation => :"SearchClient.delete_synonym",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1085,7 +1116,7 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::DeletedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::DeletedAtResponse")
     end
 
     # Gets the permissions and restrictions of an 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.
@@ -1099,7 +1130,7 @@ module Algolia
         raise ArgumentError, "Parameter `key` is required when calling `get_api_key`."
       end
 
-      path = '/1/keys/{key}'.sub('{' + 'key' + '}', Transport.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 = {}
@@ -1108,7 +1139,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_api_key',
+        :operation => :"SearchClient.get_api_key",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1125,7 +1156,7 @@ module Algolia
     # @return [GetApiKeyResponse]
     def get_api_key(key, request_options = {})
       response = get_api_key_with_http_info(key, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::GetApiKeyResponse")
     end
 
     # Checks the status of a given application task.
@@ -1141,7 +1172,7 @@ module Algolia
         raise ArgumentError, "Parameter `task_id` is required when calling `get_app_task`."
       end
 
-      path = '/1/task/{taskID}'.sub('{' + 'taskID' + '}', Transport.encode_uri(task_id.to_s))
+      path = "/1/task/{taskID}".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 = {}
@@ -1150,7 +1181,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_app_task',
+        :operation => :"SearchClient.get_app_task",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1169,7 +1200,7 @@ module Algolia
     # @return [GetTaskResponse]
     def get_app_task(task_id, request_options = {})
       response = get_app_task_with_http_info(task_id, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetTaskResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::GetTaskResponse")
     end
 
     # Lists supported languages with their supported dictionary types and number of custom entries.
@@ -1179,7 +1210,7 @@ module Algolia
     # @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 = {})
-      path = '/1/dictionaries/*/languages'
+      path = "/1/dictionaries/*/languages"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1188,7 +1219,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_dictionary_languages',
+        :operation => :"SearchClient.get_dictionary_languages",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1206,7 +1237,7 @@ module Algolia
     # @return [Hash<String, Languages>]
     def get_dictionary_languages(request_options = {})
       response = get_dictionary_languages_with_http_info(request_options)
-      @api_client.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
 
     # Retrieves the languages for which standard dictionary entries are turned off.
@@ -1216,7 +1247,7 @@ module Algolia
     # @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 = {})
-      path = '/1/dictionaries/*/settings'
+      path = "/1/dictionaries/*/settings"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1225,7 +1256,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_dictionary_settings',
+        :operation => :"SearchClient.get_dictionary_settings",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1243,7 +1274,10 @@ module Algolia
     # @return [GetDictionarySettingsResponse]
     def get_dictionary_settings(request_options = {})
       response = get_dictionary_settings_with_http_info(request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetDictionarySettingsResponse')
+      @api_client.deserialize(
+        response.body,
+        request_options[:debug_return_type] || "Search::GetDictionarySettingsResponse"
+      )
     end
 
     # 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. - Up to 1,000 API requests per server are logged. - 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.
@@ -1258,10 +1292,13 @@ module Algolia
     # @return [Http::Response] the response
     def get_logs_with_http_info(offset = nil, length = nil, index_name = nil, type = nil, request_options = {})
       if @api_client.config.client_side_validation && !length.nil? && length > 1000
-        raise ArgumentError, 'invalid value for ""length"" when calling SearchClient.get_logs, must be smaller than or equal to 1000.'
+        raise(
+          ArgumentError,
+          "invalid value for \"\"length\"\" when calling SearchClient.get_logs, must be smaller than or equal to 1000."
+        )
       end
 
-      path = '/1/logs'
+      path = "/1/logs"
       query_params = {}
       query_params[:offset] = offset unless offset.nil?
       query_params[:length] = length unless length.nil?
@@ -1274,7 +1311,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_logs',
+        :operation => :"SearchClient.get_logs",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1296,7 +1333,7 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetLogsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::GetLogsResponse")
     end
 
     # Retrieves one record by its object ID.  To retrieve more than one record, use the [&#x60;objects&#x60; operation](#tag/Records/operation/getObjects).
@@ -1318,10 +1355,15 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `get_object`."
       end
 
-      path = '/1/indexes/{indexName}/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                         Transport.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?
+      unless attributes_to_retrieve.nil?
+        query_params[:attributesToRetrieve] = @api_client.build_collection_param(attributes_to_retrieve, :multi)
+      end
+
       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?
@@ -1329,7 +1371,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_object',
+        :operation => :"SearchClient.get_object",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1350,7 +1392,7 @@ 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)
-      @api_client.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
 
     # Retrieves one or more records, potentially from different indices.  Records are returned in the same order as the requests.
@@ -1366,7 +1408,7 @@ module Algolia
         raise ArgumentError, "Parameter `get_objects_params` is required when calling `get_objects`."
       end
 
-      path = '/1/indexes/*/objects'
+      path = "/1/indexes/*/objects"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1375,7 +1417,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(get_objects_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_objects',
+        :operation => :"SearchClient.get_objects",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1394,7 +1436,7 @@ module Algolia
     # @return [GetObjectsResponse]
     def get_objects(get_objects_params, request_options = {})
       response = get_objects_with_http_info(get_objects_params, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetObjectsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::GetObjectsResponse")
     end
 
     # Retrieves a rule by its ID. To find the object ID of rules, use the [&#x60;search&#x60; operation](#tag/Rules/operation/searchRules).
@@ -1415,8 +1457,9 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `get_rule`."
       end
 
-      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                               Transport.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 = {}
@@ -1425,7 +1468,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_rule',
+        :operation => :"SearchClient.get_rule",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1445,7 +1488,7 @@ module Algolia
     # @return [Rule]
     def get_rule(index_name, object_id, request_options = {})
       response = get_rule_with_http_info(index_name, object_id, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::Rule')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::Rule")
     end
 
     # Retrieves an object with non-null index settings.
@@ -1461,7 +1504,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `get_settings`."
       end
 
-      path = '/1/indexes/{indexName}/settings'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -1470,7 +1513,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_settings',
+        :operation => :"SearchClient.get_settings",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1489,7 +1532,7 @@ module Algolia
     # @return [IndexSettings]
     def get_settings(index_name, request_options = {})
       response = get_settings_with_http_info(index_name, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::IndexSettings')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::IndexSettings")
     end
 
     # Retrieves all allowed IP addresses with access to your application.
@@ -1499,7 +1542,7 @@ module Algolia
     # @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 = {})
-      path = '/1/security/sources'
+      path = "/1/security/sources"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1508,7 +1551,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_sources',
+        :operation => :"SearchClient.get_sources",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1526,7 +1569,7 @@ module Algolia
     # @return [Array<Source>]
     def get_sources(request_options = {})
       response = get_sources_with_http_info(request_options)
-      @api_client.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
 
     # Retrieves a syonym by its ID. To find the object IDs for your synonyms, use the [&#x60;search&#x60; operation](#tag/Synonyms/operation/searchSynonyms).
@@ -1547,8 +1590,9 @@ module Algolia
         raise ArgumentError, "Parameter `object_id` is required when calling `get_synonym`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                  Transport.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 = {}
@@ -1557,7 +1601,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_synonym',
+        :operation => :"SearchClient.get_synonym",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1577,7 +1621,7 @@ module Algolia
     # @return [SynonymHit]
     def get_synonym(index_name, object_id, request_options = {})
       response = get_synonym_with_http_info(index_name, object_id, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SynonymHit')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SynonymHit")
     end
 
     # Checks the status of a given task.  Indexing tasks are asynchronous. When you add, update, or delete records or indices, a task is created on a queue and completed depending on the load on the server.  The indexing tasks&#39; responses include a task ID that you can use to check the status.
@@ -1598,8 +1642,9 @@ module Algolia
         raise ArgumentError, "Parameter `task_id` is required when calling `get_task`."
       end
 
-      path = '/1/indexes/{indexName}/task/{taskID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'taskID' + '}',
-                                                                                                                            Transport.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 = {}
@@ -1608,7 +1653,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_task',
+        :operation => :"SearchClient.get_task",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1628,7 +1673,7 @@ module Algolia
     # @return [GetTaskResponse]
     def get_task(index_name, task_id, request_options = {})
       response = get_task_with_http_info(index_name, task_id, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetTaskResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::GetTaskResponse")
     end
 
     # Get the IDs of the 10 users with the highest number of records per cluster.  Since it can take a few seconds to get the data from the different clusters, the response isn&#39;t real-time.
@@ -1638,7 +1683,7 @@ module Algolia
     # @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 = {})
-      path = '/1/clusters/mapping/top'
+      path = "/1/clusters/mapping/top"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1647,7 +1692,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_top_user_ids',
+        :operation => :"SearchClient.get_top_user_ids",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1665,7 +1710,7 @@ module Algolia
     # @return [GetTopUserIdsResponse]
     def get_top_user_ids(request_options = {})
       response = get_top_user_ids_with_http_info(request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::GetTopUserIdsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::GetTopUserIdsResponse")
     end
 
     # Returns the user ID data stored in the mapping.  Since it can take a few seconds to get the data from the different clusters, the response isn&#39;t real-time.
@@ -1683,10 +1728,13 @@ module Algolia
 
       pattern = /^[a-zA-Z0-9 \-*.]+$/
       if @api_client.config.client_side_validation && user_id !~ pattern
-        raise ArgumentError, "invalid value for 'user_id' when calling SearchClient.get_user_id, must conform to the pattern #{pattern}."
+        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' + '}', Transport.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 = {}
@@ -1695,7 +1743,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.get_user_id',
+        :operation => :"SearchClient.get_user_id",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1714,7 +1762,7 @@ module Algolia
     # @return [UserId]
     def get_user_id(user_id, request_options = {})
       response = get_user_id_with_http_info(user_id, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UserId')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UserId")
     end
 
     # 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.
@@ -1725,7 +1773,7 @@ module Algolia
     # @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 has_pending_mappings_with_http_info(get_clusters = nil, request_options = {})
-      path = '/1/clusters/mapping/pending'
+      path = "/1/clusters/mapping/pending"
       query_params = {}
       query_params[:getClusters] = get_clusters unless get_clusters.nil?
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
@@ -1735,7 +1783,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.has_pending_mappings',
+        :operation => :"SearchClient.has_pending_mappings",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1754,7 +1802,10 @@ module Algolia
     # @return [HasPendingMappingsResponse]
     def has_pending_mappings(get_clusters = nil, request_options = {})
       response = has_pending_mappings_with_http_info(get_clusters, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::HasPendingMappingsResponse')
+      @api_client.deserialize(
+        response.body,
+        request_options[:debug_return_type] || "Search::HasPendingMappingsResponse"
+      )
     end
 
     # Lists all API keys associated with your Algolia application, including their permissions and restrictions.
@@ -1764,7 +1815,7 @@ module Algolia
     # @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 = {})
-      path = '/1/keys'
+      path = "/1/keys"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1773,7 +1824,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.list_api_keys',
+        :operation => :"SearchClient.list_api_keys",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1791,7 +1842,7 @@ module Algolia
     # @return [ListApiKeysResponse]
     def list_api_keys(request_options = {})
       response = list_api_keys_with_http_info(request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ListApiKeysResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::ListApiKeysResponse")
     end
 
     # Lists the available clusters in a multi-cluster setup.
@@ -1801,7 +1852,7 @@ module Algolia
     # @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 = {})
-      path = '/1/clusters'
+      path = "/1/clusters"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1810,7 +1861,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.list_clusters',
+        :operation => :"SearchClient.list_clusters",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1828,7 +1879,7 @@ module Algolia
     # @return [ListClustersResponse]
     def list_clusters(request_options = {})
       response = list_clusters_with_http_info(request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ListClustersResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::ListClustersResponse")
     end
 
     # Lists all indices in the current Algolia application.  The request follows any index restrictions of the API key you use to make the request.
@@ -1841,10 +1892,13 @@ module Algolia
     # @return [Http::Response] the response
     def list_indices_with_http_info(page = nil, hits_per_page = nil, request_options = {})
       if @api_client.config.client_side_validation && !page.nil? && page < 0
-        raise ArgumentError, 'invalid value for ""page"" when calling SearchClient.list_indices, must be greater than or equal to 0.'
+        raise(
+          ArgumentError,
+          "invalid value for \"\"page\"\" when calling SearchClient.list_indices, must be greater than or equal to 0."
+        )
       end
 
-      path = '/1/indexes'
+      path = "/1/indexes"
       query_params = {}
       query_params[:page] = page unless page.nil?
       query_params[:hitsPerPage] = hits_per_page unless hits_per_page.nil?
@@ -1855,7 +1909,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.list_indices',
+        :operation => :"SearchClient.list_indices",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1875,7 +1929,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ListIndicesResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::ListIndicesResponse")
     end
 
     # Lists the userIDs assigned to a multi-cluster application.  Since it can take a few seconds to get the data from the different clusters, the response isn&#39;t real-time.
@@ -1888,10 +1942,13 @@ module Algolia
     # @return [Http::Response] the response
     def list_user_ids_with_http_info(page = nil, hits_per_page = nil, request_options = {})
       if @api_client.config.client_side_validation && !page.nil? && page < 0
-        raise ArgumentError, 'invalid value for ""page"" when calling SearchClient.list_user_ids, must be greater than or equal to 0.'
+        raise(
+          ArgumentError,
+          "invalid value for \"\"page\"\" when calling SearchClient.list_user_ids, must be greater than or equal to 0."
+        )
       end
 
-      path = '/1/clusters/mapping'
+      path = "/1/clusters/mapping"
       query_params = {}
       query_params[:page] = page unless page.nil?
       query_params[:hitsPerPage] = hits_per_page unless hits_per_page.nil?
@@ -1902,7 +1959,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.list_user_ids',
+        :operation => :"SearchClient.list_user_ids",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1922,7 +1979,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ListUserIdsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::ListUserIdsResponse")
     end
 
     # Adds, updates, or deletes records in multiple indices with a single API request.  - Actions are applied in the order they are specified. - Actions are equivalent to the individual API requests of the same name.
@@ -1936,7 +1993,7 @@ module Algolia
         raise ArgumentError, "Parameter `batch_params` is required when calling `multiple_batch`."
       end
 
-      path = '/1/indexes/*/batch'
+      path = "/1/indexes/*/batch"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -1945,7 +2002,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(batch_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.multiple_batch',
+        :operation => :"SearchClient.multiple_batch",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -1962,7 +2019,7 @@ module Algolia
     # @return [MultipleBatchResponse]
     def multiple_batch(batch_params, request_options = {})
       response = multiple_batch_with_http_info(batch_params, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::MultipleBatchResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::MultipleBatchResponse")
     end
 
     # Copies or moves (renames) an index within the same Algolia application.  - Existing destination indices are overwritten, except for their analytics data. - If the destination index doesn&#39;t exist yet, it&#39;ll be created.  **Copy**  - Copying a source index that doesn&#39;t exist creates a new index with 0 records and default settings. - The API keys of the source index are merged with the existing keys in the destination index. - You can&#39;t copy the &#x60;enableReRanking&#x60;, &#x60;mode&#x60;, and &#x60;replicas&#x60; settings. - You can&#39;t copy to a destination index that already has replicas. - Be aware of the [size limits](https://www.algolia.com/doc/guides/scaling/algolia-service-limits/#application-record-and-index-limits). - Related guide: [Copy indices](https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/how-to/copy-indices/)  **Move**  - Moving a source index that doesn&#39;t exist is ignored without returning an error. - When moving an index, the analytics data keep their original name and a new set of analytics data is started for the new name.   To access the original analytics in the dashboard, create an index with the original name. - If the destination index has replicas, moving will overwrite the existing index and copy the data to the replica indices. - Related guide: [Move indices](https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/how-to/move-indices/).
@@ -1983,7 +2040,7 @@ module Algolia
         raise ArgumentError, "Parameter `operation_index_params` is required when calling `operation_index`."
       end
 
-      path = '/1/indexes/{indexName}/operation'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -1992,7 +2049,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(operation_index_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.operation_index',
+        :operation => :"SearchClient.operation_index",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2012,7 +2069,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # Adds new attributes to a record, or update existing ones.  - If a record with the specified object ID doesn&#39;t exist,   a new record is added to the index **if** &#x60;createIfNotExists&#x60; is true. - If the index doesn&#39;t exist yet, this method creates a new index. - You can use any first-level attribute but not nested attributes.   If you specify a nested attribute, the engine treats it as a replacement for its first-level ancestor.
@@ -2025,7 +2082,13 @@ module Algolia
     # @param create_if_not_exists [Boolean] Whether to create a new record if it doesn&#39;t exist. (default to true)
     # @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 partial_update_object_with_http_info(index_name, object_id, attributes_to_update, create_if_not_exists = nil, request_options = {})
+    def partial_update_object_with_http_info(
+      index_name,
+      object_id,
+      attributes_to_update,
+      create_if_not_exists = 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 `partial_update_object`."
@@ -2039,8 +2102,9 @@ module Algolia
         raise ArgumentError, "Parameter `attributes_to_update` is required when calling `partial_update_object`."
       end
 
-      path = '/1/indexes/{indexName}/{objectID}/partial'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                 Transport.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?
@@ -2050,7 +2114,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(attributes_to_update)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.partial_update_object',
+        :operation => :"SearchClient.partial_update_object",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2070,9 +2134,24 @@ module Algolia
     # @param create_if_not_exists [Boolean] Whether to create a new record if it doesn&#39;t exist. (default to true)
     # @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 [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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::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
+      )
+      @api_client.deserialize(
+        response.body,
+        request_options[:debug_return_type] || "Search::UpdatedAtWithObjectIdResponse"
+      )
     end
 
     # Deletes a user ID and its associated data from the clusters.
@@ -2090,10 +2169,13 @@ module Algolia
 
       pattern = /^[a-zA-Z0-9 \-*.]+$/
       if @api_client.config.client_side_validation && user_id !~ pattern
-        raise ArgumentError, "invalid value for 'user_id' when calling SearchClient.remove_user_id, must conform to the pattern #{pattern}."
+        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' + '}', Transport.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 = {}
@@ -2102,7 +2184,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.remove_user_id',
+        :operation => :"SearchClient.remove_user_id",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2121,7 +2203,7 @@ module Algolia
     # @return [RemoveUserIdResponse]
     def remove_user_id(user_id, request_options = {})
       response = remove_user_id_with_http_info(user_id, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::RemoveUserIdResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::RemoveUserIdResponse")
     end
 
     # Replaces the list of allowed sources.
@@ -2137,7 +2219,7 @@ module Algolia
         raise ArgumentError, "Parameter `source` is required when calling `replace_sources`."
       end
 
-      path = '/1/security/sources'
+      path = "/1/security/sources"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2146,7 +2228,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(source)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.replace_sources',
+        :operation => :"SearchClient.replace_sources",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2165,7 +2247,7 @@ module Algolia
     # @return [ReplaceSourceResponse]
     def replace_sources(source, request_options = {})
       response = replace_sources_with_http_info(source, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::ReplaceSourceResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::ReplaceSourceResponse")
     end
 
     # Restores a deleted API key.  Restoring resets the &#x60;validity&#x60; attribute to &#x60;0&#x60;.  Algolia stores up to 1,000 API keys per application. If you create more, the oldest API keys are deleted and can&#39;t be restored.
@@ -2181,7 +2263,7 @@ module Algolia
         raise ArgumentError, "Parameter `key` is required when calling `restore_api_key`."
       end
 
-      path = '/1/keys/{key}/restore'.sub('{' + 'key' + '}', Transport.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 = {}
@@ -2190,7 +2272,7 @@ module Algolia
       post_body = request_options[:debug_body]
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.restore_api_key',
+        :operation => :"SearchClient.restore_api_key",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2209,7 +2291,7 @@ module Algolia
     # @return [AddApiKeyResponse]
     def restore_api_key(key, request_options = {})
       response = restore_api_key_with_http_info(key, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::AddApiKeyResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::AddApiKeyResponse")
     end
 
     # Adds a record to an index or replace it.  - If the record doesn&#39;t have an object ID, a new record with an auto-generated object ID is added to your index. - If a record with the specified object ID exists, the existing record is replaced. - If a record with the specified object ID doesn&#39;t exist, a new record is added to your index. - If you add a record to an index that doesn&#39;t exist yet, a new index is created.  To update _some_ attributes of a record, use the [&#x60;partial&#x60; operation](#tag/Records/operation/partial). To add, update, or replace multiple records, use the [&#x60;batch&#x60; operation](#tag/Records/operation/batch).
@@ -2230,7 +2312,7 @@ module Algolia
         raise ArgumentError, "Parameter `body` is required when calling `save_object`."
       end
 
-      path = '/1/indexes/{indexName}'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -2239,7 +2321,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(body)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.save_object',
+        :operation => :"SearchClient.save_object",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2259,7 +2341,7 @@ module Algolia
     # @return [SaveObjectResponse]
     def save_object(index_name, body, request_options = {})
       response = save_object_with_http_info(index_name, body, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SaveObjectResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SaveObjectResponse")
     end
 
     # If a rule with the specified object ID doesn&#39;t exist, it&#39;s created. Otherwise, the existing rule is replaced.  To create or update more than one rule, use the [&#x60;batch&#x60; operation](#tag/Rules/operation/saveRules).
@@ -2286,8 +2368,9 @@ module Algolia
         raise ArgumentError, "Parameter `rule` is required when calling `save_rule`."
       end
 
-      path = '/1/indexes/{indexName}/rules/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                               Transport.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?
@@ -2297,7 +2380,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(rule)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.save_rule',
+        :operation => :"SearchClient.save_rule",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2319,7 +2402,7 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedRuleResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedRuleResponse")
     end
 
     # Create or update multiple rules.  If a rule with the specified object ID doesn&#39;t exist, Algolia creates a new one. Otherwise, existing rules are replaced.
@@ -2332,7 +2415,13 @@ module Algolia
     # @param clear_existing_rules [Boolean] Whether existing rules should be deleted before adding this batch.
     # @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 save_rules_with_http_info(index_name, rules, forward_to_replicas = nil, clear_existing_rules = nil, request_options = {})
+    def save_rules_with_http_info(
+      index_name,
+      rules,
+      forward_to_replicas = nil,
+      clear_existing_rules = 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 `save_rules`."
@@ -2342,7 +2431,7 @@ module Algolia
         raise ArgumentError, "Parameter `rules` is required when calling `save_rules`."
       end
 
-      path = '/1/indexes/{indexName}/rules/batch'.sub('{' + 'indexName' + '}', Transport.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?
@@ -2353,7 +2442,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(rules)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.save_rules',
+        :operation => :"SearchClient.save_rules",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2374,8 +2463,14 @@ module Algolia
     # @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 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      response = save_rules_with_http_info(
+        index_name,
+        rules,
+        forward_to_replicas,
+        clear_existing_rules,
+        request_options
+      )
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # If a synonym with the specified object ID doesn&#39;t exist, Algolia adds a new one. Otherwise, the existing synonym is replaced. To add multiple synonyms in a single API request, use the [&#x60;batch&#x60; operation](#tag/Synonyms/operation/saveSynonyms).
@@ -2402,8 +2497,9 @@ module Algolia
         raise ArgumentError, "Parameter `synonym_hit` is required when calling `save_synonym`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/{objectID}'.sub('{' + 'indexName' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'objectID' + '}',
-                                                                                                                                  Transport.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?
@@ -2413,7 +2509,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(synonym_hit)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.save_synonym',
+        :operation => :"SearchClient.save_synonym",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2435,7 +2531,7 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SaveSynonymResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SaveSynonymResponse")
     end
 
     # If a synonym with the &#x60;objectID&#x60; doesn&#39;t exist, Algolia adds a new one. Otherwise, existing synonyms are replaced.
@@ -2448,7 +2544,13 @@ module Algolia
     # @param replace_existing_synonyms [Boolean] Whether to replace all synonyms in the index with the ones sent with this request.
     # @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 save_synonyms_with_http_info(index_name, synonym_hit, forward_to_replicas = nil, replace_existing_synonyms = nil, request_options = {})
+    def save_synonyms_with_http_info(
+      index_name,
+      synonym_hit,
+      forward_to_replicas = nil,
+      replace_existing_synonyms = 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 `save_synonyms`."
@@ -2458,7 +2560,7 @@ module Algolia
         raise ArgumentError, "Parameter `synonym_hit` is required when calling `save_synonyms`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/batch'.sub('{' + 'indexName' + '}', Transport.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?
@@ -2469,7 +2571,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(synonym_hit)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.save_synonyms',
+        :operation => :"SearchClient.save_synonyms",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2489,9 +2591,21 @@ module Algolia
     # @param replace_existing_synonyms [Boolean] Whether to replace all synonyms in the index with the ones sent with this request.
     # @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 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::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
+      )
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # Sends multiple search request to one or more indices.  This can be useful in these cases:  - Different indices for different purposes, such as, one index for products, another one for marketing content. - Multiple searches to the same index—for example, with different filters.
@@ -2507,7 +2621,7 @@ module Algolia
         raise ArgumentError, "Parameter `search_method_params` is required when calling `search`."
       end
 
-      path = '/1/indexes/*/queries'
+      path = "/1/indexes/*/queries"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2516,7 +2630,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(search_method_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.search',
+        :operation => :"SearchClient.search",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2535,7 +2649,7 @@ module Algolia
     # @return [SearchResponses]
     def search(search_method_params, request_options = {})
       response = search_with_http_info(search_method_params, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchResponses')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SearchResponses")
     end
 
     # Searches for standard and custom dictionary entries.
@@ -2546,17 +2660,27 @@ module Algolia
     # @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 [Http::Response] the response
-    def search_dictionary_entries_with_http_info(dictionary_name, search_dictionary_entries_params, request_options = {})
+    def search_dictionary_entries_with_http_info(
+      dictionary_name,
+      search_dictionary_entries_params,
+      request_options = {}
+    )
       # verify the required parameter 'dictionary_name' is set
       if @api_client.config.client_side_validation && dictionary_name.nil?
         raise ArgumentError, "Parameter `dictionary_name` is required when calling `search_dictionary_entries`."
       end
       # verify the required parameter 'search_dictionary_entries_params' is set
       if @api_client.config.client_side_validation && search_dictionary_entries_params.nil?
-        raise ArgumentError, "Parameter `search_dictionary_entries_params` is required when calling `search_dictionary_entries`."
+        raise(
+          ArgumentError,
+          "Parameter `search_dictionary_entries_params` is required when calling `search_dictionary_entries`."
+        )
       end
 
-      path = '/1/dictionaries/{dictionaryName}/search'.sub('{' + 'dictionaryName' + '}', Transport.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 = {}
@@ -2565,7 +2689,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(search_dictionary_entries_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.search_dictionary_entries',
+        :operation => :"SearchClient.search_dictionary_entries",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2584,8 +2708,15 @@ module Algolia
     # @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 [SearchDictionaryEntriesResponse]
     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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchDictionaryEntriesResponse')
+      response = search_dictionary_entries_with_http_info(
+        dictionary_name,
+        search_dictionary_entries_params,
+        request_options
+      )
+      @api_client.deserialize(
+        response.body,
+        request_options[:debug_return_type] || "Search::SearchDictionaryEntriesResponse"
+      )
     end
 
     # Searches for values of a specified facet attribute.  - By default, facet values are sorted by decreasing count.   You can adjust this with the &#x60;sortFacetValueBy&#x60; parameter. - Searching for facet values doesn&#39;t work if you have **more than 65 searchable facets and searchable attributes combined**.
@@ -2597,7 +2728,12 @@ module Algolia
     # @param search_for_facet_values_request [SearchForFacetValuesRequest]
     # @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_for_facet_values_with_http_info(index_name, facet_name, search_for_facet_values_request = nil, request_options = {})
+    def search_for_facet_values_with_http_info(
+      index_name,
+      facet_name,
+      search_for_facet_values_request = 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_for_facet_values`."
@@ -2607,8 +2743,9 @@ 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' + '}', Transport.encode_uri(index_name.to_s)).sub('{' + 'facetName' + '}',
-                                                                                                                                       Transport.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 = {}
@@ -2617,7 +2754,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(search_for_facet_values_request)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.search_for_facet_values',
+        :operation => :"SearchClient.search_for_facet_values",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2637,8 +2774,16 @@ module Algolia
     # @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 [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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchForFacetValuesResponse')
+      response = search_for_facet_values_with_http_info(
+        index_name,
+        facet_name,
+        search_for_facet_values_request,
+        request_options
+      )
+      @api_client.deserialize(
+        response.body,
+        request_options[:debug_return_type] || "Search::SearchForFacetValuesResponse"
+      )
     end
 
     # Searches for rules in your index.
@@ -2655,7 +2800,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `search_rules`."
       end
 
-      path = '/1/indexes/{indexName}/rules/search'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -2664,7 +2809,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(search_rules_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.search_rules',
+        :operation => :"SearchClient.search_rules",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2684,7 +2829,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchRulesResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SearchRulesResponse")
     end
 
     # Searches a single index and return matching search results (_hits_).  This method lets you retrieve up to 1,000 hits. If you need more, use the [&#x60;browse&#x60; operation](#tag/Search/operation/browse) or increase the &#x60;paginatedLimitedTo&#x60; index setting.
@@ -2701,7 +2846,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `search_single_index`."
       end
 
-      path = '/1/indexes/{indexName}/query'.sub('{' + 'indexName' + '}', Transport.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 = {}
@@ -2710,7 +2855,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(search_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.search_single_index',
+        :operation => :"SearchClient.search_single_index",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2730,7 +2875,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SearchResponse")
     end
 
     # Searches for synonyms in your index.
@@ -2747,7 +2892,10 @@ module Algolia
         raise ArgumentError, "Parameter `index_name` is required when calling `search_synonyms`."
       end
 
-      path = '/1/indexes/{indexName}/synonyms/search'.sub('{' + 'indexName' + '}', Transport.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 = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2756,7 +2904,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(search_synonyms_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.search_synonyms',
+        :operation => :"SearchClient.search_synonyms",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2776,7 +2924,7 @@ module Algolia
     # @return [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')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SearchSynonymsResponse")
     end
 
     # Since it can take 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).
@@ -2792,7 +2940,7 @@ module Algolia
         raise ArgumentError, "Parameter `search_user_ids_params` is required when calling `search_user_ids`."
       end
 
-      path = '/1/clusters/mapping/search'
+      path = "/1/clusters/mapping/search"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2801,7 +2949,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(search_user_ids_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.search_user_ids',
+        :operation => :"SearchClient.search_user_ids",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2820,7 +2968,7 @@ module Algolia
     # @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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::SearchUserIdsResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::SearchUserIdsResponse")
     end
 
     # Turns standard stop word dictionary entries on or off for a given language.
@@ -2833,10 +2981,13 @@ module Algolia
     def set_dictionary_settings_with_http_info(dictionary_settings_params, request_options = {})
       # verify the required parameter 'dictionary_settings_params' is set
       if @api_client.config.client_side_validation && dictionary_settings_params.nil?
-        raise ArgumentError, "Parameter `dictionary_settings_params` is required when calling `set_dictionary_settings`."
+        raise(
+          ArgumentError,
+          "Parameter `dictionary_settings_params` is required when calling `set_dictionary_settings`."
+        )
       end
 
-      path = '/1/dictionaries/*/settings'
+      path = "/1/dictionaries/*/settings"
       query_params = {}
       query_params = query_params.merge(request_options[:query_params]) unless request_options[:query_params].nil?
       header_params = {}
@@ -2845,7 +2996,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(dictionary_settings_params)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.set_dictionary_settings',
+        :operation => :"SearchClient.set_dictionary_settings",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2864,7 +3015,7 @@ module Algolia
     # @return [UpdatedAtResponse]
     def set_dictionary_settings(dictionary_settings_params, request_options = {})
       response = set_dictionary_settings_with_http_info(dictionary_settings_params, request_options)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # Update the specified index settings.  Index settings that you don&#39;t specify are left unchanged. Specify &#x60;null&#x60; to reset a setting to its default value.  For best performance, update the index settings before you add new records to your index.
@@ -2886,7 +3037,7 @@ module Algolia
         raise ArgumentError, "Parameter `index_settings` is required when calling `set_settings`."
       end
 
-      path = '/1/indexes/{indexName}/settings'.sub('{' + 'indexName' + '}', Transport.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?
@@ -2896,7 +3047,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(index_settings)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.set_settings',
+        :operation => :"SearchClient.set_settings",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2917,7 +3068,7 @@ 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)
-      @api_client.deserialize(response.body, request_options[:debug_return_type] || 'Search::UpdatedAtResponse')
+      @api_client.deserialize(response.body, request_options[:debug_return_type] || "Search::UpdatedAtResponse")
     end
 
     # Replaces the permissions of an existing API key.  Any unspecified attribute resets that attribute to its default value.
@@ -2938,7 +3089,7 @@ module Algolia
         raise ArgumentError, "Parameter `api_key` is required when calling `update_api_key`."
       end
 
-      path = '/1/keys/{key}'.sub('{' + 'key' + '}', Transport.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 = {}
@@ -2947,7 +3098,7 @@ module Algolia
       post_body = request_options[:debug_body] || @api_client.object_to_http_body(api_key)
 
       new_options = request_options.merge(
-        :operation => :'SearchClient.update_api_key',
+        :operation => :"SearchClient.update_api_key",
         :header_params => header_params,
         :query_params => query_params,
         :body => post_body,
@@ -2967,7 +3118,7 @@ module Algolia
     # @return [UpdateApiKeyResponse]
     def update_api_key(key, api_key, request_options = {})
       response = update_api_key_with_http_info(key, api_key, request_options)
-      @api_client.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`.
@@ -2978,17 +3129,24 @@ module Algolia
     # @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 = {})
+    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'
+        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
 
@@ -2999,48 +3157,56 @@ module Algolia
     # @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_app_task(task_id, max_retries = 50, timeout = ->(retry_count) { [retry_count * 200, 5000].min }, request_options = {})
+    def wait_for_app_task(
+      task_id,
+      max_retries = 50,
+      timeout = -> (retry_count) { [retry_count * 200, 5000].min },
+      request_options = {}
+    )
       retries = 0
       while retries < max_retries
         res = get_app_task(task_id, request_options)
-        if res.status == 'published'
+        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 operation [String] the `operation` that was done on a `key`.
     # @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 = {})
+    def wait_for_api_key(
+      key,
+      operation,
+      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?
-
+      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
+          updated_key = get_api_key(key, request_options)
+          updated_key_hash = updated_key.to_hash
+          equals = true
+          api_key.to_hash.each do |k, v|
+            equals &&= updated_key_hash[k] == v
           end
 
+          return updated_key if equals
+
           retries += 1
           sleep(timeout.call(retries) / 1000.0)
         end
@@ -3051,13 +3217,19 @@ module Algolia
       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
+          return res if operation == "add"
+        rescue AlgoliaHttpError => e
+          if e.code == 404
+            return nil if operation == "delete"
+          else
+            raise e
+          end
         end
+
         retries += 1
         sleep(timeout.call(retries) / 1000.0)
       end
+
       raise ApiError, "The maximum number of retries exceeded. (#{max_retries})"
     end
 
@@ -3078,6 +3250,7 @@ module Algolia
         else
           hits.concat(res.hits)
         end
+
         browse_params.cursor = res.cursor
         break if browse_params.cursor.nil?
       end
@@ -3091,7 +3264,12 @@ module Algolia
     # @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)
+    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)
@@ -3102,6 +3280,7 @@ module Algolia
         else
           rules.concat(res.hits)
         end
+
         search_rules_params.page += 1
         break if res.nb_hits < search_rules_params.hits_per_page
       end
@@ -3115,7 +3294,12 @@ module Algolia
     # @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)
+    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)
@@ -3126,6 +3310,7 @@ module Algolia
         else
           synonyms.concat(res.hits)
         end
+
         search_synonyms_params.page += 1
         break if res.nb_hits < search_synonyms_params.hits_per_page
       end
@@ -3149,12 +3334,17 @@ module Algolia
         restrictions.delete(:searchParams)
       end
 
-      url_encoded_restrictions = Algolia::Transport.stringify_query_params(restrictions).sort.to_h.map do |key, value|
-        "#{key}=#{value}"
-      end.join('&')
+      url_encoded_restrictions = Algolia::Transport
+        .stringify_query_params(restrictions)
+        .sort
+        .to_h
+        .map do |key, value|
+          "#{key}=#{value}"
+        end
+        .join("&")
 
-      hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), parent_api_key, url_encoded_restrictions)
-      Base64.encode64("#{hmac}#{url_encoded_restrictions}").gsub("\n", '')
+      hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), parent_api_key, url_encoded_restrictions)
+      Base64.encode64("#{hmac}#{url_encoded_restrictions}").gsub("\n", "")
     end
 
     # Helper: Retrieves the remaining validity of the previous generated `secured_api_key`, the `validUntil` parameter must have been provided.
@@ -3164,13 +3354,13 @@ module Algolia
     # @return [Integer]
     #
     def get_secured_api_key_remaining_validity(secured_api_key)
-      now         = Time.now.to_i
+      now = Time.now.to_i
       decoded_key = Base64.decode64(secured_api_key)
-      regex       = 'validUntil=(\d+)'
-      matches     = decoded_key.match(regex)
+      regex = "validUntil=(\\d+)"
+      matches = decoded_key.match(regex)
 
       if matches.nil?
-        raise AlgoliaError, 'The SecuredApiKey doesn\'t have a validUntil parameter.'
+        raise AlgoliaError, "The SecuredApiKey doesn't have a validUntil parameter."
       end
 
       valid_until = matches[1].to_i
@@ -3208,7 +3398,7 @@ module Algolia
     def delete_objects(index_name, object_ids, request_options = {})
       chunked_batch(
         index_name,
-        object_ids.map { |id| { "objectID" => id } },
+        object_ids.map { |id| {"objectID" => id} },
         Search::Action::DELETE_OBJECT,
         false,
         1000,
@@ -3247,7 +3437,14 @@ module Algolia
     #
     # @return [Array<BatchResponse>]
     #
-    def chunked_batch(index_name, objects, action = Action::ADD_OBJECT, wait_for_tasks = false, batch_size = 1000, request_options = {})
+    def chunked_batch(
+      index_name,
+      objects,
+      action = Action::ADD_OBJECT,
+      wait_for_tasks = false,
+      batch_size = 1000,
+      request_options = {}
+    )
       responses = []
       objects.each_slice(batch_size) do |chunk|
         requests = chunk.map do |object|
@@ -3275,7 +3472,7 @@ module Algolia
     #
     # @return [Array<ReplaceAllObjectsResponse>]
     def replace_all_objects(index_name, objects, batch_size = 1000, request_options = {})
-      tmp_index_name = index_name + '_tmp_' + rand(10_000_000).to_s
+      tmp_index_name = index_name + "_tmp_" + rand(10_000_000).to_s
 
       copy_operation_response = operation_index(
         index_name,
@@ -3284,8 +3481,8 @@ module Algolia
           destination: tmp_index_name,
           scope: [
             Search::ScopeType::SETTINGS,
-            Search::ScopeType::SYNONYMS,
-            Search::ScopeType::RULES
+            Search::ScopeType::RULES,
+            Search::ScopeType::SYNONYMS
           ]
         ),
         request_options
@@ -3309,8 +3506,8 @@ module Algolia
           destination: tmp_index_name,
           scope: [
             Search::ScopeType::SETTINGS,
-            Search::ScopeType::SYNONYMS,
-            Search::ScopeType::RULES
+            Search::ScopeType::RULES,
+            Search::ScopeType::SYNONYMS
           ]
         ),
         request_options