algoliasearch 5.0.0-alpha.2 → 5.0.0-alpha.21

package/dist/algoliasearch.esm.browser.js

@@ -15,43 +15,43 @@ function createAuth(appId, apiKey, authMode = 'WithinHeaders') {
   };
 }
 
-const DEFAULT_MAX_RETRIES = 50;
-const DEFAULT_TIMEOUT = retryCount => Math.min(retryCount * 200, 5000);
 /**
- * Return a promise that retry a task until it meets the condition.
+ * Helper: Returns the promise of a given `func` to iterate on, based on a given `validate` condition.
  *
- * @param createRetryablePromiseOptions - The createRetryablePromise options.
- * @param createRetryablePromiseOptions.func - The function to run, which returns a promise.
- * @param createRetryablePromiseOptions.validate - The validator function. It receives the resolved return of `func`.
- * @param createRetryablePromiseOptions.maxRetries - The maximum number of retries. 50 by default.
- * @param createRetryablePromiseOptions.timeout - The function to decide how long to wait between retries.
+ * @param createIterator - The createIterator options.
+ * @param createIterator.func - The function to run, which returns a promise.
+ * @param createIterator.validate - The validator function. It receives the resolved return of `func`.
+ * @param createIterator.aggregator - The function that runs right after the `func` method has been executed, allows you to do anything with the response before `validate`.
+ * @param createIterator.error - The `validate` condition to throw an error, and its message.
+ * @param createIterator.timeout - The function to decide how long to wait between iterations.
  */
