@algolia/client-query-suggestions 5.0.0-alpha.10 → 5.0.0-alpha.101

package/dist/client-query-suggestions.esm.browser.js

@@ -7,53 +7,69 @@ function createAuth(appId, apiKey, authMode = 'WithinHeaders') {
     headers() {
       return authMode === 'WithinHeaders' ? credentials : {};
     },
-
     queryParameters() {
       return authMode === 'WithinQueryParameters' ? credentials : {};
     }
-
   };
 }
 
 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) || '{}');
   }
-
+  function setNamespace(namespace) {
+    getStorage().setItem(namespaceKey, JSON.stringify(namespace));
+  }
+  function removeOutdatedCacheItems() {
+    const timeToLive = options.timeToLive ? options.timeToLive * 1000 : null;
+    const namespace = getNamespace();
+    const filteredNamespaceWithoutOldFormattedCacheItems = Object.fromEntries(Object.entries(namespace).filter(([, cacheItem]) => {
+      return cacheItem.timestamp !== undefined;
+    }));
+    setNamespace(filteredNamespaceWithoutOldFormattedCacheItems);
+    if (!timeToLive) {
+      return;
+    }
+    const filteredNamespaceWithoutExpiredItems = Object.fromEntries(Object.entries(filteredNamespaceWithoutOldFormattedCacheItems).filter(([, cacheItem]) => {
+      const currentTimestamp = new Date().getTime();
+      const isExpired = cacheItem.timestamp + timeToLive < currentTimestamp;
+      return !isExpired;
+    }));
+    setNamespace(filteredNamespaceWithoutExpiredItems);
+  }
   return {
     get(key, defaultValue, events = {
       miss: () => Promise.resolve()
     }) {
       return Promise.resolve().then(() => {
-        const keyAsString = JSON.stringify(key);
-        const value = getNamespace()[keyAsString];
-        return Promise.all([value || defaultValue(), value !== undefined]);
+        removeOutdatedCacheItems();
+        return getNamespace()[JSON.stringify(key)];
+      }).then(value => {
+        return Promise.all([value ? value.value : defaultValue(), value !== undefined]);
       }).then(([value, exists]) => {
         return Promise.all([value, exists || events.miss(value)]);
       }).then(([value]) => value);
     },
-
     set(key, value) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
-        namespace[JSON.stringify(key)] = value;
+        namespace[JSON.stringify(key)] = {
+          timestamp: new Date().getTime(),
+          value
+        };
         getStorage().setItem(namespaceKey, JSON.stringify(namespace));
         return value;
       });
     },
-
     delete(key) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
@@ -61,13 +77,11 @@ function createBrowserLocalStorageCache(options) {
         getStorage().setItem(namespaceKey, JSON.stringify(namespace));
       });
     },
-
     clear() {
       return Promise.resolve().then(() => {
         getStorage().removeItem(namespaceKey);
       });
     }
-
   };
 }
 
@@ -79,30 +93,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()
@@ -113,7 +121,6 @@ function createFallbackableCache(options) {
         }).get(key, defaultValue, events);
       });
     },
-
     set(key, value) {
       return current.set(key, value).catch(() => {
         return createFallbackableCache({
@@ -121,7 +128,6 @@ function createFallbackableCache(options) {
         }).set(key, value);
       });
     },
-
     delete(key) {
       return current.delete(key).catch(() => {
         return createFallbackableCache({
@@ -129,7 +135,6 @@ function createFallbackableCache(options) {
         }).delete(key);
       });
     },
-
     clear() {
       return current.clear().catch(() => {
         return createFallbackableCache({
@@ -137,7 +142,6 @@ function createFallbackableCache(options) {
         }).clear();
       });
     }
-
   };
 }
 
@@ -150,30 +154,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();
     }
-
   };
 }
 
@@ -182,16 +180,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,
@@ -199,7 +195,22 @@ function createStatefulHost(host, status = 'up') {
   };
 }
 
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : String(i);
+}
 function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -210,79 +221,71 @@ 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');
+    super('Unreachable hosts - your application id may be incorrect. If the error persists, please create a ticket at https://support.algolia.com/ sharing steps we can use to reproduce the issue.', stackTrace, 'RetryError');
   }
