@algolia/client-search 5.0.0-alpha.3 → 5.0.0-alpha.30

package/dist/client-search.esm.browser.js

@@ -7,75 +7,65 @@ function createAuth(appId, apiKey, authMode = 'WithinHeaders') {
     headers() {
       return authMode === 'WithinHeaders' ? credentials : {};
     },
-
     queryParameters() {
       return authMode === 'WithinQueryParameters' ? credentials : {};
     }
-
   };
 }
 
-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);
-
-        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));
+      func(previousResponse).then(response => {
+        if (aggregator) {
+          aggregator(response);
+        }
+        if (validate(response)) {
+          return resolve(response);
+        }
+        if (error && error.validate(response)) {
+          return reject(new Error(error.message(response)));
         }
-      }).catch(error => {
-        reject(error);
+        return setTimeout(() => {
+          retry(response).then(resolve).catch(reject);
+        }, timeout());
+      }).catch(err => {
+        reject(err);
       });
     });
   };
-
   return retry();
 }
 
 function createBrowserLocalStorageCache(options) {
-  let storage; // We've changed the namespace to avoid conflicts with v4, as this version is a huge breaking change
-
+  let storage;
+  // We've changed the namespace to avoid conflicts with v4, as this version is a huge breaking change
   const namespaceKey = `algolia-client-js-${options.key}`;
-
   function getStorage() {
     if (storage === undefined) {
       storage = options.localStorage || window.localStorage;
     }
-
     return storage;
   }
-
   function getNamespace() {
     return JSON.parse(getStorage().getItem(namespaceKey) || '{}');
   }
-
   return {
     get(key, defaultValue, events = {
       miss: () => Promise.resolve()
@@ -88,7 +78,6 @@ function createBrowserLocalStorageCache(options) {
         return Promise.all([value, exists || events.miss(value)]);
       }).then(([value]) => value);
     },
-
     set(key, value) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
@@ -97,7 +86,6 @@ function createBrowserLocalStorageCache(options) {
         return value;
       });
     },
-
     delete(key) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
@@ -105,13 +93,11 @@ function createBrowserLocalStorageCache(options) {
         getStorage().setItem(namespaceKey, JSON.stringify(namespace));
       });
     },
-
     clear() {
       return Promise.resolve().then(() => {
         getStorage().removeItem(namespaceKey);
       });
     }
-
   };
 }
 
@@ -123,30 +109,24 @@ function createNullCache() {
       const value = defaultValue();
       return value.then(result => Promise.all([result, events.miss(result)])).then(([result]) => result);
     },
-
     set(_key, value) {
       return Promise.resolve(value);
     },
-
     delete(_key) {
       return Promise.resolve();
     },
-
     clear() {
       return Promise.resolve();
     }
-
   };
 }
 
 function createFallbackableCache(options) {
   const caches = [...options.caches];
   const current = caches.shift();
-
   if (current === undefined) {
     return createNullCache();
   }
-
   return {
     get(key, defaultValue, events = {
       miss: () => Promise.resolve()
@@ -157,7 +137,6 @@ function createFallbackableCache(options) {
         }).get(key, defaultValue, events);
       });
     },
-
     set(key, value) {
       return current.set(key, value).catch(() => {
         return createFallbackableCache({
@@ -165,7 +144,6 @@ function createFallbackableCache(options) {
         }).set(key, value);
       });
     },
-
     delete(key) {
       return current.delete(key).catch(() => {
         return createFallbackableCache({
@@ -173,7 +151,6 @@ function createFallbackableCache(options) {
         }).delete(key);
       });
     },
-
     clear() {
       return current.clear().catch(() => {
         return createFallbackableCache({
@@ -181,7 +158,6 @@ function createFallbackableCache(options) {
         }).clear();
       });
     }
-
   };
 }
 
@@ -194,30 +170,24 @@ function createMemoryCache(options = {
       miss: () => Promise.resolve()
     }) {
       const keyAsString = JSON.stringify(key);
-
       if (keyAsString in cache) {
         return Promise.resolve(options.serializable ? JSON.parse(cache[keyAsString]) : cache[keyAsString]);
       }
-
       const promise = defaultValue();
       return promise.then(value => events.miss(value)).then(() => promise);
     },
-
     set(key, value) {
       cache[JSON.stringify(key)] = options.serializable ? JSON.stringify(value) : value;
       return Promise.resolve(value);
     },
-
     delete(key) {
       delete cache[JSON.stringify(key)];
       return Promise.resolve();
     },
-
     clear() {
       cache = {};
       return Promise.resolve();
     }
-
   };
 }
 