-
-function createRetryablePromise({
+function createIterablePromise({
   func,
   validate,
-  maxRetries = DEFAULT_MAX_RETRIES,
-  timeout = DEFAULT_TIMEOUT
+  aggregator,
+  error,
+  timeout = () => 0
 }) {
-  let retryCount = 0;
-
-  const retry = () => {
+  const retry = previousResponse => {
     return new Promise((resolve, reject) => {
-      func().then(response => {
-        const isValid = validate(response);
+      func(previousResponse).then(response => {
+        if (aggregator) {
+          aggregator(response);
+        }
 
-        if (isValid) {
-          resolve(response);
-        } else if (retryCount + 1 >= maxRetries) {
-          reject(new Error(`The maximum number of retries exceeded. (${retryCount + 1}/${maxRetries})`));
-        } else {
-          retryCount += 1;
-          setTimeout(() => {
-            retry().then(resolve).catch(reject);
-          }, timeout(retryCount));
+        if (validate(response)) {
+          return resolve(response);
         }
-      }).catch(error => {
-        reject(error);
+
+        if (error && error.validate(response)) {
+          return reject(new Error(error.message(response)));
+        }
+
+        return setTimeout(() => {
+          retry(response).then(resolve).catch(reject);
+        }, timeout());
+      }).catch(err => {
+        reject(err);
       });
     });
   };
@@ -332,7 +332,7 @@ function serializeUrl(host, path, queryParameters) {
 function serializeQueryParameters(parameters) {
   const isObjectOrArray = value => Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]';
 
-  return Object.keys(parameters).map(key => `${key}=${isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]}`).join('&');
+  return Object.keys(parameters).map(key => `${key}=${encodeURIComponent(isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key])}`).join('&');
 }
 function serializeData(request, requestOptions) {
   if (request.method === 'GET' || request.data === undefined && requestOptions.data === undefined) {
@@ -715,7 +715,7 @@ const DEFAULT_READ_TIMEOUT_BROWSER = 2000;
 const DEFAULT_WRITE_TIMEOUT_BROWSER = 30000;
 
 // This file is generated, manual changes will be lost - read more on https://github.com/algolia/api-clients-automation.
-const apiClientVersion$4 = '5.0.0-alpha.2';
+const apiClientVersion$4 = '5.0.0-alpha.21';
 const REGIONS$2 = ['de', 'us'];
 function getDefaultHosts$3(region) {
     const url = !region
@@ -746,6 +746,19 @@ function createAbtestingClient({ appId: appIdOption, apiKey: apiKeyOption, authM
     });
     return {
         transporter,
+        /**
+         * The `appId` currently in use.
+         */
+        appId: appIdOption,
+        /**
+         * Clears the cache of the transporter for the `requestsCache` and `responsesCache` properties.
+         */
+        clearCache() {
+            return Promise.all([
+                transporter.requestsCache.clear(),
+                transporter.responsesCache.clear(),
+            ]).then(() => undefined);
+        },
         /**
          * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
          */
@@ -896,7 +909,7 @@ function createAbtestingClient({ appId: appIdOption, apiKey: apiKeyOption, authM
          * @param listABTests.limit - Number of records to return. Limit is the size of the page.
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        listABTests({ offset, limit }, requestOptions) {
+        listABTests({ offset, limit } = {}, requestOptions = undefined) {
             const requestPath = '/2/abtests';
             const headers = {};
             const queryParameters = {};
@@ -993,7 +1006,7 @@ function createAbtestingClient({ appId: appIdOption, apiKey: apiKeyOption, authM
 }
 
 // This file is generated, manual changes will be lost - read more on https://github.com/algolia/api-clients-automation.
-const apiClientVersion$3 = '5.0.0-alpha.2';
+const apiClientVersion$3 = '5.0.0-alpha.21';
 const REGIONS$1 = ['de', 'us'];
 function getDefaultHosts$2(region) {
     const url = !region
@@ -1024,6 +1037,19 @@ function createAnalyticsClient({ appId: appIdOption, apiKey: apiKeyOption, authM
     });
     return {
         transporter,
+        /**
+         * The `appId` currently in use.
+         */
+        appId: appIdOption,
+        /**
+         * Clears the cache of the transporter for the `requestsCache` and `responsesCache` properties.
+         */
+        clearCache() {
+            return Promise.all([
+                transporter.requestsCache.clear(),
+                transporter.responsesCache.clear(),
+            ]).then(() => undefined);
+        },
         /**
          * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
          */
@@ -1877,7 +1903,7 @@ function createAnalyticsClient({ appId: appIdOption, apiKey: apiKeyOption, authM
 }
 
 // This file is generated, manual changes will be lost - read more on https://github.com/algolia/api-clients-automation.
-const apiClientVersion$2 = '5.0.0-alpha.2';
+const apiClientVersion$2 = '5.0.0-alpha.21';
 const REGIONS = ['eu', 'us'];
 function getDefaultHosts$1(region) {
     const url = 'personalization.{region}.algolia.com'.replace('{region}', region);
@@ -1906,6 +1932,19 @@ function createPersonalizationClient({ appId: appIdOption, apiKey: apiKeyOption,
     });
     return {
         transporter,
+        /**
+         * The `appId` currently in use.
+         */
+        appId: appIdOption,
+        /**
+         * Clears the cache of the transporter for the `requestsCache` and `responsesCache` properties.
+         */
+        clearCache() {
+            return Promise.all([
+                transporter.requestsCache.clear(),
+                transporter.responsesCache.clear(),
+            ]).then(() => undefined);
+        },
         /**
          * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
          */
@@ -2121,7 +2160,7 @@ function createPersonalizationClient({ appId: appIdOption, apiKey: apiKeyOption,
 }
 
 // This file is generated, manual changes will be lost - read more on https://github.com/algolia/api-clients-automation.
-const apiClientVersion$1 = '5.0.0-alpha.2';
+const apiClientVersion$1 = '5.0.0-alpha.21';
 function getDefaultHosts(appId) {
     return [
         {
@@ -2175,6 +2214,19 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
     });
     return {
         transporter,
+        /**
+         * The `appId` currently in use.
+         */
+        appId: appIdOption,
+        /**
+         * Clears the cache of the transporter for the `requestsCache` and `responsesCache` properties.
+         */
+        clearCache() {
+            return Promise.all([
+                transporter.requestsCache.clear(),
+                transporter.responsesCache.clear(),
+            ]).then(() => undefined);
+        },
         /**
          * Get the value of the `algoliaAgent`, used by our libraries internally and telemetry system.
          */
@@ -2191,38 +2243,57 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
             transporter.algoliaAgent.add({ segment, version });
         },
         /**
-         * Helper: Wait for a task to complete with `indexName` and `taskID`.
+         * Helper: Wait for a task to be published (completed) for a given `indexName` and `taskID`.
          *
-         * @summary Wait for a task to complete.
+         * @summary Helper method that waits for a task to be published (completed).
          * @param waitForTaskOptions - The waitForTaskOptions object.
          * @param waitForTaskOptions.indexName - The `indexName` where the operation was performed.
          * @param waitForTaskOptions.taskID - The `taskID` returned in the method response.
+         * @param waitForTaskOptions.maxRetries - The maximum number of retries. 50 by default.
+         * @param waitForTaskOptions.timeout - The function to decide how long to wait between retries.
          * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `getTask` method and merged with the transporter requestOptions.
          */
-        waitForTask({ indexName, taskID, ...createRetryablePromiseOptions }, requestOptions) {
-            return createRetryablePromise({
-                ...createRetryablePromiseOptions,
+        waitForTask({ indexName, taskID, maxRetries = 50, timeout = (retryCount) => Math.min(retryCount * 200, 5000), }, requestOptions) {
+            let retryCount = 0;
+            return createIterablePromise({
                 func: () => this.getTask({ indexName, taskID }, requestOptions),
                 validate: (response) => response.status === 'published',
+                aggregator: () => (retryCount += 1),
+                error: {
+                    validate: () => retryCount >= maxRetries,
+                    message: () => `The maximum number of retries exceeded. (${retryCount}/${maxRetries})`,
+                },
+                timeout: () => timeout(retryCount),
             });
         },
         /**
          * Helper: Wait for an API key to be added, updated or deleted based on a given `operation`.
          *
-         * @summary Wait for an API key task to be processed.
+         * @summary Helper method that waits for an API key task to be processed.
          * @param waitForApiKeyOptions - The waitForApiKeyOptions object.
          * @param waitForApiKeyOptions.operation - The `operation` that was done on a `key`.
          * @param waitForApiKeyOptions.key - The `key` that has been added, deleted or updated.
          * @param waitForApiKeyOptions.apiKey - Necessary to know if an `update` operation has been processed, compare fields of the response with it.
+         * @param waitForApiKeyOptions.maxRetries - The maximum number of retries. 50 by default.
+         * @param waitForApiKeyOptions.timeout - The function to decide how long to wait between retries.
          * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `getApikey` method and merged with the transporter requestOptions.
          */
-        waitForApiKey({ operation, key, apiKey, ...createRetryablePromiseOptions }, requestOptions) {
+        waitForApiKey({ operation, key, apiKey, maxRetries = 50, timeout = (retryCount) => Math.min(retryCount * 200, 5000), }, requestOptions) {
+            let retryCount = 0;
+            const baseIteratorOptions = {
+                aggregator: () => (retryCount += 1),
+                error: {
+                    validate: () => retryCount >= maxRetries,
+                    message: () => `The maximum number of retries exceeded. (${retryCount}/${maxRetries})`,
+                },
+                timeout: () => timeout(retryCount),
+            };
             if (operation === 'update') {
                 if (!apiKey) {
                     throw new Error('`apiKey` is required when waiting for an `update` operation.');
                 }
-                return createRetryablePromise({
-                    ...createRetryablePromiseOptions,
+                return createIterablePromise({
+                    ...baseIteratorOptions,
                     func: () => this.getApiKey({ key }, requestOptions),
                     validate: (response) => {
                         for (const field of Object.keys(apiKey)) {
@@ -2240,12 +2311,99 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                     },
                 });
             }
-            return createRetryablePromise({
-                ...createRetryablePromiseOptions,
+            return createIterablePromise({
+                ...baseIteratorOptions,
                 func: () => this.getApiKey({ key }, requestOptions).catch((error) => error),
                 validate: (error) => operation === 'add' ? error.status !== 404 : error.status === 404,
             });
         },
+        /**
+         * Helper: Iterate on the `browse` method of the client to allow aggregating objects of an index.
+         *
+         * @summary Helper method that iterates on the `browse` method.
+         * @param browseObjects - The browseObjects object.
+         * @param browseObjects.indexName - The index in which to perform the request.
+         * @param browseObjects.browseParams - The `browse` parameters.
+         * @param browseObjects.validate - The validator function. It receive the resolved return of the API call. By default, stops when there is no `cursor` in the response.
+         * @param browseObjects.aggregator - The function that runs right after the API call has been resolved, allows you to do anything with the response before `validate`.
+         * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `browse` method and merged with the transporter requestOptions.
+         */
+        browseObjects({ indexName, browseParams, ...browseObjectsOptions }, requestOptions) {
+            return createIterablePromise({
+                func: (previousResponse) => {
+                    return this.browse({
+                        indexName,
+                        browseParams: {
+                            cursor: previousResponse ? previousResponse.cursor : undefined,
+                            ...browseParams,
+                        },
+                    }, requestOptions);
+                },
+                validate: (response) => response.cursor === undefined,
+                ...browseObjectsOptions,
+            });
+        },
+        /**
+         * Helper: Iterate on the `searchRules` method of the client to allow aggregating rules of an index.
+         *
+         * @summary Helper method that iterates on the `searchRules` method.
+         * @param browseObjects - The browseObjects object.
+         * @param browseObjects.indexName - The index in which to perform the request.
+         * @param browseObjects.searchRulesParams - The `searchRules` method parameters.
+         * @param browseObjects.validate - The validator function. It receive the resolved return of the API call. By default, stops when there is less hits returned than the number of maximum hits (1000).
+         * @param browseObjects.aggregator - The function that runs right after the API call has been resolved, allows you to do anything with the response before `validate`.
+         * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `searchRules` method and merged with the transporter requestOptions.
+         */
+        browseRules({ indexName, searchRulesParams, ...browseRulesOptions }, requestOptions) {
+            const params = {
+                hitsPerPage: 1000,
+                ...searchRulesParams,
+            };
+            return createIterablePromise({
+                func: (previousResponse) => {
+                    return this.searchRules({
+                        indexName,
+                        searchRulesParams: {
+                            ...params,
+                            page: previousResponse
+                                ? previousResponse.page + 1
+                                : params.page || 0,
+                        },
+                    }, requestOptions);
+                },
+                validate: (response) => response.nbHits < params.hitsPerPage,
+                ...browseRulesOptions,
+            });
+        },
+        /**
+         * Helper: Iterate on the `searchSynonyms` method of the client to allow aggregating rules of an index.
+         *
+         * @summary Helper method that iterates on the `searchSynonyms` method.
+         * @param browseObjects - The browseObjects object.
+         * @param browseObjects.indexName - The index in which to perform the request.
+         * @param browseObjects.validate - The validator function. It receive the resolved return of the API call. By default, stops when there is less hits returned than the number of maximum hits (1000).
+         * @param browseObjects.aggregator - The function that runs right after the API call has been resolved, allows you to do anything with the response before `validate`.
+         * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `searchSynonyms` method and merged with the transporter requestOptions.
+         */
+        browseSynonyms({ indexName, validate, aggregator, ...browseSynonymsOptions }, requestOptions) {
+            const params = {
+                hitsPerPage: 1000,
+                ...browseSynonymsOptions,
+            };
+            return createIterablePromise({
+                func: (previousResponse) => {
+                    return this.searchSynonyms({
+                        ...params,
+                        indexName,
+                        page: previousResponse
+                            ? previousResponse.page + 1
+                            : browseSynonymsOptions.page || 0,
+                    }, requestOptions);
+                },
+                validate: (response) => response.nbHits < params.hitsPerPage,
+                ...browseSynonymsOptions,
+            });
+        },
         /**
          * Add a new API Key with specific permissions/restrictions.
          *
@@ -2379,6 +2537,9 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
             if (!batchWriteParams) {
                 throw new Error('Parameter `batchWriteParams` is required when calling `batch`.');
             }
+            if (!batchWriteParams.requests) {
+                throw new Error('Parameter `batchWriteParams.requests` is required when calling `batch`.');
+            }
             const requestPath = '/1/indexes/{indexName}/batch'.replace('{indexName}', encodeURIComponent(indexName));
             const headers = {};
             const queryParameters = {};
@@ -2465,10 +2626,10 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
          * @summary Retrieve all index content.
          * @param browse - The browse object.
          * @param browse.indexName - The index in which to perform the request.
-         * @param browse.browseRequest - The browseRequest object.
+         * @param browse.browseParams - The browseParams object.
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        browse({ indexName, browseRequest }, requestOptions) {
+        browse({ indexName, browseParams }, requestOptions) {
             if (!indexName) {
                 throw new Error('Parameter `indexName` is required when calling `browse`.');
             }
@@ -2480,7 +2641,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: browseRequest ? browseRequest : {},
+                data: browseParams ? browseParams : {},
             };
             return transporter.request(request, requestOptions);
         },
@@ -2614,15 +2775,15 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
          * @summary Delete all records matching the query.
          * @param deleteBy - The deleteBy object.
          * @param deleteBy.indexName - The index in which to perform the request.
-         * @param deleteBy.searchParams - The searchParams object.
+         * @param deleteBy.deleteByParams - The deleteByParams object.
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        deleteBy({ indexName, searchParams }, requestOptions) {
+        deleteBy({ indexName, deleteByParams }, requestOptions) {
             if (!indexName) {
                 throw new Error('Parameter `indexName` is required when calling `deleteBy`.');
             }
-            if (!searchParams) {
-                throw new Error('Parameter `searchParams` is required when calling `deleteBy`.');
+            if (!deleteByParams) {
+                throw new Error('Parameter `deleteByParams` is required when calling `deleteBy`.');
             }
             const requestPath = '/1/indexes/{indexName}/deleteByQuery'.replace('{indexName}', encodeURIComponent(indexName));
             const headers = {};
@@ -2632,7 +2793,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: searchParams,
+                data: deleteByParams,
             };
             return transporter.request(request, requestOptions);
         },
@@ -2871,7 +3032,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
          * @param getLogs.type - Type of log entries to retrieve. When omitted, all log entries are retrieved.
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        getLogs({ offset, length, indexName, type }, requestOptions) {
+        getLogs({ offset, length, indexName, type } = {}, requestOptions = undefined) {
             const requestPath = '/1/logs';
             const headers = {};
             const queryParameters = {};
@@ -2939,6 +3100,9 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
             if (!getObjectsParams) {
                 throw new Error('Parameter `getObjectsParams` is required when calling `getObjects`.');
             }
+            if (!getObjectsParams.requests) {
+                throw new Error('Parameter `getObjectsParams.requests` is required when calling `getObjects`.');
+            }
             const requestPath = '/1/indexes/*/objects';
             const headers = {};
             const queryParameters = {};
@@ -3130,7 +3294,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
          * @param hasPendingMappings.getClusters - If the clusters pending mapping state should be on the response.
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        hasPendingMappings({ getClusters }, requestOptions) {
+        hasPendingMappings({ getClusters } = {}, requestOptions = undefined) {
             const requestPath = '/1/clusters/mapping/pending';
             const headers = {};
             const queryParameters = {};
@@ -3189,7 +3353,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
          * @param listIndices.page - Requested page (zero-based). When specified, will retrieve a specific page; the page size is implicitly set to 100. When null, will retrieve all indices (no pagination).
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        listIndices({ page }, requestOptions) {
+        listIndices({ page } = {}, requestOptions = undefined) {
             const requestPath = '/1/indexes';
             const headers = {};
             const queryParameters = {};
@@ -3213,7 +3377,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
          * @param listUserIds.hitsPerPage - Maximum number of objects to retrieve.
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        listUserIds({ page, hitsPerPage }, requestOptions) {
+        listUserIds({ page, hitsPerPage } = {}, requestOptions = undefined) {
             const requestPath = '/1/clusters/mapping';
             const headers = {};
             const queryParameters = {};
@@ -3242,6 +3406,9 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
             if (!batchParams) {
                 throw new Error('Parameter `batchParams` is required when calling `multipleBatch`.');
             }
+            if (!batchParams.requests) {
+                throw new Error('Parameter `batchParams.requests` is required when calling `multipleBatch`.');
+            }
             const requestPath = '/1/indexes/*/batch';
             const headers = {};
             const queryParameters = {};
@@ -3295,19 +3462,19 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
          * @param partialUpdateObject - The partialUpdateObject object.
          * @param partialUpdateObject.indexName - The index in which to perform the request.
          * @param partialUpdateObject.objectID - Unique identifier of an object.
-         * @param partialUpdateObject.attributeOrBuiltInOperation - List of attributes to update.
+         * @param partialUpdateObject.attributesToUpdate - Map of attribute(s) to update.
          * @param partialUpdateObject.createIfNotExists - Creates the record if it does not exist yet.
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        partialUpdateObject({ indexName, objectID, attributeOrBuiltInOperation, createIfNotExists, }, requestOptions) {
+        partialUpdateObject({ indexName, objectID, attributesToUpdate, createIfNotExists, }, requestOptions) {
             if (!indexName) {
                 throw new Error('Parameter `indexName` is required when calling `partialUpdateObject`.');
             }
             if (!objectID) {
                 throw new Error('Parameter `objectID` is required when calling `partialUpdateObject`.');
             }
-            if (!attributeOrBuiltInOperation) {
-                throw new Error('Parameter `attributeOrBuiltInOperation` is required when calling `partialUpdateObject`.');
+            if (!attributesToUpdate) {
+                throw new Error('Parameter `attributesToUpdate` is required when calling `partialUpdateObject`.');
             }
             const requestPath = '/1/indexes/{indexName}/{objectID}/partial'
                 .replace('{indexName}', encodeURIComponent(indexName))
@@ -3322,7 +3489,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: attributeOrBuiltInOperation,
+                data: attributesToUpdate,
             };
             return transporter.request(request, requestOptions);
         },
@@ -3523,17 +3690,17 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
          * @summary Save a batch of rules.
          * @param saveRules - The saveRules object.
          * @param saveRules.indexName - The index in which to perform the request.
-         * @param saveRules.rule - The rule object.
+         * @param saveRules.rules - The rules object.
          * @param saveRules.forwardToReplicas - When true, changes are also propagated to replicas of the given indexName.
          * @param saveRules.clearExistingRules - When true, existing Rules are cleared before adding this batch. When false, existing Rules are kept.
          * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
          */
-        saveRules({ indexName, rule, forwardToReplicas, clearExistingRules, }, requestOptions) {
+        saveRules({ indexName, rules, forwardToReplicas, clearExistingRules, }, requestOptions) {
             if (!indexName) {
                 throw new Error('Parameter `indexName` is required when calling `saveRules`.');
             }
-            if (!rule) {
-                throw new Error('Parameter `rule` is required when calling `saveRules`.');
+            if (!rules) {
+                throw new Error('Parameter `rules` is required when calling `saveRules`.');
             }
             const requestPath = '/1/indexes/{indexName}/rules/batch'.replace('{indexName}', encodeURIComponent(indexName));
             const headers = {};
@@ -3549,7 +3716,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: rule,
+                data: rules,
             };
             return transporter.request(request, requestOptions);
         },
@@ -3760,9 +3927,6 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
             if (!indexName) {
                 throw new Error('Parameter `indexName` is required when calling `searchRules`.');
             }
-            if (!searchRulesParams) {
-                throw new Error('Parameter `searchRulesParams` is required when calling `searchRules`.');
-            }
             const requestPath = '/1/indexes/{indexName}/rules/search'.replace('{indexName}', encodeURIComponent(indexName));
             const headers = {};
             const queryParameters = {};
@@ -3771,7 +3935,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: searchRulesParams,
+                data: searchRulesParams ? searchRulesParams : {},
                 useReadTransporter: true,
                 cacheable: true,
             };
@@ -4071,13 +4235,11 @@ function algoliasearch(appId, apiKey, options) {
         });
     }
     function initPersonalization(initOptions) {
-        if (!initOptions.region) {
-            throw new Error('`region` is missing.');
-        }
-        if (initOptions.region &&
-            (typeof initOptions.region !== 'string' ||
-                !REGIONS.includes(initOptions.region))) {
-            throw new Error(`\`region\` must be one of the following: ${REGIONS.join(', ')}`);
+        if (!initOptions.region ||
+            (initOptions.region &&
+                (typeof initOptions.region !== 'string' ||
+                    !REGIONS.includes(initOptions.region)))) {
+            throw new Error(`\`region\` is required and must be one of the following: ${REGIONS.join(', ')}`);
         }
         return createPersonalizationClient({
             ...commonOptions,