-
 }
 class ApiError extends ErrorWithStackTrace {
-  constructor(message, status, stackTrace) {
-    super(message, stackTrace, 'ApiError');
-
+  constructor(message, status, stackTrace, name = 'ApiError') {
+    super(message, stackTrace, name);
     _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;
   }
-
+}
+// DetailedApiError is only used by the ingestion client to return more informative error, other clients will use ApiClient.
+class DetailedApiError extends ApiError {
+  constructor(message, status, error, stackTrace) {
+    super(message, status, stackTrace, 'DetailedApiError');
+    _defineProperty(this, "error", void 0);
+    this.error = error;
+  }
 }
 function serializeUrl(host, path, queryParameters) {
   const queryParametersAsString = serializeQueryParameters(queryParameters);
-  let url = `${host.protocol}://${host.url}/${path.charAt(0) === '/' ? path.substr(1) : path}`;
-
+  let url = `${host.protocol}://${host.url}${host.port ? `:${host.port}` : ''}/${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]).replaceAll('+', '%20')}`).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);
@@ -312,14 +315,16 @@ function deserializeFailure({
   content,
   status
 }, stackFrame) {
-  let message = content;
-
   try {
-    message = JSON.parse(content).message;
-  } catch (e) {// ..
+    const parsed = JSON.parse(content);
+    if ('error' in parsed) {
+      return new DetailedApiError(parsed.message, status, parsed.error, stackFrame);
+    }
+    return new ApiError(parsed.message, status, stackFrame);
+  } catch (e) {
+    // ..
   }
-
-  return new ApiError(message, status, stackFrame);
+  return new ApiError(content, status, stackFrame);
 }
 
 function isNetworkError({
@@ -350,9 +355,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
       }
     }
@@ -377,53 +385,49 @@ 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
-         * on the following way: 1 (timed out) > 4 (timed out) > 5 (200).
-         *
-         * Note that, the very next request, we start from the previous timeout.
-         *
-         *  5 (timed out) > 6 (timed out) > 7 ...
-         *
-         * This strategy may need to be reviewed, but is the strategy on the our
-         * current v3 version.
+        /**
+         * Imagine that you have 4 hosts, if timeouts will increase
+         * on the following way: 1 (timed out) > 4 (timed out) > 5 (200).
+         *
+         * Note that, the very next request, we start from the previous timeout.
+         *
+         *  5 (timed out) > 6 (timed out) > 7 ...
+         *
+         * This strategy may need to be reviewed, but is the strategy on the our
+         * current v3 version.
          */
         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.
+    /**
+     * 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 = { ...baseQueryParameters,
+    const queryParameters = {
+      ...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,
@@ -436,25 +440,19 @@ function createTransporter({
         }
       }
     }
-
     let timeoutsCount = 0;
-
     const retry = async (retryableHosts, getTimeout) => {
-      /**
-       * We iterate on each host, until there is no host left.
+      /**
+       * 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,
@@ -463,12 +461,11 @@ function createTransporter({
         connectTimeout: getTimeout(timeoutsCount, timeouts.connect),
         responseTimeout: getTimeout(timeoutsCount, responseTimeout)
       };
-      /**
-       * The stackFrame is pushed to the stackTrace so we
-       * can have information about onRetry and onFailure
-       * decisions.
+      /**
+       * The stackFrame is pushed to the stackTrace so we
+       * can have information about onRetry and onFailure
+       * decisions.
        */
-
       const pushToStackTrace = response => {
         const stackFrame = {
           request: payload,
@@ -479,102 +476,85 @@ 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++;
         }
-        /**
-         * Failures are individually sent to the logger, allowing
-         * the end user to debug / store stack frames even
-         * when a retry error does not happen.
+        /**
+         * Failures are individually sent to the logger, allowing
+         * the end user to debug / store stack frames even
+         * 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.
+        /**
+         * 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);
     };
-    /**
-     * Finally, for each retryable host perform request until we got a non
-     * retryable response. Some notes here:
-     *
-     * 1. The reverse here is applied so we can apply a `pop` later on => more performant.
-     * 2. We also get from the retryable options a timeout multiplier that is tailored
-     * for the current context.
+    /**
+     * Finally, for each retryable host perform request until we got a non
+     * retryable response. Some notes here:
+     *
+     * 1. The reverse here is applied so we can apply a `pop` later on => more performant.
+     * 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`).
+    /**
+     * 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
-       * proxy the request immediately to the requester.
+      /**
+       * On write requests, no cache mechanisms are applied, and we
+       * proxy the request immediately to the requester.
        */
       return retryableRequest(request, requestOptions, isRead);
     }
