@algolia/client-personalization 5.0.0-alpha.9 → 5.0.0-alpha.91

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

@@ -7,31 +7,25 @@ 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) || '{}');
   }
-
   return {
     get(key, defaultValue, events = {
       miss: () => Promise.resolve()
@@ -44,7 +38,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();
@@ -53,7 +46,6 @@ function createBrowserLocalStorageCache(options) {
         return value;
       });
     },
-
     delete(key) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
@@ -61,13 +53,11 @@ function createBrowserLocalStorageCache(options) {
         getStorage().setItem(namespaceKey, JSON.stringify(namespace));
       });
     },
-
     clear() {
       return Promise.resolve().then(() => {
         getStorage().removeItem(namespaceKey);
       });
     }
-
   };
 }
 
@@ -79,30 +69,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 +97,6 @@ function createFallbackableCache(options) {
         }).get(key, defaultValue, events);
       });
     },
-
     set(key, value) {
       return current.set(key, value).catch(() => {
         return createFallbackableCache({
@@ -121,7 +104,6 @@ function createFallbackableCache(options) {
         }).set(key, value);
       });
     },
-
     delete(key) {
       return current.delete(key).catch(() => {
         return createFallbackableCache({
@@ -129,7 +111,6 @@ function createFallbackableCache(options) {
         }).delete(key);
       });
     },
-
     clear() {
       return current.clear().catch(() => {
         return createFallbackableCache({
@@ -137,7 +118,6 @@ function createFallbackableCache(options) {
         }).clear();
       });
     }
-
   };
 }
 
@@ -150,30 +130,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 +156,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,
@@ -200,6 +172,7 @@ function createStatefulHost(host, status = 'up') {
 }
 
 function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -210,79 +183,85 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
 
 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');
-
+  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}`;
-
   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);
@@ -312,14 +291,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 +331,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 +361,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 +416,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 +437,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 +452,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 +539,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 +581,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,349 +609,349 @@ 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.9';
-const REGIONS = ['eu', 'us'];
-function getDefaultHosts(region) {
-    const url = 'personalization.{region}.algolia.com'.replace('{region}', region);
-    return [{ url, accept: 'readWrite', protocol: 'https' }];
-}
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function createPersonalizationClient({ 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: 'Personalization',
-            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 });
-        },
-        /**
-         * 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 the user profile and all its associated data.  Returns, as part of the response, a date until which the data can safely be considered as deleted for the given user. This means if you send events for the given user before this date, they will be ignored. Any data received after the deletedUntil date will start building a new user profile.  It might take a couple hours for the deletion request to be fully processed.
-         *
-         * @summary Delete a user profile.
-         * @param deleteUserProfile - The deleteUserProfile object.
-         * @param deleteUserProfile.userToken - UserToken representing the user for which to fetch the Personalization profile.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        deleteUserProfile({ userToken }, requestOptions) {
-            if (!userToken) {
-                throw new Error('Parameter `userToken` is required when calling `deleteUserProfile`.');
-            }
-            const requestPath = '/1/profiles/{userToken}'.replace('{userToken}', encodeURIComponent(userToken));
-            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);
-        },
-        /**
-         * The strategy contains information on the events and facets that impact user profiles and personalized search results.
-         *
-         * @summary Get the current strategy.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getPersonalizationStrategy(requestOptions) {
-            const requestPath = '/1/strategies/personalization';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'GET',
-                path: requestPath,
-                queryParameters,
-                headers,
-            };
-            return transporter.request(request, requestOptions);
-        },
-        /**
-         * Get the user profile built from Personalization strategy.  The profile is structured by facet name used in the strategy. Each facet value is mapped to its score. Each score represents the user affinity for a specific facet value given the userToken past events and the Personalization strategy defined. Scores are bounded to 20. The last processed event timestamp is provided using the ISO 8601 format for debugging purposes.
-         *
-         * @summary Get a user profile.
-         * @param getUserTokenProfile - The getUserTokenProfile object.
-         * @param getUserTokenProfile.userToken - UserToken representing the user for which to fetch the Personalization profile.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        getUserTokenProfile({ userToken }, requestOptions) {
-            if (!userToken) {
-                throw new Error('Parameter `userToken` is required when calling `getUserTokenProfile`.');
-            }
-            const requestPath = '/1/profiles/personalization/{userToken}'.replace('{userToken}', encodeURIComponent(userToken));
-            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);
-        },
-        /**
-         * A strategy defines the events and facets that impact user profiles and personalized search results.
-         *
-         * @summary Set a new strategy.
-         * @param personalizationStrategyParams - The personalizationStrategyParams object.
-         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
-         */
-        setPersonalizationStrategy(personalizationStrategyParams, requestOptions) {
-            if (!personalizationStrategyParams) {
-                throw new Error('Parameter `personalizationStrategyParams` is required when calling `setPersonalizationStrategy`.');
-            }
-            if (!personalizationStrategyParams.eventScoring) {
-                throw new Error('Parameter `personalizationStrategyParams.eventScoring` is required when calling `setPersonalizationStrategy`.');
-            }
-            if (!personalizationStrategyParams.facetScoring) {
-                throw new Error('Parameter `personalizationStrategyParams.facetScoring` is required when calling `setPersonalizationStrategy`.');
-            }
-            if (!personalizationStrategyParams.personalizationImpact) {
-                throw new Error('Parameter `personalizationStrategyParams.personalizationImpact` is required when calling `setPersonalizationStrategy`.');
-            }
-            const requestPath = '/1/strategies/personalization';
-            const headers = {};
-            const queryParameters = {};
-            const request = {
-                method: 'POST',
-                path: requestPath,
-                queryParameters,
-                headers,
-                data: personalizationStrategyParams,
-            };
-            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.91';
+const REGIONS = ['eu', 'us'];
+function getDefaultHosts(region) {
+    const url = 'personalization.{region}.algolia.com'.replace('{region}', region);
+    return [{ url, accept: 'readWrite', protocol: 'https' }];
+}
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+function createPersonalizationClient({ 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: 'Personalization',
+            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 });
+        },
+        /**
+         * 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 - Path of the endpoint, anything after \"/1\" must be specified.
+         * @param del.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.
+         */
+        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 the user profile and all its associated data.  Returns, as part of the response, a date until which the data can safely be considered as deleted for the given user. This means if you send events for the given user before this date, they will be ignored. Any data received after the deletedUntil date will start building a new user profile.  It might take a couple hours for the deletion request to be fully processed.
+         *
+         * @summary Delete a user profile.
+         * @param deleteUserProfile - The deleteUserProfile object.
+         * @param deleteUserProfile.userToken - UserToken representing the user for which to fetch the Personalization profile.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        deleteUserProfile({ userToken }, requestOptions) {
+            if (!userToken) {
+                throw new Error('Parameter `userToken` is required when calling `deleteUserProfile`.');
+            }
+            const requestPath = '/1/profiles/{userToken}'.replace('{userToken}', encodeURIComponent(userToken));
+            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 - Path of the endpoint, anything after \"/1\" must be specified.
+         * @param get.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.
+         */
+        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);
+        },
+        /**
+         * The strategy contains information on the events and facets that impact user profiles and personalized search results.
+         *
+         * @summary Get the current strategy.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getPersonalizationStrategy(requestOptions) {
+            const requestPath = '/1/strategies/personalization';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'GET',
+                path: requestPath,
+                queryParameters,
+                headers,
+            };
+            return transporter.request(request, requestOptions);
+        },
+        /**
+         * Get the user profile built from Personalization strategy.  The profile is structured by facet name used in the strategy. Each facet value is mapped to its score. Each score represents the user affinity for a specific facet value given the userToken past events and the Personalization strategy defined. Scores are bounded to 20. The last processed event timestamp is provided using the ISO 8601 format for debugging purposes.
+         *
+         * @summary Get a user profile.
+         * @param getUserTokenProfile - The getUserTokenProfile object.
+         * @param getUserTokenProfile.userToken - UserToken representing the user for which to fetch the Personalization profile.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        getUserTokenProfile({ userToken }, requestOptions) {
+            if (!userToken) {
+                throw new Error('Parameter `userToken` is required when calling `getUserTokenProfile`.');
+            }
+            const requestPath = '/1/profiles/personalization/{userToken}'.replace('{userToken}', encodeURIComponent(userToken));
+            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 - Path of the endpoint, anything after \"/1\" must be specified.
+         * @param post.parameters - Query parameters to apply to the current query.
+         * @param post.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.
+         */
+        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 - Path of the endpoint, anything after \"/1\" must be specified.
+         * @param put.parameters - Query parameters to apply to the current query.
+         * @param put.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.
+         */
+        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);
+        },
+        /**
+         * A strategy defines the events and facets that impact user profiles and personalized search results.
+         *
+         * @summary Set a new strategy.
+         * @param personalizationStrategyParams - The personalizationStrategyParams object.
+         * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+         */
+        setPersonalizationStrategy(personalizationStrategyParams, requestOptions) {
+            if (!personalizationStrategyParams) {
+                throw new Error('Parameter `personalizationStrategyParams` is required when calling `setPersonalizationStrategy`.');
+            }
+            if (!personalizationStrategyParams.eventScoring) {
+                throw new Error('Parameter `personalizationStrategyParams.eventScoring` is required when calling `setPersonalizationStrategy`.');
+            }
+            if (!personalizationStrategyParams.facetScoring) {
+                throw new Error('Parameter `personalizationStrategyParams.facetScoring` is required when calling `setPersonalizationStrategy`.');
+            }
+            if (!personalizationStrategyParams.personalizationImpact) {
+                throw new Error('Parameter `personalizationStrategyParams.personalizationImpact` is required when calling `setPersonalizationStrategy`.');
+            }
+            const requestPath = '/1/strategies/personalization';
+            const headers = {};
+            const queryParameters = {};
+            const request = {
+                method: 'POST',
+                path: requestPath,
+                queryParameters,
+                headers,
+                data: personalizationStrategyParams,
+            };
+            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 personalizationClient(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 createPersonalizationClient({
-        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 personalizationClient(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 createPersonalizationClient({
+        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, personalizationClient };