@algolia/client-search 5.55.1 → 5.56.0

package/dist/builds/worker.js

@@ -13,7 +13,7 @@ import {
   shuffle,
   validateRequired
 } from "@algolia/client-common";
-var apiClientVersion = "5.55.1";
+var apiClientVersion = "5.56.0";
 function getDefaultHosts(appId) {
   return [
     {
@@ -580,6 +580,32 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Creates a new API key with specific permissions and restrictions.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param apiKey - The apiKey object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see addApiKey for the plain version.
+     */
+    addApiKeyWithHTTPInfo(apiKey, requestOptions) {
+      validateRequired("apiKey", "addApiKeyWithHTTPInfo", apiKey);
+      validateRequired("apiKey.acl", "addApiKeyWithHTTPInfo", apiKey.acl);
+      const requestPath = "/1/keys";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: apiKey
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * If a record with the specified object ID exists, the existing record is replaced. Otherwise, a new record is added to the index.  If you want to use auto-generated object IDs, use the [`saveObject` operation](https://www.algolia.com/doc/rest-api/search/save-object). To update _some_ attributes of an existing record, use the [`partial` operation](https://www.algolia.com/doc/rest-api/search/partial-update-object) instead. To add, update, or replace multiple records, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/batch).
      *
@@ -607,6 +633,36 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * If a record with the specified object ID exists, the existing record is replaced. Otherwise, a new record is added to the index.  If you want to use auto-generated object IDs, use the [`saveObject` operation](https://www.algolia.com/doc/rest-api/search/save-object). To update _some_ attributes of an existing record, use the [`partial` operation](https://www.algolia.com/doc/rest-api/search/partial-update-object) instead. To add, update, or replace multiple records, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/batch).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     * @param addOrUpdateObject - The addOrUpdateObject object.
+     * @param addOrUpdateObject.indexName - Name of the index on which to perform the operation.
+     * @param addOrUpdateObject.objectID - Unique record identifier.
+     * @param addOrUpdateObject.body - The record. A schemaless object with attributes that are useful in the context of search and discovery.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see addOrUpdateObject for the plain version.
+     */
+    addOrUpdateObjectWithHTTPInfo({ indexName, objectID, body }, requestOptions) {
+      validateRequired("indexName", "addOrUpdateObjectWithHTTPInfo", indexName);
+      validateRequired("objectID", "addOrUpdateObjectWithHTTPInfo", objectID);
+      validateRequired("body", "addOrUpdateObjectWithHTTPInfo", body);
+      const requestPath = "/1/indexes/{indexName}/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: body
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Adds a source to the list of allowed sources.
      *
@@ -630,6 +686,32 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Adds a source to the list of allowed sources.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param source - Source to add.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see appendSource for the plain version.
+     */
+    appendSourceWithHTTPInfo(source, requestOptions) {
+      validateRequired("source", "appendSourceWithHTTPInfo", source);
+      validateRequired("source.source", "appendSourceWithHTTPInfo", source.source);
+      const requestPath = "/1/security/sources/append";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: source
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * 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.
      *
@@ -661,6 +743,40 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * 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.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     *
+     * @deprecated
+     * @param assignUserId - The assignUserId object.
+     * @param assignUserId.xAlgoliaUserID - Unique identifier of the user who makes the search request.
+     * @param assignUserId.assignUserIdParams - The assignUserIdParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see assignUserId for the plain version.
+     */
+    assignUserIdWithHTTPInfo({ xAlgoliaUserID, assignUserIdParams }, requestOptions) {
+      validateRequired("xAlgoliaUserID", "assignUserIdWithHTTPInfo", xAlgoliaUserID);
+      validateRequired("assignUserIdParams", "assignUserIdWithHTTPInfo", assignUserIdParams);
+      validateRequired("assignUserIdParams.cluster", "assignUserIdWithHTTPInfo", assignUserIdParams.cluster);
+      const requestPath = "/1/clusters/mapping";
+      const headers = {};
+      const queryParameters = {};
+      if (xAlgoliaUserID !== void 0) {
+        headers["X-Algolia-User-ID"] = xAlgoliaUserID.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: assignUserIdParams
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * 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\'re specified. - Actions are equivalent to the individual API requests of the same name.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
@@ -687,6 +803,35 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * 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\'re specified. - Actions are equivalent to the individual API requests of the same name.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     * @param batch - The batch object.
+     * @param batch.indexName - Name of the index on which to perform the operation.
+     * @param batch.batchWriteParams - The batchWriteParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see batch for the plain version.
+     */
+    batchWithHTTPInfo({ indexName, batchWriteParams }, requestOptions) {
+      validateRequired("indexName", "batchWithHTTPInfo", indexName);
+      validateRequired("batchWriteParams", "batchWithHTTPInfo", batchWriteParams);
+      validateRequired("batchWriteParams.requests", "batchWithHTTPInfo", batchWriteParams.requests);
+      const requestPath = "/1/indexes/{indexName}/batch".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: batchWriteParams
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Assigns multiple user IDs to a cluster.  **You can\'t move users with this operation**.
      *
@@ -719,6 +864,49 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Assigns multiple user IDs to a cluster.  **You can\'t move users with this operation**.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     *
+     * @deprecated
+     * @param batchAssignUserIds - The batchAssignUserIds object.
+     * @param batchAssignUserIds.xAlgoliaUserID - Unique identifier of the user who makes the search request.
+     * @param batchAssignUserIds.batchAssignUserIdsParams - The batchAssignUserIdsParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see batchAssignUserIds for the plain version.
+     */
+    batchAssignUserIdsWithHTTPInfo({ xAlgoliaUserID, batchAssignUserIdsParams }, requestOptions) {
+      validateRequired("xAlgoliaUserID", "batchAssignUserIdsWithHTTPInfo", xAlgoliaUserID);
+      validateRequired("batchAssignUserIdsParams", "batchAssignUserIdsWithHTTPInfo", batchAssignUserIdsParams);
+      validateRequired(
+        "batchAssignUserIdsParams.cluster",
+        "batchAssignUserIdsWithHTTPInfo",
+        batchAssignUserIdsParams.cluster
+      );
+      validateRequired(
+        "batchAssignUserIdsParams.users",
+        "batchAssignUserIdsWithHTTPInfo",
+        batchAssignUserIdsParams.users
+      );
+      const requestPath = "/1/clusters/mapping/batch";
+      const headers = {};
+      const queryParameters = {};
+      if (xAlgoliaUserID !== void 0) {
+        headers["X-Algolia-User-ID"] = xAlgoliaUserID.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: batchAssignUserIdsParams
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Adds or deletes multiple entries from your plurals, segmentation, or stop word dictionaries.
      *
@@ -752,6 +940,46 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Adds or deletes multiple entries from your plurals, segmentation, or stop word dictionaries.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param batchDictionaryEntries - The batchDictionaryEntries object.
+     * @param batchDictionaryEntries.dictionaryName - Dictionary type in which to search.
+     * @param batchDictionaryEntries.batchDictionaryEntriesParams - The batchDictionaryEntriesParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see batchDictionaryEntries for the plain version.
+     */
+    batchDictionaryEntriesWithHTTPInfo({ dictionaryName, batchDictionaryEntriesParams }, requestOptions) {
+      validateRequired("dictionaryName", "batchDictionaryEntriesWithHTTPInfo", dictionaryName);
+      validateRequired(
+        "batchDictionaryEntriesParams",
+        "batchDictionaryEntriesWithHTTPInfo",
+        batchDictionaryEntriesParams
+      );
+      validateRequired(
+        "batchDictionaryEntriesParams.requests",
+        "batchDictionaryEntriesWithHTTPInfo",
+        batchDictionaryEntriesParams.requests
+      );
+      const requestPath = "/1/dictionaries/{dictionaryName}/batch".replace(
+        "{dictionaryName}",
+        encodeURIComponent(dictionaryName)
+      );
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: batchDictionaryEntriesParams
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Retrieves records from an index, up to 1,000 per request.  Searching returns _hits_ (records augmented with highlighting and ranking details). Browsing returns matching records only. Use browse 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, or 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` evaluate to `true`)  If you send these parameters with your browse requests, they\'re ignored.
      *
@@ -777,6 +1005,34 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Retrieves records from an index, up to 1,000 per request.  Searching returns _hits_ (records augmented with highlighting and ranking details). Browsing returns matching records only. Use browse 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, or 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` evaluate to `true`)  If you send these parameters with your browse requests, they\'re ignored.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - browse
+     * @param browse - The browse object.
+     * @param browse.indexName - Name of the index on which to perform the operation.
+     * @param browse.browseParams - The browseParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see browse for the plain version.
+     */
+    browseWithHTTPInfo({ indexName, browseParams }, requestOptions) {
+      validateRequired("indexName", "browseWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}/browse".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: browseParams ? browseParams : {},
+        useReadTransporter: true
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes only the records from an index while keeping settings, synonyms, and rules. This operation is resource-intensive and subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
@@ -799,6 +1055,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Deletes only the records from an index while keeping settings, synonyms, and rules. This operation is resource-intensive and subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - deleteIndex
+     * @param clearObjects - The clearObjects object.
+     * @param clearObjects.indexName - Name of the index on which to perform the operation.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see clearObjects for the plain version.
+     */
+    clearObjectsWithHTTPInfo({ indexName }, requestOptions) {
+      validateRequired("indexName", "clearObjectsWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}/clear".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes all rules from the index.
      *
@@ -826,18 +1107,21 @@ function createSearchClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Deletes all synonyms from the index.
+     * Deletes all rules from the index.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - editSettings
-     * @param clearSynonyms - The clearSynonyms object.
-     * @param clearSynonyms.indexName - Name of the index on which to perform the operation.
-     * @param clearSynonyms.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param clearRules - The clearRules object.
+     * @param clearRules.indexName - Name of the index on which to perform the operation.
+     * @param clearRules.forwardToReplicas - Whether changes are applied to replica indices.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see clearRules for the plain version.
      */
-    clearSynonyms({ indexName, forwardToReplicas }, requestOptions) {
-      validateRequired("indexName", "clearSynonyms", indexName);
-      const requestPath = "/1/indexes/{indexName}/synonyms/clear".replace("{indexName}", encodeURIComponent(indexName));
+    clearRulesWithHTTPInfo({ indexName, forwardToReplicas }, requestOptions) {
+      validateRequired("indexName", "clearRulesWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}/rules/clear".replace("{indexName}", encodeURIComponent(indexName));
       const headers = {};
       const queryParameters = {};
       if (forwardToReplicas !== void 0) {
@@ -849,22 +1133,28 @@ function createSearchClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * This method lets you send requests to the Algolia REST API.
-     * @param customDelete - The customDelete object.
-     * @param customDelete.path - Path of the endpoint, for example `1/newFeature`.
-     * @param customDelete.parameters - Query parameters to apply to the current query.
+     * Deletes all synonyms from the index.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param clearSynonyms - The clearSynonyms object.
+     * @param clearSynonyms.indexName - Name of the index on which to perform the operation.
+     * @param clearSynonyms.forwardToReplicas - Whether changes are applied to replica indices.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
      */
-    customDelete({ path, parameters }, requestOptions) {
-      validateRequired("path", "customDelete", path);
-      const requestPath = "/{path}".replace("{path}", path);
+    clearSynonyms({ indexName, forwardToReplicas }, requestOptions) {
+      validateRequired("indexName", "clearSynonyms", indexName);
+      const requestPath = "/1/indexes/{indexName}/synonyms/clear".replace("{indexName}", encodeURIComponent(indexName));
       const headers = {};
-      const queryParameters = parameters ? parameters : {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
       const request = {
-        method: "DELETE",
+        method: "POST",
         path: requestPath,
         queryParameters,
         headers
@@ -872,7 +1162,79 @@ function createSearchClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * This method lets you send requests to the Algolia REST API.
+     * Deletes all synonyms from the index.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param clearSynonyms - The clearSynonyms object.
+     * @param clearSynonyms.indexName - Name of the index on which to perform the operation.
+     * @param clearSynonyms.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see clearSynonyms for the plain version.
+     */
+    clearSynonymsWithHTTPInfo({ indexName, forwardToReplicas }, requestOptions) {
+      validateRequired("indexName", "clearSynonymsWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}/synonyms/clear".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     * @param customDelete - The customDelete object.
+     * @param customDelete.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customDelete.parameters - Query parameters to apply to the current query.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    customDelete({ path, parameters }, requestOptions) {
+      validateRequired("path", "customDelete", path);
+      const requestPath = "/{path}".replace("{path}", path);
+      const headers = {};
+      const queryParameters = parameters ? parameters : {};
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     * @param customDelete - The customDelete object.
+     * @param customDelete.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customDelete.parameters - Query parameters to apply to the current query.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see customDelete for the plain version.
+     */
+    customDeleteWithHTTPInfo({ path, parameters }, requestOptions) {
+      validateRequired("path", "customDeleteWithHTTPInfo", path);
+      const requestPath = "/{path}".replace("{path}", path);
+      const headers = {};
+      const queryParameters = parameters ? parameters : {};
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * This method lets you send requests to the Algolia REST API.
      * @param customGet - The customGet object.
      * @param customGet.path - Path of the endpoint, for example `1/newFeature`.
      * @param customGet.parameters - Query parameters to apply to the current query.
@@ -891,6 +1253,29 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     * @param customGet - The customGet object.
+     * @param customGet.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customGet.parameters - Query parameters to apply to the current query.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see customGet for the plain version.
+     */
+    customGetWithHTTPInfo({ path, parameters }, requestOptions) {
+      validateRequired("path", "customGetWithHTTPInfo", path);
+      const requestPath = "/{path}".replace("{path}", path);
+      const headers = {};
+      const queryParameters = parameters ? parameters : {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * This method lets you send requests to the Algolia REST API.
      * @param customPost - The customPost object.
@@ -913,6 +1298,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     * @param customPost - The customPost object.
+     * @param customPost.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customPost.parameters - Query parameters to apply to the current query.
+     * @param customPost.body - Parameters to send with the custom request.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see customPost for the plain version.
+     */
+    customPostWithHTTPInfo({ path, parameters, body }, requestOptions) {
+      validateRequired("path", "customPostWithHTTPInfo", path);
+      const requestPath = "/{path}".replace("{path}", path);
+      const headers = {};
+      const queryParameters = parameters ? parameters : {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: body ? body : {}
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * This method lets you send requests to the Algolia REST API.
      * @param customPut - The customPut object.
@@ -935,6 +1345,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     * @param customPut - The customPut object.
+     * @param customPut.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customPut.parameters - Query parameters to apply to the current query.
+     * @param customPut.body - Parameters to send with the custom request.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see customPut for the plain version.
+     */
+    customPutWithHTTPInfo({ path, parameters, body }, requestOptions) {
+      validateRequired("path", "customPutWithHTTPInfo", path);
+      const requestPath = "/{path}".replace("{path}", path);
+      const headers = {};
+      const queryParameters = parameters ? parameters : {};
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: body ? body : {}
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes the API key.
      *
@@ -957,6 +1392,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Deletes the API key.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param deleteApiKey - The deleteApiKey object.
+     * @param deleteApiKey.key - API key.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see deleteApiKey for the plain version.
+     */
+    deleteApiKeyWithHTTPInfo({ key }, requestOptions) {
+      validateRequired("key", "deleteApiKeyWithHTTPInfo", key);
+      const requestPath = "/1/keys/{key}".replace("{key}", encodeURIComponent(key));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * This operation doesn\'t accept empty filters.  This operation is resource-intensive. Use it only if you can\'t get the object IDs of the records you want to delete. It\'s more efficient to get a list of object IDs with the [`browse` operation](https://www.algolia.com/doc/rest-api/search/browse), and then delete the records using the [`batch` operation](https://www.algolia.com/doc/rest-api/search/batch).  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
@@ -982,6 +1442,34 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * This operation doesn\'t accept empty filters.  This operation is resource-intensive. Use it only if you can\'t get the object IDs of the records you want to delete. It\'s more efficient to get a list of object IDs with the [`browse` operation](https://www.algolia.com/doc/rest-api/search/browse), and then delete the records using the [`batch` operation](https://www.algolia.com/doc/rest-api/search/batch).  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - deleteIndex
+     * @param deleteBy - The deleteBy object.
+     * @param deleteBy.indexName - Name of the index on which to perform the operation.
+     * @param deleteBy.deleteByParams - The deleteByParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see deleteBy for the plain version.
+     */
+    deleteByWithHTTPInfo({ indexName, deleteByParams }, requestOptions) {
+      validateRequired("indexName", "deleteByWithHTTPInfo", indexName);
+      validateRequired("deleteByParams", "deleteByWithHTTPInfo", deleteByParams);
+      const requestPath = "/1/indexes/{indexName}/deleteByQuery".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: deleteByParams
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes an index and all its settings.  - Deleting an index doesn\'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).
      *
@@ -1004,6 +1492,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Deletes an index and all its settings.  - Deleting an index doesn\'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).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - deleteIndex
+     * @param deleteIndex - The deleteIndex object.
+     * @param deleteIndex.indexName - Name of the index on which to perform the operation.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see deleteIndex for the plain version.
+     */
+    deleteIndexWithHTTPInfo({ indexName }, requestOptions) {
+      validateRequired("indexName", "deleteIndexWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes a record by its object ID.  To delete more than one record, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/batch). To delete records matching a query, use the [`deleteBy` operation](https://www.algolia.com/doc/rest-api/search/delete-by).
      *
@@ -1028,6 +1541,33 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Deletes a record by its object ID.  To delete more than one record, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/batch). To delete records matching a query, use the [`deleteBy` operation](https://www.algolia.com/doc/rest-api/search/delete-by).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - deleteObject
+     * @param deleteObject - The deleteObject object.
+     * @param deleteObject.indexName - Name of the index on which to perform the operation.
+     * @param deleteObject.objectID - Unique record identifier.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see deleteObject for the plain version.
+     */
+    deleteObjectWithHTTPInfo({ indexName, objectID }, requestOptions) {
+      validateRequired("indexName", "deleteObjectWithHTTPInfo", indexName);
+      validateRequired("objectID", "deleteObjectWithHTTPInfo", objectID);
+      const requestPath = "/1/indexes/{indexName}/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes a rule by its ID. To find the object ID for rules, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-rules).
      *
@@ -1056,6 +1596,37 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Deletes a rule by its ID. To find the object ID for rules, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-rules).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param deleteRule - The deleteRule object.
+     * @param deleteRule.indexName - Name of the index on which to perform the operation.
+     * @param deleteRule.objectID - Unique identifier of a rule object.
+     * @param deleteRule.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see deleteRule for the plain version.
+     */
+    deleteRuleWithHTTPInfo({ indexName, objectID, forwardToReplicas }, requestOptions) {
+      validateRequired("indexName", "deleteRuleWithHTTPInfo", indexName);
+      validateRequired("objectID", "deleteRuleWithHTTPInfo", objectID);
+      const requestPath = "/1/indexes/{indexName}/rules/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes a source from the list of allowed sources.
      *
@@ -1078,6 +1649,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Deletes a source from the list of allowed sources.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param deleteSource - The deleteSource object.
+     * @param deleteSource.source - IP address range of the source.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see deleteSource for the plain version.
+     */
+    deleteSourceWithHTTPInfo({ source }, requestOptions) {
+      validateRequired("source", "deleteSourceWithHTTPInfo", source);
+      const requestPath = "/1/security/sources/{source}".replace("{source}", encodeURIComponent(source));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Deletes a synonym by its ID. To find the object IDs of your synonyms, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-synonyms).
      *
@@ -1107,13 +1703,44 @@ function createSearchClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * 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\'s keys. When authenticating with other API keys, you can only retrieve information for that key, with the description replaced by `<redacted>`.
+     * Deletes a synonym by its ID. To find the object IDs of your synonyms, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-synonyms).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
-     *  - search
-     * @param getApiKey - The getApiKey object.
-     * @param getApiKey.key - API key.
-     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     *  - editSettings
+     * @param deleteSynonym - The deleteSynonym object.
+     * @param deleteSynonym.indexName - Name of the index on which to perform the operation.
+     * @param deleteSynonym.objectID - Unique identifier of a synonym object.
+     * @param deleteSynonym.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see deleteSynonym for the plain version.
+     */
+    deleteSynonymWithHTTPInfo({ indexName, objectID, forwardToReplicas }, requestOptions) {
+      validateRequired("indexName", "deleteSynonymWithHTTPInfo", indexName);
+      validateRequired("objectID", "deleteSynonymWithHTTPInfo", objectID);
+      const requestPath = "/1/indexes/{indexName}/synonyms/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * 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\'s keys. When authenticating with other API keys, you can only retrieve information for that key, with the description replaced by `<redacted>`.
+     *
+     * Required API Key ACLs:
+     *  - search
+     * @param getApiKey - The getApiKey object.
+     * @param getApiKey.key - API key.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
      */
     getApiKey({ key }, requestOptions) {
       validateRequired("key", "getApiKey", key);
@@ -1128,6 +1755,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * 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\'s keys. When authenticating with other API keys, you can only retrieve information for that key, with the description replaced by `<redacted>`.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - search
+     * @param getApiKey - The getApiKey object.
+     * @param getApiKey.key - API key.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getApiKey for the plain version.
+     */
+    getApiKeyWithHTTPInfo({ key }, requestOptions) {
+      validateRequired("key", "getApiKeyWithHTTPInfo", key);
+      const requestPath = "/1/keys/{key}".replace("{key}", encodeURIComponent(key));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Checks the status of a given application task.
      *
@@ -1150,6 +1802,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Checks the status of a given application task.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param getAppTask - The getAppTask object.
+     * @param getAppTask.taskID - Unique task identifier.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getAppTask for the plain version.
+     */
+    getAppTaskWithHTTPInfo({ taskID }, requestOptions) {
+      validateRequired("taskID", "getAppTaskWithHTTPInfo", taskID);
+      const requestPath = "/1/task/{taskID}".replace("{taskID}", encodeURIComponent(taskID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Lists supported languages with their supported dictionary types and number of custom entries.
      *
@@ -1169,6 +1846,28 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Lists supported languages with their supported dictionary types and number of custom entries.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getDictionaryLanguages for the plain version.
+     */
+    getDictionaryLanguagesWithHTTPInfo(requestOptions) {
+      const requestPath = "/1/dictionaries/*/languages";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Retrieves the languages for which standard dictionary entries are turned off.
      *
@@ -1188,6 +1887,28 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Retrieves the languages for which standard dictionary entries are turned off.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getDictionarySettings for the plain version.
+     */
+    getDictionarySettingsWithHTTPInfo(requestOptions) {
+      const requestPath = "/1/dictionaries/*/settings";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * The request must be authenticated by an API key with the [`logs` ACL](https://www.algolia.com/doc/guides/security/api-keys/#access-control-list-acl).  - Logs are held for the last seven days. - Up to 1,000 API requests per server are logged. - This request counts towards your [operations quota](https://support.algolia.com/hc/articles/17245378392977-How-does-Algolia-count-records-and-operations) but doesn\'t appear in the logs itself.
      *
@@ -1224,6 +1945,45 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * The request must be authenticated by an API key with the [`logs` ACL](https://www.algolia.com/doc/guides/security/api-keys/#access-control-list-acl).  - Logs are held for the last seven days. - Up to 1,000 API requests per server are logged. - This request counts towards your [operations quota](https://support.algolia.com/hc/articles/17245378392977-How-does-Algolia-count-records-and-operations) but doesn\'t appear in the logs itself.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - logs
+     * @param getLogs - The getLogs object.
+     * @param getLogs.offset - First log entry to retrieve. The most recent entries are listed first.
+     * @param getLogs.length - Maximum number of entries to retrieve.
+     * @param getLogs.indexName - Index for which to retrieve log entries. By default, log entries are retrieved for all indices.
+     * @param getLogs.type - Type of log entries to retrieve. By default, all log entries are retrieved.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getLogs for the plain version.
+     */
+    getLogsWithHTTPInfo({ offset, length, indexName, type } = {}, requestOptions = void 0) {
+      const requestPath = "/1/logs";
+      const headers = {};
+      const queryParameters = {};
+      if (offset !== void 0) {
+        queryParameters["offset"] = offset.toString();
+      }
+      if (length !== void 0) {
+        queryParameters["length"] = length.toString();
+      }
+      if (indexName !== void 0) {
+        queryParameters["indexName"] = indexName.toString();
+      }
+      if (type !== void 0) {
+        queryParameters["type"] = type.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Retrieves one record by its object ID.  To retrieve more than one record, use the [`objects` operation](https://www.algolia.com/doc/rest-api/search/get-objects).
      *
@@ -1252,6 +2012,37 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Retrieves one record by its object ID.  To retrieve more than one record, use the [`objects` operation](https://www.algolia.com/doc/rest-api/search/get-objects).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - search
+     * @param getObject - The getObject object.
+     * @param getObject.indexName - Name of the index on which to perform the operation.
+     * @param getObject.objectID - Unique record identifier.
+     * @param getObject.attributesToRetrieve - Attributes to include with the records in the response. This is useful to reduce the size of the API response. By default, all retrievable attributes are returned.  `objectID` is always retrieved.  Attributes included in `unretrievableAttributes` won\'t be retrieved unless the request is authenticated with the admin API key.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getObject for the plain version.
+     */
+    getObjectWithHTTPInfo({ indexName, objectID, attributesToRetrieve }, requestOptions) {
+      validateRequired("indexName", "getObjectWithHTTPInfo", indexName);
+      validateRequired("objectID", "getObjectWithHTTPInfo", objectID);
+      const requestPath = "/1/indexes/{indexName}/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      if (attributesToRetrieve !== void 0) {
+        queryParameters["attributesToRetrieve"] = attributesToRetrieve.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Retrieves one or more records, potentially from different indices.  Records are returned in the same order as the requests.
      *
@@ -1277,20 +2068,246 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Retrieves one or more records, potentially from different indices.  Records are returned in the same order as the requests.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - search
+     * @param getObjectsParams - Request object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getObjects for the plain version.
+     */
+    getObjectsWithHTTPInfo(getObjectsParams, requestOptions) {
+      validateRequired("getObjectsParams", "getObjectsWithHTTPInfo", getObjectsParams);
+      validateRequired("getObjectsParams.requests", "getObjectsWithHTTPInfo", getObjectsParams.requests);
+      const requestPath = "/1/indexes/*/objects";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: getObjectsParams,
+        useReadTransporter: true,
+        cacheable: true
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * Retrieves a rule by its ID. To find the object ID of rules, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-rules).
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param getRule - The getRule object.
+     * @param getRule.indexName - Name of the index on which to perform the operation.
+     * @param getRule.objectID - Unique identifier of a rule object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    getRule({ indexName, objectID }, requestOptions) {
+      validateRequired("indexName", "getRule", indexName);
+      validateRequired("objectID", "getRule", objectID);
+      const requestPath = "/1/indexes/{indexName}/rules/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.request(request, requestOptions);
+    },
     /**
      * Retrieves a rule by its ID. To find the object ID of rules, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-rules).
      *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
      * Required API Key ACLs:
      *  - settings
      * @param getRule - The getRule object.
      * @param getRule.indexName - Name of the index on which to perform the operation.
      * @param getRule.objectID - Unique identifier of a rule object.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getRule for the plain version.
+     */
+    getRuleWithHTTPInfo({ indexName, objectID }, requestOptions) {
+      validateRequired("indexName", "getRuleWithHTTPInfo", indexName);
+      validateRequired("objectID", "getRuleWithHTTPInfo", objectID);
+      const requestPath = "/1/indexes/{indexName}/rules/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * Retrieves an object with non-null index settings.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param getSettings - The getSettings object.
+     * @param getSettings.indexName - Name of the index on which to perform the operation.
+     * @param getSettings.getVersion - When set to 2, the endpoint will not include `synonyms` in the response. This parameter is here for backward compatibility.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    getSettings({ indexName, getVersion }, requestOptions) {
+      validateRequired("indexName", "getSettings", indexName);
+      const requestPath = "/1/indexes/{indexName}/settings".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      if (getVersion !== void 0) {
+        queryParameters["getVersion"] = getVersion.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * Retrieves an object with non-null index settings.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param getSettings - The getSettings object.
+     * @param getSettings.indexName - Name of the index on which to perform the operation.
+     * @param getSettings.getVersion - When set to 2, the endpoint will not include `synonyms` in the response. This parameter is here for backward compatibility.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getSettings for the plain version.
+     */
+    getSettingsWithHTTPInfo({ indexName, getVersion }, requestOptions) {
+      validateRequired("indexName", "getSettingsWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}/settings".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      if (getVersion !== void 0) {
+        queryParameters["getVersion"] = getVersion.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * Retrieves all allowed IP addresses with access to your application.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    getSources(requestOptions) {
+      const requestPath = "/1/security/sources";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * Retrieves all allowed IP addresses with access to your application.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getSources for the plain version.
+     */
+    getSourcesWithHTTPInfo(requestOptions) {
+      const requestPath = "/1/security/sources";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * Retrieves a synonym by its ID. To find the object IDs for your synonyms, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-synonyms).
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param getSynonym - The getSynonym object.
+     * @param getSynonym.indexName - Name of the index on which to perform the operation.
+     * @param getSynonym.objectID - Unique identifier of a synonym object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    getSynonym({ indexName, objectID }, requestOptions) {
+      validateRequired("indexName", "getSynonym", indexName);
+      validateRequired("objectID", "getSynonym", objectID);
+      const requestPath = "/1/indexes/{indexName}/synonyms/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * Retrieves a synonym by its ID. To find the object IDs for your synonyms, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-synonyms).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param getSynonym - The getSynonym object.
+     * @param getSynonym.indexName - Name of the index on which to perform the operation.
+     * @param getSynonym.objectID - Unique identifier of a synonym object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getSynonym for the plain version.
+     */
+    getSynonymWithHTTPInfo({ indexName, objectID }, requestOptions) {
+      validateRequired("indexName", "getSynonymWithHTTPInfo", indexName);
+      validateRequired("objectID", "getSynonymWithHTTPInfo", objectID);
+      const requestPath = "/1/indexes/{indexName}/synonyms/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * 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\' responses include a task ID that you can use to check the status.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     * @param getTask - The getTask object.
+     * @param getTask.indexName - Name of the index on which to perform the operation.
+     * @param getTask.taskID - Unique task identifier.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
      */
-    getRule({ indexName, objectID }, requestOptions) {
-      validateRequired("indexName", "getRule", indexName);
-      validateRequired("objectID", "getRule", objectID);
-      const requestPath = "/1/indexes/{indexName}/rules/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+    getTask({ indexName, taskID }, requestOptions) {
+      validateRequired("indexName", "getTask", indexName);
+      validateRequired("taskID", "getTask", taskID);
+      const requestPath = "/1/indexes/{indexName}/task/{taskID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -1302,40 +2319,43 @@ function createSearchClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Retrieves an object with non-null index settings.
+     * 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\' responses include a task ID that you can use to check the status.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
-     *  - settings
-     * @param getSettings - The getSettings object.
-     * @param getSettings.indexName - Name of the index on which to perform the operation.
-     * @param getSettings.getVersion - When set to 2, the endpoint will not include `synonyms` in the response. This parameter is here for backward compatibility.
+     *  - addObject
+     * @param getTask - The getTask object.
+     * @param getTask.indexName - Name of the index on which to perform the operation.
+     * @param getTask.taskID - Unique task identifier.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getTask for the plain version.
      */
-    getSettings({ indexName, getVersion }, requestOptions) {
-      validateRequired("indexName", "getSettings", indexName);
-      const requestPath = "/1/indexes/{indexName}/settings".replace("{indexName}", encodeURIComponent(indexName));
+    getTaskWithHTTPInfo({ indexName, taskID }, requestOptions) {
+      validateRequired("indexName", "getTaskWithHTTPInfo", indexName);
+      validateRequired("taskID", "getTaskWithHTTPInfo", taskID);
+      const requestPath = "/1/indexes/{indexName}/task/{taskID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{taskID}", encodeURIComponent(taskID));
       const headers = {};
       const queryParameters = {};
-      if (getVersion !== void 0) {
-        queryParameters["getVersion"] = getVersion.toString();
-      }
       const request = {
         method: "GET",
         path: requestPath,
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * Retrieves all allowed IP addresses with access to your application.
+     * 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\'t real-time.
      *
      * Required API Key ACLs:
      *  - admin
+     *
+     * @deprecated
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
      */
-    getSources(requestOptions) {
-      const requestPath = "/1/security/sources";
+    getTopUserIds(requestOptions) {
+      const requestPath = "/1/clusters/mapping/top";
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -1347,19 +2367,19 @@ function createSearchClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * Retrieves a synonym by its ID. To find the object IDs for your synonyms, use the [`search` operation](https://www.algolia.com/doc/rest-api/search/search-synonyms).
+     * 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\'t real-time.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
-     *  - settings
-     * @param getSynonym - The getSynonym object.
-     * @param getSynonym.indexName - Name of the index on which to perform the operation.
-     * @param getSynonym.objectID - Unique identifier of a synonym object.
+     *  - admin
+     *
+     * @deprecated
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getTopUserIds for the plain version.
      */
-    getSynonym({ indexName, objectID }, requestOptions) {
-      validateRequired("indexName", "getSynonym", indexName);
-      validateRequired("objectID", "getSynonym", objectID);
-      const requestPath = "/1/indexes/{indexName}/synonyms/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+    getTopUserIdsWithHTTPInfo(requestOptions) {
+      const requestPath = "/1/clusters/mapping/top";
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -1368,22 +2388,22 @@ function createSearchClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * 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\' responses include a task ID that you can use to check the status.
+     * 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\'t real-time.
      *
      * Required API Key ACLs:
-     *  - addObject
-     * @param getTask - The getTask object.
-     * @param getTask.indexName - Name of the index on which to perform the operation.
-     * @param getTask.taskID - Unique task identifier.
+     *  - admin
+     *
+     * @deprecated
+     * @param getUserId - The getUserId object.
+     * @param getUserId.userID - Unique identifier of the user who makes the search request.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
      */
-    getTask({ indexName, taskID }, requestOptions) {
-      validateRequired("indexName", "getTask", indexName);
-      validateRequired("taskID", "getTask", taskID);
-      const requestPath = "/1/indexes/{indexName}/task/{taskID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{taskID}", encodeURIComponent(taskID));
+    getUserId({ userID }, requestOptions) {
+      validateRequired("userID", "getUserId", userID);
+      const requestPath = "/1/clusters/mapping/{userID}".replace("{userID}", encodeURIComponent(userID));
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -1395,16 +2415,22 @@ function createSearchClient({
       return transporter.request(request, requestOptions);
     },
     /**
-     * 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\'t real-time.
+     * 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\'t real-time.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
      *
      * Required API Key ACLs:
      *  - admin
      *
      * @deprecated
+     * @param getUserId - The getUserId object.
+     * @param getUserId.userID - Unique identifier of the user who makes the search request.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see getUserId for the plain version.
      */
-    getTopUserIds(requestOptions) {
-      const requestPath = "/1/clusters/mapping/top";
+    getUserIdWithHTTPInfo({ userID }, requestOptions) {
+      validateRequired("userID", "getUserIdWithHTTPInfo", userID);
+      const requestPath = "/1/clusters/mapping/{userID}".replace("{userID}", encodeURIComponent(userID));
       const headers = {};
       const queryParameters = {};
       const request = {
@@ -1413,24 +2439,26 @@ function createSearchClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
-     * 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\'t real-time.
+     * To determine when the time-consuming process of creating a large batch of users or migrating users from one cluster to another is complete, this operation retrieves the status of the process.
      *
      * Required API Key ACLs:
      *  - admin
      *
      * @deprecated
-     * @param getUserId - The getUserId object.
-     * @param getUserId.userID - Unique identifier of the user who makes the search request.
+     * @param hasPendingMappings - The hasPendingMappings object.
+     * @param hasPendingMappings.getClusters - Whether to include the cluster\'s pending mapping state in the response.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
      */
-    getUserId({ userID }, requestOptions) {
-      validateRequired("userID", "getUserId", userID);
-      const requestPath = "/1/clusters/mapping/{userID}".replace("{userID}", encodeURIComponent(userID));
+    hasPendingMappings({ getClusters } = {}, requestOptions = void 0) {
+      const requestPath = "/1/clusters/mapping/pending";
       const headers = {};
       const queryParameters = {};
+      if (getClusters !== void 0) {
+        queryParameters["getClusters"] = getClusters.toString();
+      }
       const request = {
         method: "GET",
         path: requestPath,
@@ -1442,6 +2470,8 @@ function createSearchClient({
     /**
      * 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.
      *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
      * Required API Key ACLs:
      *  - admin
      *
@@ -1449,8 +2479,9 @@ function createSearchClient({
      * @param hasPendingMappings - The hasPendingMappings object.
      * @param hasPendingMappings.getClusters - Whether to include the cluster\'s pending mapping state in the response.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see hasPendingMappings for the plain version.
      */
-    hasPendingMappings({ getClusters } = {}, requestOptions = void 0) {
+    hasPendingMappingsWithHTTPInfo({ getClusters } = {}, requestOptions = void 0) {
       const requestPath = "/1/clusters/mapping/pending";
       const headers = {};
       const queryParameters = {};
@@ -1463,7 +2494,7 @@ function createSearchClient({
         queryParameters,
         headers
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
      * Lists all API keys associated with your Algolia application, including their permissions and restrictions.
@@ -1484,6 +2515,28 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Lists all API keys associated with your Algolia application, including their permissions and restrictions.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see listApiKeys for the plain version.
+     */
+    listApiKeysWithHTTPInfo(requestOptions) {
+      const requestPath = "/1/keys";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Lists the available clusters in a multi-cluster setup.
      *
@@ -1505,6 +2558,30 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Lists the available clusters in a multi-cluster setup.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     *
+     * @deprecated
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see listClusters for the plain version.
+     */
+    listClustersWithHTTPInfo(requestOptions) {
+      const requestPath = "/1/clusters";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Lists all indices in the current Algolia application.  The request follows any index restrictions of the API key you use to make the request.
      *
@@ -1533,6 +2610,37 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Lists all indices in the current Algolia application.  The request follows any index restrictions of the API key you use to make the request.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - listIndexes
+     * @param listIndices - The listIndices object.
+     * @param listIndices.page - Requested page of the API response. If `null`, the API response is not paginated.
+     * @param listIndices.hitsPerPage - Number of hits per page.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see listIndices for the plain version.
+     */
+    listIndicesWithHTTPInfo({ page, hitsPerPage } = {}, requestOptions = void 0) {
+      const requestPath = "/1/indexes";
+      const headers = {};
+      const queryParameters = {};
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (hitsPerPage !== void 0) {
+        queryParameters["hitsPerPage"] = hitsPerPage.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * 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\'t real-time.
      *
@@ -1563,6 +2671,39 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * 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\'t real-time.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     *
+     * @deprecated
+     * @param listUserIds - The listUserIds object.
+     * @param listUserIds.page - Requested page of the API response. If `null`, the API response is not paginated.
+     * @param listUserIds.hitsPerPage - Number of hits per page.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see listUserIds for the plain version.
+     */
+    listUserIdsWithHTTPInfo({ page, hitsPerPage } = {}, requestOptions = void 0) {
+      const requestPath = "/1/clusters/mapping";
+      const headers = {};
+      const queryParameters = {};
+      if (page !== void 0) {
+        queryParameters["page"] = page.toString();
+      }
+      if (hitsPerPage !== void 0) {
+        queryParameters["hitsPerPage"] = hitsPerPage.toString();
+      }
+      const request = {
+        method: "GET",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * 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.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
@@ -1586,6 +2727,32 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * 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.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     * @param batchParams - The batchParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see multipleBatch for the plain version.
+     */
+    multipleBatchWithHTTPInfo(batchParams, requestOptions) {
+      validateRequired("batchParams", "multipleBatchWithHTTPInfo", batchParams);
+      validateRequired("batchParams.requests", "multipleBatchWithHTTPInfo", batchParams.requests);
+      const requestPath = "/1/indexes/*/batch";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: batchParams
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Copies or moves (renames) an index within the same Algolia application.  Notes: - Existing destination indices are overwritten, except for their analytics data. - If the destination index doesn\'t exist yet, it\'s created. - This operation is resource-intensive.  **Copy**  - If the source index doesn\'t exist, copying creates a new index with 0 records and default settings. - API keys from the source index are merged with the existing keys in the destination index. - You can\'t copy the `enableReRanking`, `mode`, and `replicas` settings. - You can\'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). - For more information, see [Copy indices](https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/how-to/copy-indices).  **Move**  - If the source index doesn\'t exist, moving is ignored without returning an error. - When moving an index, the analytics data keeps its 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. - For more information, see [Move indices](https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/how-to/move-indices).  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
@@ -1609,13 +2776,80 @@ function createSearchClient({
         path: requestPath,
         queryParameters,
         headers,
-        data: operationIndexParams
+        data: operationIndexParams
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * Copies or moves (renames) an index within the same Algolia application.  Notes: - Existing destination indices are overwritten, except for their analytics data. - If the destination index doesn\'t exist yet, it\'s created. - This operation is resource-intensive.  **Copy**  - If the source index doesn\'t exist, copying creates a new index with 0 records and default settings. - API keys from the source index are merged with the existing keys in the destination index. - You can\'t copy the `enableReRanking`, `mode`, and `replicas` settings. - You can\'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). - For more information, see [Copy indices](https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/how-to/copy-indices).  **Move**  - If the source index doesn\'t exist, moving is ignored without returning an error. - When moving an index, the analytics data keeps its 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. - For more information, see [Move indices](https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices/how-to/move-indices).  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     * @param operationIndex - The operationIndex object.
+     * @param operationIndex.indexName - Name of the index on which to perform the operation.
+     * @param operationIndex.operationIndexParams - The operationIndexParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see operationIndex for the plain version.
+     */
+    operationIndexWithHTTPInfo({ indexName, operationIndexParams }, requestOptions) {
+      validateRequired("indexName", "operationIndexWithHTTPInfo", indexName);
+      validateRequired("operationIndexParams", "operationIndexWithHTTPInfo", operationIndexParams);
+      validateRequired("operationIndexParams.operation", "operationIndexWithHTTPInfo", operationIndexParams.operation);
+      validateRequired(
+        "operationIndexParams.destination",
+        "operationIndexWithHTTPInfo",
+        operationIndexParams.destination
+      );
+      const requestPath = "/1/indexes/{indexName}/operation".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: operationIndexParams
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * Adds new attributes to a record, or updates existing ones.  - If a record with the specified object ID doesn\'t exist,   a new record is added to the index **if** `createIfNotExists` is true. - If the index doesn\'t exist yet, this method creates a new index. - Use first-level attributes only. Nested attributes aren\'t supported.   If you specify a nested attribute, this operation replaces its first-level ancestor.  To update attributes without replacing the full record, use these built-in operations. These operations are useful when the initial data isn\'t available.  - `Increment`: increment a numeric attribute. - `Decrement`: decrement a numeric attribute. - `Add`: append a number or string element to an array attribute. - `Remove`: remove all matching number or string elements from an array attribute made of numbers or strings. - `AddUnique`: add a number or string element to an array attribute made of numbers or strings only if it\'s not already present. - `IncrementFrom`: increment a numeric integer attribute only if the provided value matches the current value. Otherwise, the update is ignored.   Example: If you pass an `IncrementFrom` value of 2 for the `version` attribute but the current value is 1, the API ignores the update.   If the object doesn\'t exist, the API only creates it if you pass an `IncrementFrom` value of 0. - `IncrementSet`: increment a numeric integer attribute only if the provided value is greater than the current value. Otherwise, the update is ignored.   Example: If you pass an `IncrementSet` value of 2 for the `version` attribute and the current value is 1, the API updates the object.   If the object doesn\'t exist yet, the API only creates it if you pass an `IncrementSet` value greater than 0.  Specify an operation by providing an object with the attribute to update as the key and its value as an object with these properties:  - `_operation`: the operation to apply on the attribute. - `value`: the right-hand side argument to the operation, for example, increment or decrement step, or a value to add or remove.  When updating multiple attributes or using multiple operations targeting the same record, use a single partial update for faster processing.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     * @param partialUpdateObject - The partialUpdateObject object.
+     * @param partialUpdateObject.indexName - Name of the index on which to perform the operation.
+     * @param partialUpdateObject.objectID - Unique record identifier.
+     * @param partialUpdateObject.attributesToUpdate - Attributes with their values.
+     * @param partialUpdateObject.createIfNotExists - Whether to create a new record if it doesn\'t exist.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    partialUpdateObject({ indexName, objectID, attributesToUpdate, createIfNotExists }, requestOptions) {
+      validateRequired("indexName", "partialUpdateObject", indexName);
+      validateRequired("objectID", "partialUpdateObject", objectID);
+      validateRequired("attributesToUpdate", "partialUpdateObject", attributesToUpdate);
+      const requestPath = "/1/indexes/{indexName}/{objectID}/partial".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      if (createIfNotExists !== void 0) {
+        queryParameters["createIfNotExists"] = createIfNotExists.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: attributesToUpdate
       };
       return transporter.request(request, requestOptions);
     },
     /**
      * Adds new attributes to a record, or updates existing ones.  - If a record with the specified object ID doesn\'t exist,   a new record is added to the index **if** `createIfNotExists` is true. - If the index doesn\'t exist yet, this method creates a new index. - Use first-level attributes only. Nested attributes aren\'t supported.   If you specify a nested attribute, this operation replaces its first-level ancestor.  To update attributes without replacing the full record, use these built-in operations. These operations are useful when the initial data isn\'t available.  - `Increment`: increment a numeric attribute. - `Decrement`: decrement a numeric attribute. - `Add`: append a number or string element to an array attribute. - `Remove`: remove all matching number or string elements from an array attribute made of numbers or strings. - `AddUnique`: add a number or string element to an array attribute made of numbers or strings only if it\'s not already present. - `IncrementFrom`: increment a numeric integer attribute only if the provided value matches the current value. Otherwise, the update is ignored.   Example: If you pass an `IncrementFrom` value of 2 for the `version` attribute but the current value is 1, the API ignores the update.   If the object doesn\'t exist, the API only creates it if you pass an `IncrementFrom` value of 0. - `IncrementSet`: increment a numeric integer attribute only if the provided value is greater than the current value. Otherwise, the update is ignored.   Example: If you pass an `IncrementSet` value of 2 for the `version` attribute and the current value is 1, the API updates the object.   If the object doesn\'t exist yet, the API only creates it if you pass an `IncrementSet` value greater than 0.  Specify an operation by providing an object with the attribute to update as the key and its value as an object with these properties:  - `_operation`: the operation to apply on the attribute. - `value`: the right-hand side argument to the operation, for example, increment or decrement step, or a value to add or remove.  When updating multiple attributes or using multiple operations targeting the same record, use a single partial update for faster processing.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
      * Required API Key ACLs:
      *  - addObject
      * @param partialUpdateObject - The partialUpdateObject object.
@@ -1624,11 +2858,12 @@ function createSearchClient({
      * @param partialUpdateObject.attributesToUpdate - Attributes with their values.
      * @param partialUpdateObject.createIfNotExists - Whether to create a new record if it doesn\'t exist.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see partialUpdateObject for the plain version.
      */
-    partialUpdateObject({ indexName, objectID, attributesToUpdate, createIfNotExists }, requestOptions) {
-      validateRequired("indexName", "partialUpdateObject", indexName);
-      validateRequired("objectID", "partialUpdateObject", objectID);
-      validateRequired("attributesToUpdate", "partialUpdateObject", attributesToUpdate);
+    partialUpdateObjectWithHTTPInfo({ indexName, objectID, attributesToUpdate, createIfNotExists }, requestOptions) {
+      validateRequired("indexName", "partialUpdateObjectWithHTTPInfo", indexName);
+      validateRequired("objectID", "partialUpdateObjectWithHTTPInfo", objectID);
+      validateRequired("attributesToUpdate", "partialUpdateObjectWithHTTPInfo", attributesToUpdate);
       const requestPath = "/1/indexes/{indexName}/{objectID}/partial".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
       const headers = {};
       const queryParameters = {};
@@ -1642,7 +2877,7 @@ function createSearchClient({
         headers,
         data: attributesToUpdate
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
      * Deletes a user ID and its associated data from the clusters.
@@ -1668,6 +2903,33 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Deletes a user ID and its associated data from the clusters.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     *
+     * @deprecated
+     * @param removeUserId - The removeUserId object.
+     * @param removeUserId.userID - Unique identifier of the user who makes the search request.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see removeUserId for the plain version.
+     */
+    removeUserIdWithHTTPInfo({ userID }, requestOptions) {
+      validateRequired("userID", "removeUserIdWithHTTPInfo", userID);
+      const requestPath = "/1/clusters/mapping/{userID}".replace("{userID}", encodeURIComponent(userID));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "DELETE",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Replaces the list of allowed sources.
      *
@@ -1691,6 +2953,32 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Replaces the list of allowed sources.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param replaceSources - The replaceSources object.
+     * @param replaceSources.source - Allowed sources.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see replaceSources for the plain version.
+     */
+    replaceSourcesWithHTTPInfo({ source }, requestOptions) {
+      validateRequired("source", "replaceSourcesWithHTTPInfo", source);
+      const requestPath = "/1/security/sources";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: source
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Restores a deleted API key.  Restoring resets the `validity` attribute to `0`.  Algolia stores up to 1,000 API keys per application. If you create more, the oldest API keys are deleted and can\'t be restored.
      *
@@ -1713,6 +3001,31 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Restores a deleted API key.  Restoring resets the `validity` attribute to `0`.  Algolia stores up to 1,000 API keys per application. If you create more, the oldest API keys are deleted and can\'t be restored.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param restoreApiKey - The restoreApiKey object.
+     * @param restoreApiKey.key - API key.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see restoreApiKey for the plain version.
+     */
+    restoreApiKeyWithHTTPInfo({ key }, requestOptions) {
+      validateRequired("key", "restoreApiKeyWithHTTPInfo", key);
+      const requestPath = "/1/keys/{key}/restore".replace("{key}", encodeURIComponent(key));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Adds a record to an index or replaces it.  - If the record doesn\'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\'t exist, a new record is added to your index. - If you add a record to an index that doesn\'t exist yet, a new index is created.  To update _some_ attributes of a record, use the [`partial` operation](https://www.algolia.com/doc/rest-api/search/partial-update-object). To add, update, or replace multiple records, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/batch).  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
@@ -1738,6 +3051,34 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Adds a record to an index or replaces it.  - If the record doesn\'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\'t exist, a new record is added to your index. - If you add a record to an index that doesn\'t exist yet, a new index is created.  To update _some_ attributes of a record, use the [`partial` operation](https://www.algolia.com/doc/rest-api/search/partial-update-object). To add, update, or replace multiple records, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/batch).  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - addObject
+     * @param saveObject - The saveObject object.
+     * @param saveObject.indexName - Name of the index on which to perform the operation.
+     * @param saveObject.body - The record. A schemaless object with attributes that are useful in the context of search and discovery.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see saveObject for the plain version.
+     */
+    saveObjectWithHTTPInfo({ indexName, body }, requestOptions) {
+      validateRequired("indexName", "saveObjectWithHTTPInfo", indexName);
+      validateRequired("body", "saveObjectWithHTTPInfo", body);
+      const requestPath = "/1/indexes/{indexName}".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: body
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * If a rule with the specified object ID doesn\'t exist, it\'s created. Otherwise, the existing rule is replaced.  To create or update more than one rule, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/save-rules).
      *
@@ -1771,6 +3112,42 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * If a rule with the specified object ID doesn\'t exist, it\'s created. Otherwise, the existing rule is replaced.  To create or update more than one rule, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/save-rules).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param saveRule - The saveRule object.
+     * @param saveRule.indexName - Name of the index on which to perform the operation.
+     * @param saveRule.objectID - Unique identifier of a rule object.
+     * @param saveRule.rule - The rule object.
+     * @param saveRule.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see saveRule for the plain version.
+     */
+    saveRuleWithHTTPInfo({ indexName, objectID, rule, forwardToReplicas }, requestOptions) {
+      validateRequired("indexName", "saveRuleWithHTTPInfo", indexName);
+      validateRequired("objectID", "saveRuleWithHTTPInfo", objectID);
+      validateRequired("rule", "saveRuleWithHTTPInfo", rule);
+      validateRequired("rule.objectID", "saveRuleWithHTTPInfo", rule.objectID);
+      validateRequired("rule.consequence", "saveRuleWithHTTPInfo", rule.consequence);
+      const requestPath = "/1/indexes/{indexName}/rules/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: rule
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Create or update multiple rules.  If a rule with the specified object ID doesn\'t exist, Algolia creates a new one. Otherwise, existing rules are replaced.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
@@ -1804,6 +3181,42 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Create or update multiple rules.  If a rule with the specified object ID doesn\'t exist, Algolia creates a new one. Otherwise, existing rules are replaced.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param saveRules - The saveRules object.
+     * @param saveRules.indexName - Name of the index on which to perform the operation.
+     * @param saveRules.rules - The rules object.
+     * @param saveRules.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param saveRules.clearExistingRules - Whether existing rules should be deleted before adding this batch.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see saveRules for the plain version.
+     */
+    saveRulesWithHTTPInfo({ indexName, rules, forwardToReplicas, clearExistingRules }, requestOptions) {
+      validateRequired("indexName", "saveRulesWithHTTPInfo", indexName);
+      validateRequired("rules", "saveRulesWithHTTPInfo", rules);
+      const requestPath = "/1/indexes/{indexName}/rules/batch".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      if (clearExistingRules !== void 0) {
+        queryParameters["clearExistingRules"] = clearExistingRules.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: rules
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * If a synonym with the specified object ID doesn\'t exist, Algolia adds a new one. Otherwise, the existing synonym is replaced. To add multiple synonyms in a single API request, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/save-synonyms).
      *
@@ -1837,6 +3250,42 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * If a synonym with the specified object ID doesn\'t exist, Algolia adds a new one. Otherwise, the existing synonym is replaced. To add multiple synonyms in a single API request, use the [`batch` operation](https://www.algolia.com/doc/rest-api/search/save-synonyms).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param saveSynonym - The saveSynonym object.
+     * @param saveSynonym.indexName - Name of the index on which to perform the operation.
+     * @param saveSynonym.objectID - Unique identifier of a synonym object.
+     * @param saveSynonym.synonymHit - The synonymHit object.
+     * @param saveSynonym.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see saveSynonym for the plain version.
+     */
+    saveSynonymWithHTTPInfo({ indexName, objectID, synonymHit, forwardToReplicas }, requestOptions) {
+      validateRequired("indexName", "saveSynonymWithHTTPInfo", indexName);
+      validateRequired("objectID", "saveSynonymWithHTTPInfo", objectID);
+      validateRequired("synonymHit", "saveSynonymWithHTTPInfo", synonymHit);
+      validateRequired("synonymHit.objectID", "saveSynonymWithHTTPInfo", synonymHit.objectID);
+      validateRequired("synonymHit.type", "saveSynonymWithHTTPInfo", synonymHit.type);
+      const requestPath = "/1/indexes/{indexName}/synonyms/{objectID}".replace("{indexName}", encodeURIComponent(indexName)).replace("{objectID}", encodeURIComponent(objectID));
+      const headers = {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: synonymHit
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * If a synonym with the `objectID` doesn\'t exist, Algolia adds a new one. Otherwise, existing synonyms are replaced.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
      *
@@ -1855,30 +3304,115 @@ function createSearchClient({
       const requestPath = "/1/indexes/{indexName}/synonyms/batch".replace("{indexName}", encodeURIComponent(indexName));
       const headers = {};
       const queryParameters = {};
-      if (forwardToReplicas !== void 0) {
-        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
-      }
-      if (replaceExistingSynonyms !== void 0) {
-        queryParameters["replaceExistingSynonyms"] = replaceExistingSynonyms.toString();
-      }
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      if (replaceExistingSynonyms !== void 0) {
+        queryParameters["replaceExistingSynonyms"] = replaceExistingSynonyms.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: synonymHit
+      };
+      return transporter.request(request, requestOptions);
+    },
+    /**
+     * If a synonym with the `objectID` doesn\'t exist, Algolia adds a new one. Otherwise, existing synonyms are replaced.  This operation is subject to [indexing rate limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param saveSynonyms - The saveSynonyms object.
+     * @param saveSynonyms.indexName - Name of the index on which to perform the operation.
+     * @param saveSynonyms.synonymHit - The synonymHit object.
+     * @param saveSynonyms.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param saveSynonyms.replaceExistingSynonyms - Whether to replace all synonyms in the index with the ones sent with this request.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see saveSynonyms for the plain version.
+     */
+    saveSynonymsWithHTTPInfo({ indexName, synonymHit, forwardToReplicas, replaceExistingSynonyms }, requestOptions) {
+      validateRequired("indexName", "saveSynonymsWithHTTPInfo", indexName);
+      validateRequired("synonymHit", "saveSynonymsWithHTTPInfo", synonymHit);
+      const requestPath = "/1/indexes/{indexName}/synonyms/batch".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      if (replaceExistingSynonyms !== void 0) {
+        queryParameters["replaceExistingSynonyms"] = replaceExistingSynonyms.toString();
+      }
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: synonymHit
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
+    /**
+     * Runs multiple search queries against one or more indices in a single API request.  Use cases include:  - Searching different indices, such as products and marketing content. - Run multiple queries on the same index with different parameters or filters.  If you know the expected result type, use the `searchForHits` or `searchForFacets` helper to simplify the response format.
+     *
+     * Required API Key ACLs:
+     *  - search
+     * @param searchMethodParams - Multi-query search request body. Results are returned in the same order as the requests.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    search(searchMethodParams, requestOptions) {
+      if (searchMethodParams && Array.isArray(searchMethodParams)) {
+        const newSignatureRequest = {
+          requests: searchMethodParams.map(({ params, ...legacyRequest }) => {
+            if (legacyRequest.type === "facet") {
+              return {
+                ...legacyRequest,
+                ...params,
+                type: "facet"
+              };
+            }
+            return {
+              ...legacyRequest,
+              ...params,
+              facet: void 0,
+              maxFacetHits: void 0,
+              facetQuery: void 0
+            };
+          })
+        };
+        searchMethodParams = newSignatureRequest;
+      }
+      validateRequired("searchMethodParams", "search", searchMethodParams);
+      validateRequired("searchMethodParams.requests", "search", searchMethodParams.requests);
+      const requestPath = "/1/indexes/*/queries";
+      const headers = {};
+      const queryParameters = {};
       const request = {
         method: "POST",
         path: requestPath,
         queryParameters,
         headers,
-        data: synonymHit
+        data: searchMethodParams,
+        useReadTransporter: true,
+        cacheable: true
       };
       return transporter.request(request, requestOptions);
     },
     /**
      * Runs multiple search queries against one or more indices in a single API request.  Use cases include:  - Searching different indices, such as products and marketing content. - Run multiple queries on the same index with different parameters or filters.  If you know the expected result type, use the `searchForHits` or `searchForFacets` helper to simplify the response format.
      *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
      * Required API Key ACLs:
      *  - search
      * @param searchMethodParams - Multi-query search request body. Results are returned in the same order as the requests.
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see search for the plain version.
      */
-    search(searchMethodParams, requestOptions) {
+    searchWithHTTPInfo(searchMethodParams, requestOptions) {
       if (searchMethodParams && Array.isArray(searchMethodParams)) {
         const newSignatureRequest = {
           requests: searchMethodParams.map(({ params, ...legacyRequest }) => {
@@ -1900,8 +3434,8 @@ function createSearchClient({
         };
         searchMethodParams = newSignatureRequest;
       }
-      validateRequired("searchMethodParams", "search", searchMethodParams);
-      validateRequired("searchMethodParams.requests", "search", searchMethodParams.requests);
+      validateRequired("searchMethodParams", "searchWithHTTPInfo", searchMethodParams);
+      validateRequired("searchMethodParams.requests", "searchWithHTTPInfo", searchMethodParams.requests);
       const requestPath = "/1/indexes/*/queries";
       const headers = {};
       const queryParameters = {};
@@ -1914,7 +3448,7 @@ function createSearchClient({
         useReadTransporter: true,
         cacheable: true
       };
-      return transporter.request(request, requestOptions);
+      return transporter.requestWithHttpInfo(request, requestOptions);
     },
     /**
      * Searches for standard and custom dictionary entries.
@@ -1951,6 +3485,48 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for standard and custom dictionary entries.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param searchDictionaryEntries - The searchDictionaryEntries object.
+     * @param searchDictionaryEntries.dictionaryName - Dictionary type in which to search.
+     * @param searchDictionaryEntries.searchDictionaryEntriesParams - The searchDictionaryEntriesParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see searchDictionaryEntries for the plain version.
+     */
+    searchDictionaryEntriesWithHTTPInfo({ dictionaryName, searchDictionaryEntriesParams }, requestOptions) {
+      validateRequired("dictionaryName", "searchDictionaryEntriesWithHTTPInfo", dictionaryName);
+      validateRequired(
+        "searchDictionaryEntriesParams",
+        "searchDictionaryEntriesWithHTTPInfo",
+        searchDictionaryEntriesParams
+      );
+      validateRequired(
+        "searchDictionaryEntriesParams.query",
+        "searchDictionaryEntriesWithHTTPInfo",
+        searchDictionaryEntriesParams.query
+      );
+      const requestPath = "/1/dictionaries/{dictionaryName}/search".replace(
+        "{dictionaryName}",
+        encodeURIComponent(dictionaryName)
+      );
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: searchDictionaryEntriesParams,
+        useReadTransporter: true,
+        cacheable: true
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for values of a specified facet attribute.  - By default, facet values are sorted by decreasing count.   You can adjust this with the `sortFacetValueBy` parameter. - Searching for facet values doesn\'t work if you have **more than 65 searchable facets and searchable attributes combined**.
      *
@@ -1979,6 +3555,37 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for values of a specified facet attribute.  - By default, facet values are sorted by decreasing count.   You can adjust this with the `sortFacetValueBy` parameter. - Searching for facet values doesn\'t work if you have **more than 65 searchable facets and searchable attributes combined**.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - search
+     * @param searchForFacetValues - The searchForFacetValues object.
+     * @param searchForFacetValues.indexName - Name of the index on which to perform the operation.
+     * @param searchForFacetValues.facetName - Facet attribute in which to search for values.  This attribute must be included in the `attributesForFaceting` index setting with the `searchable()` modifier.
+     * @param searchForFacetValues.searchForFacetValuesRequest - The searchForFacetValuesRequest object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see searchForFacetValues for the plain version.
+     */
+    searchForFacetValuesWithHTTPInfo({ indexName, facetName, searchForFacetValuesRequest }, requestOptions) {
+      validateRequired("indexName", "searchForFacetValuesWithHTTPInfo", indexName);
+      validateRequired("facetName", "searchForFacetValuesWithHTTPInfo", facetName);
+      const requestPath = "/1/indexes/{indexName}/facets/{facetName}/query".replace("{indexName}", encodeURIComponent(indexName)).replace("{facetName}", encodeURIComponent(facetName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: searchForFacetValuesRequest ? searchForFacetValuesRequest : {},
+        useReadTransporter: true,
+        cacheable: true
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for rules in your index.
      *
@@ -2005,6 +3612,35 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for rules in your index.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param searchRules - The searchRules object.
+     * @param searchRules.indexName - Name of the index on which to perform the operation.
+     * @param searchRules.searchRulesParams - The searchRulesParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see searchRules for the plain version.
+     */
+    searchRulesWithHTTPInfo({ indexName, searchRulesParams }, requestOptions) {
+      validateRequired("indexName", "searchRulesWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}/rules/search".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: searchRulesParams ? searchRulesParams : {},
+        useReadTransporter: true,
+        cacheable: true
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches a single index and returns matching search results as hits.  This method lets you retrieve up to 1,000 hits. If you need more, use the [`browse` operation](https://www.algolia.com/doc/rest-api/search/browse) or increase the `paginatedLimitedTo` index setting.
      *
@@ -2031,6 +3667,35 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches a single index and returns matching search results as hits.  This method lets you retrieve up to 1,000 hits. If you need more, use the [`browse` operation](https://www.algolia.com/doc/rest-api/search/browse) or increase the `paginatedLimitedTo` index setting.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - search
+     * @param searchSingleIndex - The searchSingleIndex object.
+     * @param searchSingleIndex.indexName - Name of the index on which to perform the operation.
+     * @param searchSingleIndex.searchParams - The searchParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see searchSingleIndex for the plain version.
+     */
+    searchSingleIndexWithHTTPInfo({ indexName, searchParams }, requestOptions) {
+      validateRequired("indexName", "searchSingleIndexWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}/query".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: searchParams ? searchParams : {},
+        useReadTransporter: true,
+        cacheable: true
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Searches for synonyms in your index.
      *
@@ -2060,6 +3725,38 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Searches for synonyms in your index.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param searchSynonyms - The searchSynonyms object.
+     * @param searchSynonyms.indexName - Name of the index on which to perform the operation.
+     * @param searchSynonyms.searchSynonymsParams - Body of the `searchSynonyms` operation.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see searchSynonyms for the plain version.
+     */
+    searchSynonymsWithHTTPInfo({ indexName, searchSynonymsParams }, requestOptions) {
+      validateRequired("indexName", "searchSynonymsWithHTTPInfo", indexName);
+      const requestPath = "/1/indexes/{indexName}/synonyms/search".replace(
+        "{indexName}",
+        encodeURIComponent(indexName)
+      );
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: searchSynonymsParams ? searchSynonymsParams : {},
+        useReadTransporter: true,
+        cacheable: true
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Since it can take a few seconds to get the data from the different clusters, the response isn\'t real-time.  To ensure rapid updates, the user IDs index isn\'t built at the same time as the mapping. Instead, it\'s built every 12 hours, at the same time as the update of user ID usage. For example, if you add or move a user ID, the search will show an old value until the next time the mapping is rebuilt (every 12 hours).
      *
@@ -2087,6 +3784,36 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Since it can take a few seconds to get the data from the different clusters, the response isn\'t real-time.  To ensure rapid updates, the user IDs index isn\'t built at the same time as the mapping. Instead, it\'s built every 12 hours, at the same time as the update of user ID usage. For example, if you add or move a user ID, the search will show an old value until the next time the mapping is rebuilt (every 12 hours).
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     *
+     * @deprecated
+     * @param searchUserIdsParams - The searchUserIdsParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see searchUserIds for the plain version.
+     */
+    searchUserIdsWithHTTPInfo(searchUserIdsParams, requestOptions) {
+      validateRequired("searchUserIdsParams", "searchUserIdsWithHTTPInfo", searchUserIdsParams);
+      validateRequired("searchUserIdsParams.query", "searchUserIdsWithHTTPInfo", searchUserIdsParams.query);
+      const requestPath = "/1/clusters/mapping/search";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "POST",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: searchUserIdsParams,
+        useReadTransporter: true,
+        cacheable: true
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Turns standard stop word dictionary entries on or off for a given language.
      *
@@ -2114,6 +3841,36 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Turns standard stop word dictionary entries on or off for a given language.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param dictionarySettingsParams - The dictionarySettingsParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see setDictionarySettings for the plain version.
+     */
+    setDictionarySettingsWithHTTPInfo(dictionarySettingsParams, requestOptions) {
+      validateRequired("dictionarySettingsParams", "setDictionarySettingsWithHTTPInfo", dictionarySettingsParams);
+      validateRequired(
+        "dictionarySettingsParams.disableStandardEntries",
+        "setDictionarySettingsWithHTTPInfo",
+        dictionarySettingsParams.disableStandardEntries
+      );
+      const requestPath = "/1/dictionaries/*/settings";
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: dictionarySettingsParams
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Update the specified index settings.  Index settings that you don\'t specify are left unchanged. Specify `null` to reset a setting to its default value.  For best performance, update the index settings before you add new records to your index.
      *
@@ -2143,6 +3900,38 @@ function createSearchClient({
       };
       return transporter.request(request, requestOptions);
     },
+    /**
+     * Update the specified index settings.  Index settings that you don\'t specify are left unchanged. Specify `null` to reset a setting to its default value.  For best performance, update the index settings before you add new records to your index.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param setSettings - The setSettings object.
+     * @param setSettings.indexName - Name of the index on which to perform the operation.
+     * @param setSettings.indexSettings - The indexSettings object.
+     * @param setSettings.forwardToReplicas - Whether changes are applied to replica indices.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see setSettings for the plain version.
+     */
+    setSettingsWithHTTPInfo({ indexName, indexSettings, forwardToReplicas }, requestOptions) {
+      validateRequired("indexName", "setSettingsWithHTTPInfo", indexName);
+      validateRequired("indexSettings", "setSettingsWithHTTPInfo", indexSettings);
+      const requestPath = "/1/indexes/{indexName}/settings".replace("{indexName}", encodeURIComponent(indexName));
+      const headers = {};
+      const queryParameters = {};
+      if (forwardToReplicas !== void 0) {
+        queryParameters["forwardToReplicas"] = forwardToReplicas.toString();
+      }
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: indexSettings
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
+    },
     /**
      * Replaces the permissions of an existing API key.  Any unspecified attribute resets that attribute to its default value.
      *
@@ -2168,6 +3957,35 @@ function createSearchClient({
         data: apiKey
       };
       return transporter.request(request, requestOptions);
+    },
+    /**
+     * Replaces the permissions of an existing API key.  Any unspecified attribute resets that attribute to its default value.
+     *
+     * Resolves with the full HTTP response information: status code, headers (when the requester captures them), raw body and deserialized data. Bypasses the requests and responses caches: always performs the API call.
+     *
+     * Required API Key ACLs:
+     *  - admin
+     * @param updateApiKey - The updateApiKey object.
+     * @param updateApiKey.key - API key.
+     * @param updateApiKey.apiKey - The apiKey object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     * @see updateApiKey for the plain version.
+     */
+    updateApiKeyWithHTTPInfo({ key, apiKey }, requestOptions) {
+      validateRequired("key", "updateApiKeyWithHTTPInfo", key);
+      validateRequired("apiKey", "updateApiKeyWithHTTPInfo", apiKey);
+      validateRequired("apiKey.acl", "updateApiKeyWithHTTPInfo", apiKey.acl);
+      const requestPath = "/1/keys/{key}".replace("{key}", encodeURIComponent(key));
+      const headers = {};
+      const queryParameters = {};
+      const request = {
+        method: "PUT",
+        path: requestPath,
+        queryParameters,
+        headers,
+        data: apiKey
+      };
+      return transporter.requestWithHttpInfo(request, requestOptions);
     }
   };
 }