-
     const createRetryableRequest = () => {
-      /**
-       * Then, we prepare a function factory that contains the construction of
-       * the retryable request. At this point, we may *not* perform the actual
-       * request. But we want to have the function factory ready.
+      /**
+       * Then, we prepare a function factory that contains the construction of
+       * the retryable request. At this point, we may *not* perform the actual
+       * request. But we want to have the function factory ready.
        */
       return retryableRequest(request, requestOptions);
     };
-    /**
-     * Once we have the function factory ready, we need to determine of the
-     * request is "cacheable" - should be cached. Note that, once again,
-     * the user can force this option.
+    /**
+     * Once we have the function factory ready, we need to determine of the
+     * 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 is not "cacheable", we immediately trigger the retryable request, no
+     * need to check cache implementations.
      */
-
     if (cacheable !== true) {
       return createRetryableRequest();
     }
-    /**
-     * If the request is "cacheable", we need to first compute the key to ask
-     * the cache implementations if this request is on progress or if the
-     * response already exists on the cache.
+    /**
+     * If the request is "cacheable", we need to first compute the key to ask
+     * the cache implementations if this request is on progress or if the
+     * response already exists on the cache.
      */
-
-
     const key = {
       request,
       requestOptions,
@@ -583,33 +563,31 @@ function createTransporter({
         headers: baseHeaders
       }
     };
-    /**
-     * With the computed key, we first ask the responses cache
-     * implementation if this request was been resolved before.
+    /**
+     * 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
-       * is a current request with the same key on progress.
+      /**
+       * If the request has never resolved before, we actually ask if there
+       * is a current request with the same key on progress.
        */
       return requestsCache.get(key, () =>
-      /**
-       * Finally, if there is no request in progress with the same key,
-       * this `createRetryableRequest()` will actually trigger the
-       * retryable request.
+      /**
+       * Finally, if there is no request in progress with the same key,
+       * this `createRetryableRequest()` will actually trigger the
+       * retryable request.
        */
       requestsCache.set(key, createRetryableRequest()).then(response => Promise.all([requestsCache.delete(key), response]), err => Promise.all([requestsCache.delete(key), Promise.reject(err)])).then(([_, response]) => response));
     }, {
-      /**
-       * Of course, once we get this response back from the server, we
-       * tell response cache to actually store the received response
-       * to be used later.
+      /**
+       * Of course, once we get this response back from the server, we
+       * tell response cache to actually store the received response
+       * to be used later.
        */
       miss: response => responsesCache.set(key, response)
     });
   }
-
   return {
     hostsCache,
     requester,
@@ -627,17 +605,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;
 }
@@ -659,417 +633,427 @@ const DEFAULT_CONNECT_TIMEOUT_BROWSER = 1000;
 const DEFAULT_READ_TIMEOUT_BROWSER = 2000;
 const DEFAULT_WRITE_TIMEOUT_BROWSER = 30000;
 