@@ -226,16 +196,14 @@ function createMemoryCache(options = {
 const EXPIRATION_DELAY = 2 * 60 * 1000;
 function createStatefulHost(host, status = 'up') {
   const lastUpdate = Date.now();
-
   function isUp() {
     return status === 'up' || Date.now() - lastUpdate > EXPIRATION_DELAY;
   }
-
   function isTimedOut() {
     return status === 'timed out' && Date.now() - lastUpdate <= EXPIRATION_DELAY;
   }
-
-  return { ...host,
+  return {
+    ...host,
     status,
     lastUpdate,
     isUp,
@@ -254,92 +222,74 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
 
 class AlgoliaError extends Error {
   constructor(message, name) {
     super(message);
-
     _defineProperty(this, "name", 'AlgoliaError');
-
     if (name) {
       this.name = name;
     }
   }
-
 }
 class ErrorWithStackTrace extends AlgoliaError {
   constructor(message, stackTrace, name) {
-    super(message, name); // the array and object should be frozen to reflect the stackTrace at the time of the error
-
+    super(message, name);
+    // the array and object should be frozen to reflect the stackTrace at the time of the error
     _defineProperty(this, "stackTrace", void 0);
-
     this.stackTrace = stackTrace;
   }
-
 }
 class RetryError extends ErrorWithStackTrace {
   constructor(stackTrace) {
     super('Unreachable hosts - your application id may be incorrect. If the error persists, contact support@algolia.com.', stackTrace, 'RetryError');
   }
-
 }
 class ApiError extends ErrorWithStackTrace {
   constructor(message, status, stackTrace) {
     super(message, stackTrace, 'ApiError');
-
     _defineProperty(this, "status", void 0);
-
     this.status = status;
   }
-
 }
 class DeserializationError extends AlgoliaError {
   constructor(message, response) {
     super(message, 'DeserializationError');
-
     _defineProperty(this, "response", void 0);
-
     this.response = response;
   }
-
 }
 
 function shuffle(array) {
   const shuffledArray = array;
-
   for (let c = array.length - 1; c > 0; c--) {
     const b = Math.floor(Math.random() * (c + 1));
     const a = array[c];
     shuffledArray[c] = array[b];
     shuffledArray[b] = a;
   }
-
   return shuffledArray;
 }
 function serializeUrl(host, path, queryParameters) {
   const queryParametersAsString = serializeQueryParameters(queryParameters);
   let url = `${host.protocol}://${host.url}/${path.charAt(0) === '/' ? path.substr(1) : path}`;
-
   if (queryParametersAsString.length) {
     url += `?${queryParametersAsString}`;
   }
-
   return url;
 }
 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) {
     return undefined;
   }
-
-  const data = Array.isArray(request.data) ? request.data : { ...request.data,
+  const data = Array.isArray(request.data) ? request.data : {
+    ...request.data,
     ...requestOptions.data
   };
   return JSON.stringify(data);
@@ -370,12 +320,11 @@ function deserializeFailure({
   status
 }, stackFrame) {
   let message = content;
-
   try {
     message = JSON.parse(content).message;
-  } catch (e) {// ..
+  } catch (e) {
+    // ..
   }
-
   return new ApiError(message, status, stackFrame);
 }
 
@@ -407,9 +356,12 @@ function stackFrameWithoutCredentials(stackFrame) {
   const modifiedHeaders = stackFrame.request.headers['x-algolia-api-key'] ? {
     'x-algolia-api-key': '*****'
   } : {};
-  return { ...stackFrame,
-    request: { ...stackFrame.request,
-      headers: { ...stackFrame.request.headers,
+  return {
+    ...stackFrame,
+    request: {
+      ...stackFrame.request,
+      headers: {
+        ...stackFrame.request.headers,
         ...modifiedHeaders
       }
     }
@@ -434,13 +386,12 @@ function createTransporter({
       });
     }));
     const hostsUp = statefulHosts.filter(host => host.isUp());
-    const hostsTimedOut = statefulHosts.filter(host => host.isTimedOut()); // Note, we put the hosts that previously timed out on the end of the list.
-
+    const hostsTimedOut = statefulHosts.filter(host => host.isTimedOut());
+    // Note, we put the hosts that previously timed out on the end of the list.
     const hostsAvailable = [...hostsUp, ...hostsTimedOut];
     const compatibleHostsAvailable = hostsAvailable.length > 0 ? hostsAvailable : compatibleHosts;
     return {
       hosts: compatibleHostsAvailable,
-
       getTimeout(timeoutsCount, baseTimeout) {
         /**
          * Imagine that you have 4 hosts, if timeouts will increase
@@ -456,29 +407,28 @@ function createTransporter({
         const timeoutMultiplier = hostsTimedOut.length === 0 && timeoutsCount === 0 ? 1 : hostsTimedOut.length + 3 + timeoutsCount;
         return timeoutMultiplier * baseTimeout;
       }
-
     };
   }
-
   async function retryableRequest(request, requestOptions, isRead = true) {
     const stackTrace = [];
     /**
      * First we prepare the payload that do not depend from hosts.
      */
-
     const data = serializeData(request, requestOptions);
-    const headers = serializeHeaders(baseHeaders, request.headers, requestOptions.headers); // On `GET`, the data is proxied to query parameters.
-
-    const dataQueryParameters = request.method === 'GET' ? { ...request.data,
+    const headers = serializeHeaders(baseHeaders, request.headers, requestOptions.headers);
+    // On `GET`, the data is proxied to query parameters.
+    const dataQueryParameters = request.method === 'GET' ? {
+      ...request.data,
       ...requestOptions.data
     } : {};
     const queryParameters = {
-      'x-algolia-agent': algoliaAgent.value,
       ...baseQueryParameters,
       ...request.queryParameters,
       ...dataQueryParameters
     };
-
+    if (algoliaAgent.value) {
+      queryParameters['x-algolia-agent'] = algoliaAgent.value;
+    }
     if (requestOptions && requestOptions.queryParameters) {
       for (const key of Object.keys(requestOptions.queryParameters)) {
         // We want to keep `undefined` and `null` values,
@@ -491,25 +441,19 @@ function createTransporter({
         }
       }
     }
-
     let timeoutsCount = 0;
-
     const retry = async (retryableHosts, getTimeout) => {
       /**
        * We iterate on each host, until there is no host left.
        */
       const host = retryableHosts.pop();
-
       if (host === undefined) {
         throw new RetryError(stackTraceWithoutCredentials(stackTrace));
       }
-
       let responseTimeout = requestOptions.timeout;
-
       if (responseTimeout === undefined) {
         responseTimeout = isRead ? timeouts.read : timeouts.write;
       }
-
       const payload = {
         data,
         headers,
@@ -523,7 +467,6 @@ function createTransporter({
        * can have information about onRetry and onFailure
        * decisions.
        */
-
       const pushToStackTrace = response => {
         const stackFrame = {
           request: payload,
@@ -534,12 +477,10 @@ function createTransporter({
         stackTrace.push(stackFrame);
         return stackFrame;
       };
-
       const response = await requester.send(payload);
-
       if (isRetryable(response)) {
-        const stackFrame = pushToStackTrace(response); // If response is a timeout, we increase the number of timeouts so we can increase the timeout later.
-
+        const stackFrame = pushToStackTrace(response);
+        // If response is a timeout, we increase the number of timeouts so we can increase the timeout later.
         if (response.isTimedOut) {
           timeoutsCount++;
         }
@@ -549,23 +490,18 @@ function createTransporter({
          * when a retry error does not happen.
          */
         // eslint-disable-next-line no-console -- this will be fixed by exposing a `logger` to the transporter
-
-
         console.log('Retryable failure', stackFrameWithoutCredentials(stackFrame));
         /**
          * We also store the state of the host in failure cases. If the host, is
          * down it will remain down for the next 2 minutes. In a timeout situation,
          * this host will be added end of the list of hosts on the next request.
          */
-
         await hostsCache.set(host, createStatefulHost(host, response.isTimedOut ? 'timed out' : 'down'));
         return retry(retryableHosts, getTimeout);
       }
-
       if (isSuccess(response)) {
         return deserializeSuccess(response);
       }
-
       pushToStackTrace(response);
       throw deserializeFailure(response, stackTrace);
     };
@@ -577,20 +513,16 @@ function createTransporter({
      * 2. We also get from the retryable options a timeout multiplier that is tailored
      * for the current context.
      */
-
-
     const compatibleHosts = hosts.filter(host => host.accept === 'readWrite' || (isRead ? host.accept === 'read' : host.accept === 'write'));
     const options = await createRetryableOptions(compatibleHosts);
     return retry([...options.hosts].reverse(), options.getTimeout);
   }
-
   function createRequest(request, requestOptions = {}) {
     /**
      * A read request is either a `GET` request, or a request that we make
      * via the `read` transporter (e.g. `search`).
      */
     const isRead = request.useReadTransporter || request.method === 'GET';
-
     if (!isRead) {
       /**
        * On write requests, no cache mechanisms are applied, and we
@@ -598,7 +530,6 @@ function createTransporter({
        */
       return retryableRequest(request, requestOptions, isRead);
     }
-
     const createRetryableRequest = () => {
       /**
        * Then, we prepare a function factory that contains the construction of
@@ -612,14 +543,11 @@ function createTransporter({
      * request is "cacheable" - should be cached. Note that, once again,
      * the user can force this option.
      */
-
-
     const cacheable = requestOptions.cacheable || request.cacheable;
     /**
      * If is not "cacheable", we immediately trigger the retryable request, no
      * need to check cache implementations.
      */
-
     if (cacheable !== true) {
       return createRetryableRequest();
     }
@@ -628,8 +556,6 @@ function createTransporter({
      * the cache implementations if this request is on progress or if the
      * response already exists on the cache.
      */
-
-
     const key = {
       request,
       requestOptions,
@@ -642,7 +568,6 @@ function createTransporter({
      * With the computed key, we first ask the responses cache
      * implementation if this request was been resolved before.
      */
-
     return responsesCache.get(key, () => {
       /**
        * If the request has never resolved before, we actually ask if there
@@ -664,7 +589,6 @@ function createTransporter({
       miss: response => responsesCache.set(key, response)
     });
   }
-
   return {
     hostsCache,
     requester,
@@ -682,17 +606,13 @@ function createTransporter({
 function createAlgoliaAgent(version) {
   const algoliaAgent = {
     value: `Algolia for JavaScript (${version})`,
-
     add(options) {
       const addedAlgoliaAgent = `; ${options.segment}${options.version !== undefined ? ` (${options.version})` : ''}`;
-
       if (algoliaAgent.value.indexOf(addedAlgoliaAgent) === -1) {
         algoliaAgent.value = `${algoliaAgent.value}${addedAlgoliaAgent}`;
       }
-
       return algoliaAgent;
     }
-
   };
   return algoliaAgent;
 }
@@ -767,7 +687,7 @@ function createXhrRequester() {
 }
 
 // This file is generated, manual changes will be lost - read more on https://github.com/algolia/api-clients-automation.
-const apiClientVersion = '5.0.0-alpha.3';
+const apiClientVersion = '5.0.0-alpha.30';
 function getDefaultHosts(appId) {
     return [
         {
@@ -821,6 +741,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.
          */
@@ -837,38 +770,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)) {
@@ -886,12 +838,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.
          *
@@ -1025,6 +1064,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 = {};
@@ -1111,10 +1153,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`.');
             }
@@ -1126,7 +1168,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: browseRequest ? browseRequest : {},
+                data: browseParams ? browseParams : {},
             };
             return transporter.request(request, requestOptions);
         },
@@ -1260,15 +1302,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 = {};
@@ -1278,7 +1320,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: searchParams,
+                data: deleteByParams,
             };
             return transporter.request(request, requestOptions);
         },
@@ -1517,7 +1559,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 = {};
@@ -1585,6 +1627,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 = {};
@@ -1776,7 +1821,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 = {};
@@ -1835,7 +1880,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 = {};
@@ -1859,7 +1904,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 = {};
@@ -1888,6 +1933,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 = {};
@@ -1941,19 +1989,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))
@@ -1968,7 +2016,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: attributeOrBuiltInOperation,
+                data: attributesToUpdate,
             };
             return transporter.request(request, requestOptions);
         },
@@ -2169,17 +2217,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 = {};
@@ -2195,7 +2243,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: rule,
+                data: rules,
             };
             return transporter.request(request, requestOptions);
         },
@@ -2406,9 +2454,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 = {};
@@ -2417,7 +2462,7 @@ function createSearchClient({ appId: appIdOption, apiKey: apiKeyOption, authMode
                 path: requestPath,
                 queryParameters,
                 headers,
-                data: searchRulesParams,
+                data: searchRulesParams ? searchRulesParams : {},
                 useReadTransporter: true,
                 cacheable: true,
             };