-function createXhrRequester() {
-    function send(request) {
-        return new Promise((resolve) => {
-            const baseRequester = new XMLHttpRequest();
-            baseRequester.open(request.method, request.url, true);
-            Object.keys(request.headers).forEach((key) => baseRequester.setRequestHeader(key, request.headers[key]));
-            const createTimeout = (timeout, content) => {
-                return setTimeout(() => {
-                    baseRequester.abort();
-                    resolve({
-                        status: 0,
-                        content,
-                        isTimedOut: true,
-                    });
-                }, timeout);
-            };
-            const connectTimeout = createTimeout(request.connectTimeout, 'Connection timeout');
-            let responseTimeout;
-            baseRequester.onreadystatechange = () => {
-                if (baseRequester.readyState > baseRequester.OPENED &&
-                    responseTimeout === undefined) {
-                    clearTimeout(connectTimeout);
-                    responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
-                }
-            };
-            baseRequester.onerror = () => {
-                // istanbul ignore next
-                if (baseRequester.status === 0) {
-                    clearTimeout(connectTimeout);
-                    clearTimeout(responseTimeout);
-                    resolve({
-                        content: baseRequester.responseText || 'Network request failed',
-                        status: baseRequester.status,
-                        isTimedOut: false,
-                    });
-                }
-            };
-            baseRequester.onload = () => {
-                clearTimeout(connectTimeout);
-                clearTimeout(responseTimeout);
-                resolve({
-                    content: baseRequester.responseText,
-                    status: baseRequester.status,
-                    isTimedOut: false,
-                });
-            };
-            baseRequester.send(request.data);
-        });
-    }
-    return { send };
+function createXhrRequester() {
+    function send(request) {
+        return new Promise((resolve) => {
+            const baseRequester = new XMLHttpRequest();
+            baseRequester.open(request.method, request.url, true);
+            Object.keys(request.headers).forEach((key) => baseRequester.setRequestHeader(key, request.headers[key]));
+            const createTimeout = (timeout, content) => {
+                return setTimeout(() => {
+                    baseRequester.abort();
+                    resolve({
+                        status: 0,
+                        content,
+                        isTimedOut: true,
+                    });
+                }, timeout);
+            };
+            const connectTimeout = createTimeout(request.connectTimeout, 'Connection timeout');
+            let responseTimeout;
+            baseRequester.onreadystatechange = () => {
+                if (baseRequester.readyState > baseRequester.OPENED &&
+                    responseTimeout === undefined) {
+                    clearTimeout(connectTimeout);
+                    responseTimeout = createTimeout(request.responseTimeout, 'Socket timeout');
+                }
+            };
+            baseRequester.onerror = () => {
+                // istanbul ignore next
+                if (baseRequester.status === 0) {
+                    clearTimeout(connectTimeout);
+                    clearTimeout(responseTimeout);
+                    resolve({
+                        content: baseRequester.responseText || 'Network request failed',
+                        status: baseRequester.status,
+                        isTimedOut: false,
+                    });
+                }
+            };
+            baseRequester.onload = () => {
+                clearTimeout(connectTimeout);
+                clearTimeout(responseTimeout);
+                resolve({
+                    content: baseRequester.responseText,
+                    status: baseRequester.status,
+                    isTimedOut: false,
+                });
+            };
+            baseRequester.send(request.data);
+        });
+    }
+    return { send };
 }
 
-// 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.10';
-const REGIONS = ['eu', 'us'];
-function getDefaultHosts(region) {
-    const url = 'query-suggestions.{region}.algolia.com'.replace('{region}', region);
-    return [{ url, accept: 'readWrite', protocol: 'https' }];
-}
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createQuerySuggestionsClient({ appId: appIdOption, apiKey: apiKeyOption, authMode, algoliaAgents, region: regionOption, ...options }) {
-    const auth = createAuth(appIdOption, apiKeyOption, authMode);
-    const transporter = createTransporter({
-        hosts: getDefaultHosts(regionOption),
-        ...options,
-        algoliaAgent: getAlgoliaAgent({
-            algoliaAgents,
-            client: 'QuerySuggestions',
-            version: apiClientVersion,
-        }),
-        baseHeaders: {
-            'content-type': 'text/plain',
-            ...auth.headers(),
-            ...options.baseHeaders,
-        },
-        baseQueryParameters: {
-            ...auth.queryParameters(),
-            ...options.baseQueryParameters,
-        },
-    });
-    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.
-         */
-        get _ua() {
-            return transporter.algoliaAgent.value;
-        },
-        /**
-         * Adds a `segment` to the `x-algolia-agent` sent with every requests.
-         *
-         * @param segment - The algolia agent (user-agent) segment to add.
-         * @param version - The version of the agent.
-         */
-        addAlgoliaAgent(segment, version) {
-            transporter.algoliaAgent.add({ segment, version });
-        },
-        /**
-         * Create a configuration of a Query Suggestions index. There\'s a limit of 100 configurations per application.
-         *
-         * @summary Create a configuration.
-         * @param querySuggestionsIndexWithIndexParam - The querySuggestionsIndexWithIndexParam object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        createConfig(querySuggestionsIndexWithIndexParam, requestOptions) {
-            if (!querySuggestionsIndexWithIndexParam) {
-                throw new Error('Parameter `querySuggestionsIndexWithIndexParam` is required when calling `createConfig`.');
-            }
-            const requestPath = '/1/configs';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: querySuggestionsIndexWithIndexParam,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * This method allow you to send requests to the Algolia REST API.
-         *
-         * @summary Send requests to the Algolia REST API.
-         * @param del - The del object.
-         * @param del.path - The path of the API endpoint to target, anything after the /1 needs to be specified.
-         * @param del.parameters - Query parameters to be applied to the current query.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        del({ path, parameters }, requestOptions) {
-            if (!path) {
-                throw new Error('Parameter `path` is required when calling `del`.');
-            }
-            const requestPath = '/1{path}'.replace('{path}', path);
-            const headers = {};
-            const queryParameters = parameters ? parameters : {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Delete a configuration of a Query Suggestion\'s index. By deleting a configuration, you stop all updates to the underlying query suggestion index. Note that when doing this, the underlying index does not change - existing suggestions remain untouched.
-         *
-         * @summary Delete a configuration.
-         * @param deleteConfig - The deleteConfig object.
-         * @param deleteConfig.indexName - The index in which to perform the request.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteConfig({ indexName }, requestOptions) {
-            if (!indexName) {
-                throw new Error('Parameter `indexName` is required when calling `deleteConfig`.');
-            }
-            const requestPath = '/1/configs/{indexName}'.replace('{indexName}', encodeURIComponent(indexName));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'DELETE',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * This method allow you to send requests to the Algolia REST API.
-         *
-         * @summary Send requests to the Algolia REST API.
-         * @param get - The get object.
-         * @param get.path - The path of the API endpoint to target, anything after the /1 needs to be specified.
-         * @param get.parameters - Query parameters to be applied to the current query.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        get({ path, parameters }, requestOptions) {
-            if (!path) {
-                throw new Error('Parameter `path` is required when calling `get`.');
-            }
-            const requestPath = '/1{path}'.replace('{path}', path);
-            const headers = {};
-            const queryParameters = parameters ? parameters : {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get all the configurations of Query Suggestions. For each index, you get a block of JSON with a list of its configuration settings.
-         *
-         * @summary List configurations.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getAllConfigs(requestOptions) {
-            const requestPath = '/1/configs';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get the configuration of a single Query Suggestions index.
-         *
-         * @summary Get a single configuration.
-         * @param getConfig - The getConfig object.
-         * @param getConfig.indexName - The index in which to perform the request.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getConfig({ indexName }, requestOptions) {
-            if (!indexName) {
-                throw new Error('Parameter `indexName` is required when calling `getConfig`.');
-            }
-            const requestPath = '/1/configs/{indexName}'.replace('{indexName}', encodeURIComponent(indexName));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get the status of a Query Suggestion\'s index. The status includes whether the Query Suggestions index is currently in the process of being built, and the last build time.
-         *
-         * @summary Get configuration status.
-         * @param getConfigStatus - The getConfigStatus object.
-         * @param getConfigStatus.indexName - The index in which to perform the request.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getConfigStatus({ indexName }, requestOptions) {
-            if (!indexName) {
-                throw new Error('Parameter `indexName` is required when calling `getConfigStatus`.');
-            }
-            const requestPath = '/1/configs/{indexName}/status'.replace('{indexName}', encodeURIComponent(indexName));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get the log file of the last build of a single Query Suggestion index.
-         *
-         * @summary Get a log file.
-         * @param getLogFile - The getLogFile object.
-         * @param getLogFile.indexName - The index in which to perform the request.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getLogFile({ indexName }, requestOptions) {
-            if (!indexName) {
-                throw new Error('Parameter `indexName` is required when calling `getLogFile`.');
-            }
-            const requestPath = '/1/logs/{indexName}'.replace('{indexName}', encodeURIComponent(indexName));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * This method allow you to send requests to the Algolia REST API.
-         *
-         * @summary Send requests to the Algolia REST API.
-         * @param post - The post object.
-         * @param post.path - The path of the API endpoint to target, anything after the /1 needs to be specified.
-         * @param post.parameters - Query parameters to be applied to the current query.
-         * @param post.body - The 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.
-         */
-        post({ path, parameters, body }, requestOptions) {
-            if (!path) {
-                throw new Error('Parameter `path` is required when calling `post`.');
-            }
-            const requestPath = '/1{path}'.replace('{path}', path);
-            const headers = {};
-            const queryParameters = parameters ? parameters : {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: body ? body : {},
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * This method allow you to send requests to the Algolia REST API.
-         *
-         * @summary Send requests to the Algolia REST API.
-         * @param put - The put object.
-         * @param put.path - The path of the API endpoint to target, anything after the /1 needs to be specified.
-         * @param put.parameters - Query parameters to be applied to the current query.
-         * @param put.body - The 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.
-         */
-        put({ path, parameters, body }, requestOptions) {
-            if (!path) {
-                throw new Error('Parameter `path` is required when calling `put`.');
-            }
-            const requestPath = '/1{path}'.replace('{path}', path);
-            const headers = {};
-            const queryParameters = parameters ? parameters : {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: body ? body : {},
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Update the configuration of a Query Suggestions index.
-         *
-         * @summary Update a configuration.
-         * @param updateConfig - The updateConfig object.
-         * @param updateConfig.indexName - The index in which to perform the request.
-         * @param updateConfig.querySuggestionsIndexParam - The querySuggestionsIndexParam object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        updateConfig({ indexName, querySuggestionsIndexParam }, requestOptions) {
-            if (!indexName) {
-                throw new Error('Parameter `indexName` is required when calling `updateConfig`.');
-            }
-            if (!querySuggestionsIndexParam) {
-                throw new Error('Parameter `querySuggestionsIndexParam` is required when calling `updateConfig`.');
-            }
-            if (!querySuggestionsIndexParam.sourceIndices) {
-                throw new Error('Parameter `querySuggestionsIndexParam.sourceIndices` is required when calling `updateConfig`.');
-            }
-            const requestPath = '/1/configs/{indexName}'.replace('{indexName}', encodeURIComponent(indexName));
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'PUT',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: querySuggestionsIndexParam,
-            };
-            return transporter.request(request, requestOptions);
-        },
-    };
+// Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
+const apiClientVersion = '5.0.0-alpha.101';
+const REGIONS = ['eu', 'us'];
+function getDefaultHosts(region) {
+    const url = 'query-suggestions.{region}.algolia.com'.replace('{region}', region);
+    return [{ url, accept: 'readWrite', protocol: 'https' }];
+}
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function createQuerySuggestionsClient({ appId: appIdOption, apiKey: apiKeyOption, authMode, algoliaAgents, region: regionOption, ...options }) {
+    const auth = createAuth(appIdOption, apiKeyOption, authMode);
+    const transporter = createTransporter({
+        hosts: getDefaultHosts(regionOption),
+        ...options,
+        algoliaAgent: getAlgoliaAgent({
+            algoliaAgents,
+            client: 'QuerySuggestions',
+            version: apiClientVersion,
+        }),
+        baseHeaders: {
+            'content-type': 'text/plain',
+            ...auth.headers(),
+            ...options.baseHeaders,
+        },
+        baseQueryParameters: {
+            ...auth.queryParameters(),
+            ...options.baseQueryParameters,
+        },
+    });
+    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.
+         */
+        get _ua() {
+            return transporter.algoliaAgent.value;
+        },
+        /**
+         * Adds a `segment` to the `x-algolia-agent` sent with every requests.
+         *
+         * @param segment - The algolia agent (user-agent) segment to add.
+         * @param version - The version of the agent.
+         */
+        addAlgoliaAgent(segment, version) {
+            transporter.algoliaAgent.add({ segment, version });
+        },
+        /**
+         * Create a new Query Suggestions configuration.  You can have up to 100 configurations per Algolia application.
+         *
+         * Required API Key ACLs:
+         * - editSettings.
+         *
+         * @param querySuggestionsConfigurationWithIndex - The querySuggestionsConfigurationWithIndex object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        createConfig(querySuggestionsConfigurationWithIndex, requestOptions) {
+            if (!querySuggestionsConfigurationWithIndex) {
+                throw new Error('Parameter `querySuggestionsConfigurationWithIndex` is required when calling `createConfig`.');
+            }
+            const requestPath = '/1/configs';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: querySuggestionsConfigurationWithIndex,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * This method allow you to send requests to the Algolia REST API.
+         *
+         * @param customDelete - The customDelete object.
+         * @param customDelete.path - Path of the endpoint, anything after \"/1\" must be specified.
+         * @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) {
+            if (!path) {
+                throw new Error('Parameter `path` is required when calling `customDelete`.');
+            }
+            const requestPath = '/1{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 allow you to send requests to the Algolia REST API.
+         *
+         * @param customGet - The customGet object.
+         * @param customGet.path - Path of the endpoint, anything after \"/1\" must be specified.
+         * @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.
+         */
+        customGet({ path, parameters }, requestOptions) {
+            if (!path) {
+                throw new Error('Parameter `path` is required when calling `customGet`.');
+            }
+            const requestPath = '/1{path}'.replace('{path}', path);
+            const headers = {};
+            const queryParameters = parameters ? parameters : {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * This method allow you to send requests to the Algolia REST API.
+         *
+         * @param customPost - The customPost object.
+         * @param customPost.path - Path of the endpoint, anything after \"/1\" must be specified.
+         * @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.
+         */
+        customPost({ path, parameters, body }, requestOptions) {
+            if (!path) {
+                throw new Error('Parameter `path` is required when calling `customPost`.');
+            }
+            const requestPath = '/1{path}'.replace('{path}', path);
+            const headers = {};
+            const queryParameters = parameters ? parameters : {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: body ? body : {},
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * This method allow you to send requests to the Algolia REST API.
+         *
+         * @param customPut - The customPut object.
+         * @param customPut.path - Path of the endpoint, anything after \"/1\" must be specified.
+         * @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.
+         */
+        customPut({ path, parameters, body }, requestOptions) {
+            if (!path) {
+                throw new Error('Parameter `path` is required when calling `customPut`.');
+            }
+            const requestPath = '/1{path}'.replace('{path}', path);
+            const headers = {};
+            const queryParameters = parameters ? parameters : {};
+            const request = {
+                method: 'PUT',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: body ? body : {},
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Delete a Query Suggestions configuration.  Deleting only removes the configuration and stops updates to the Query Suggestions index. The Query Suggestions index itself is not deleted.
+         *
+         * Required API Key ACLs:
+         * - editSettings.
+         *
+         * @param deleteConfig - The deleteConfig object.
+         * @param deleteConfig.indexName - Query Suggestions index name.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        deleteConfig({ indexName }, requestOptions) {
+            if (!indexName) {
+                throw new Error('Parameter `indexName` is required when calling `deleteConfig`.');
+            }
+            const requestPath = '/1/configs/{indexName}'.replace('{indexName}', encodeURIComponent(indexName));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'DELETE',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * List all Query Suggestions configurations of your Algolia application.
+         *
+         * Required API Key ACLs:
+         * - settings.
+         *
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getAllConfigs(requestOptions) {
+            const requestPath = '/1/configs';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get a single Query Suggestions configuration.
+         *
+         * Required API Key ACLs:
+         * - settings.
+         *
+         * @param getConfig - The getConfig object.
+         * @param getConfig.indexName - Query Suggestions index name.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getConfig({ indexName }, requestOptions) {
+            if (!indexName) {
+                throw new Error('Parameter `indexName` is required when calling `getConfig`.');
+            }
+            const requestPath = '/1/configs/{indexName}'.replace('{indexName}', encodeURIComponent(indexName));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Report the status of a Query Suggestions index.
+         *
+         * Required API Key ACLs:
+         * - settings.
+         *
+         * @param getConfigStatus - The getConfigStatus object.
+         * @param getConfigStatus.indexName - Query Suggestions index name.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getConfigStatus({ indexName }, requestOptions) {
+            if (!indexName) {
+                throw new Error('Parameter `indexName` is required when calling `getConfigStatus`.');
+            }
+            const requestPath = '/1/configs/{indexName}/status'.replace('{indexName}', encodeURIComponent(indexName));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get the logs for a single Query Suggestions index.
+         *
+         * Required API Key ACLs:
+         * - settings.
+         *
+         * @param getLogFile - The getLogFile object.
+         * @param getLogFile.indexName - Query Suggestions index name.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getLogFile({ indexName }, requestOptions) {
+            if (!indexName) {
+                throw new Error('Parameter `indexName` is required when calling `getLogFile`.');
+            }
+            const requestPath = '/1/logs/{indexName}'.replace('{indexName}', encodeURIComponent(indexName));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Update a QuerySuggestions configuration.
+         *
+         * Required API Key ACLs:
+         * - editSettings.
+         *
+         * @param updateConfig - The updateConfig object.
+         * @param updateConfig.indexName - Query Suggestions index name.
+         * @param updateConfig.querySuggestionsConfiguration - The querySuggestionsConfiguration object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        updateConfig({ indexName, querySuggestionsConfiguration }, requestOptions) {
+            if (!indexName) {
+                throw new Error('Parameter `indexName` is required when calling `updateConfig`.');
+            }
+            if (!querySuggestionsConfiguration) {
+                throw new Error('Parameter `querySuggestionsConfiguration` is required when calling `updateConfig`.');
+            }
+            if (!querySuggestionsConfiguration.sourceIndices) {
+                throw new Error('Parameter `querySuggestionsConfiguration.sourceIndices` is required when calling `updateConfig`.');
+            }
+            const requestPath = '/1/configs/{indexName}'.replace('{indexName}', encodeURIComponent(indexName));
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'PUT',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: querySuggestionsConfiguration,
+            };
+            return transporter.request(request, requestOptions);
+        },
+    };
 }
 
-// This file is generated, manual changes will be lost - read more on https://github.com/algolia/api-clients-automation.
-function querySuggestionsClient(appId, apiKey, region, options) {
-    if (!appId || typeof appId !== 'string') {
-        throw new Error('`appId` is missing.');
-    }
-    if (!apiKey || typeof apiKey !== 'string') {
-        throw new Error('`apiKey` is missing.');
-    }
-    if (!region ||
-        (region && (typeof region !== 'string' || !REGIONS.includes(region)))) {
-        throw new Error(`\`region\` is required and must be one of the following: ${REGIONS.join(', ')}`);
-    }
-    return createQuerySuggestionsClient({
-        appId,
-        apiKey,
-        region,
-        timeouts: {
-            connect: DEFAULT_CONNECT_TIMEOUT_BROWSER,
-            read: DEFAULT_READ_TIMEOUT_BROWSER,
-            write: DEFAULT_WRITE_TIMEOUT_BROWSER,
-        },
-        requester: createXhrRequester(),
-        algoliaAgents: [{ segment: 'Browser' }],
-        authMode: 'WithinQueryParameters',
-        responsesCache: createMemoryCache(),
-        requestsCache: createMemoryCache({ serializable: false }),
-        hostsCache: createFallbackableCache({
-            caches: [
-                createBrowserLocalStorageCache({ key: `${apiClientVersion}-${appId}` }),
-                createMemoryCache(),
-            ],
-        }),
-        ...options,
-    });
+// Code generated by OpenAPI Generator (https://openapi-generator.tech), manual changes will be lost - read more on https://github.com/algolia/api-clients-automation. DO NOT EDIT.
+function querySuggestionsClient(appId, apiKey, region, options) {
+    if (!appId || typeof appId !== 'string') {
+        throw new Error('`appId` is missing.');
+    }
+    if (!apiKey || typeof apiKey !== 'string') {
+        throw new Error('`apiKey` is missing.');
+    }
+    if (!region ||
+        (region && (typeof region !== 'string' || !REGIONS.includes(region)))) {
+        throw new Error(`\`region\` is required and must be one of the following: ${REGIONS.join(', ')}`);
+    }
+    return createQuerySuggestionsClient({
+        appId,
+        apiKey,
+        region,
+        timeouts: {
+            connect: DEFAULT_CONNECT_TIMEOUT_BROWSER,
+            read: DEFAULT_READ_TIMEOUT_BROWSER,
+            write: DEFAULT_WRITE_TIMEOUT_BROWSER,
+        },
+        requester: createXhrRequester(),
+        algoliaAgents: [{ segment: 'Browser' }],
+        authMode: 'WithinQueryParameters',
+        responsesCache: createMemoryCache(),
+        requestsCache: createMemoryCache({ serializable: false }),
+        hostsCache: createFallbackableCache({
+            caches: [
+                createBrowserLocalStorageCache({ key: `${apiClientVersion}-${appId}` }),
+                createMemoryCache(),
+            ],
+        }),
+        ...options,
+    });
 }
 
 export { apiClientVersion, querySuggestionsClient };